To protect your data, the CISO officer has suggested users to enable GitLab 2FA as soon as possible.

mod.rs 21 KB
Newer Older
Isaac Oscar Gariano's avatar
Isaac Oscar Gariano committed
1
// Copyright 2017 The Australian National University
2
//
Isaac Oscar Gariano's avatar
Isaac Oscar Gariano committed
3
4
5
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
6
//
Isaac Oscar Gariano's avatar
Isaac Oscar Gariano committed
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
Isaac Oscar Gariano's avatar
Isaac Oscar Gariano committed
9
10
11
12
13
14
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

qinsoon's avatar
qinsoon committed
15
16
#![allow(dead_code)]

qinsoon's avatar
qinsoon committed
17
/// Tree pattern matching instruction selection.
18
19
20
pub mod inst_sel;

mod codegen;
qinsoon's avatar
qinsoon committed
21
22
23
/// CodeGenerator trait serves as an interface to the backend code generator, which
/// may generate assembly code or binary (not implemented yet)
use compiler::backend::x86_64::codegen::CodeGenerator;
24

qinsoon's avatar
qinsoon committed
25
26
27
28
29
30
/// assembly backend as AOT compiler
mod asm_backend;
use compiler::backend::x86_64::asm_backend::ASMCodeGen;

// re-export a few functions for AOT compilation
#[cfg(feature = "aot")]
31
pub use compiler::backend::x86_64::asm_backend::emit_code;
qinsoon's avatar
qinsoon committed
32
#[cfg(feature = "aot")]
33
pub use compiler::backend::x86_64::asm_backend::emit_context;
qinsoon's avatar
qinsoon committed
34
#[cfg(feature = "aot")]
qinsoon's avatar
qinsoon committed
35
pub use compiler::backend::x86_64::asm_backend::emit_context_with_reloc;
36
37
#[cfg(feature = "aot")]
pub use compiler::backend::x86_64::asm_backend::spill_rewrite;
38

39
40
use utils::Address;
use utils::ByteSize;
41
42
use ast::ptr::P;
use ast::ir::*;
qinsoon's avatar
qinsoon committed
43
use ast::types::*;
qinsoon's avatar
qinsoon committed
44
use compiler::backend::RegGroup;
qinsoon's avatar
qinsoon committed
45

46
use utils::LinkedHashMap;
47
48
use std::collections::HashMap;

49
// number of normal callee saved registers (excluding RSP and RBP)
qinsoon's avatar
qinsoon committed
50
pub const CALLEE_SAVED_COUNT: usize = 5;
51

qinsoon's avatar
qinsoon committed
52
/// a macro to declare a set of general purpose registers that are aliased to the first one
qinsoon's avatar
qinsoon committed
53
macro_rules! GPR_ALIAS {
qinsoon's avatar
qinsoon committed
54
55
    ($alias: ident: ($id64: expr, $r64: ident) ->
     $r32: ident, $r16: ident, $r8l: ident, $r8h: ident) => {
qinsoon's avatar
qinsoon committed
56
57
58
59
60
61
62
        lazy_static!{
            pub static ref $r64 : P<Value> = GPR!($id64,    stringify!($r64), UINT64_TYPE);
            pub static ref $r32 : P<Value> = GPR!($id64 +1, stringify!($r32), UINT32_TYPE);
            pub static ref $r16 : P<Value> = GPR!($id64 +2, stringify!($r16), UINT16_TYPE);
            pub static ref $r8l : P<Value> = GPR!($id64 +3, stringify!($r8l), UINT8_TYPE);
            pub static ref $r8h : P<Value> = GPR!($id64 +4, stringify!($r8h), UINT8_TYPE);

qinsoon's avatar
qinsoon committed
63
64
            pub static ref $alias : [P<Value>; 5] = [$r64.clone(), $r32.clone(), $r16.clone(),
                                                     $r8l.clone(), $r8h.clone()];
qinsoon's avatar
qinsoon committed
65
66
67
        }
    };

qinsoon's avatar
qinsoon committed
68
69
70
71
72
73
74
    ($alias: ident: ($id64: expr, $r64: ident) -> $r32: ident, $r16: ident, $r8: ident) => {
        lazy_static!{
            pub static ref $r64 : P<Value> = GPR!($id64,    stringify!($r64), UINT64_TYPE);
            pub static ref $r32 : P<Value> = GPR!($id64 +1, stringify!($r32), UINT32_TYPE);
            pub static ref $r16 : P<Value> = GPR!($id64 +2, stringify!($r16), UINT16_TYPE);
            pub static ref $r8  : P<Value> = GPR!($id64 +3, stringify!($r8) , UINT8_TYPE );

qinsoon's avatar
qinsoon committed
75
76
            pub static ref $alias : [P<Value>; 4] = [$r64.clone(), $r32.clone(),
                                                     $r16.clone(), $r8.clone()];
qinsoon's avatar
qinsoon committed
77
78
79
80
81
        }
    };

    ($alias: ident: ($id64: expr, $r64: ident)) => {
        lazy_static!{
qinsoon's avatar
qinsoon committed
82
            pub static ref $r64 : P<Value> = GPR!($id64, stringify!($r64), UINT64_TYPE);
qinsoon's avatar
qinsoon committed
83

qinsoon's avatar
qinsoon committed
84
85
            pub static ref $alias : [P<Value>; 4] = [$r64.clone(), $r64.clone(),
                                                     $r64.clone(), $r64.clone()];
qinsoon's avatar
qinsoon committed
86
87
88
89
        }
    };
}

qinsoon's avatar
qinsoon committed
90
/// a macro to declare a general purpose register
91
macro_rules! GPR {
qinsoon's avatar
qinsoon committed
92
    ($id:expr, $name: expr, $ty: ident) => {
qinsoon's avatar
qinsoon committed
93
94
        {
            P(Value {
qinsoon's avatar
qinsoon committed
95
                hdr: MuEntityHeader::named($id, $name.to_string()),
qinsoon's avatar
qinsoon committed
96
                ty: $ty.clone(),
qinsoon's avatar
qinsoon committed
97
                v: Value_::SSAVar($id)
qinsoon's avatar
qinsoon committed
98
99
            })
        }
qinsoon's avatar
qinsoon committed
100
101
102
    };
}

qinsoon's avatar
qinsoon committed
103
/// a macro to declare a floating point register
qinsoon's avatar
qinsoon committed
104
macro_rules! FPR {
qinsoon's avatar
qinsoon committed
105
    ($id:expr, $name: expr) => {
qinsoon's avatar
qinsoon committed
106
107
        {
            P(Value {
qinsoon's avatar
qinsoon committed
108
                hdr: MuEntityHeader::named($id, $name.to_string()),
qinsoon's avatar
qinsoon committed
109
                ty: DOUBLE_TYPE.clone(),
qinsoon's avatar
qinsoon committed
110
                v: Value_::SSAVar($id)
qinsoon's avatar
qinsoon committed
111
112
            })
        }
qinsoon's avatar
qinsoon committed
113
114
115
    };
}

qinsoon's avatar
qinsoon committed
116
117
118
// declare all general purpose registers for x86_64
// non 64-bit registers are alias of its 64-bit one

119
120
GPR_ALIAS!(RAX_ALIAS: (0, RAX)  -> EAX, AX , AL, AH);
GPR_ALIAS!(RCX_ALIAS: (5, RCX)  -> ECX, CX , CL, CH);
121
GPR_ALIAS!(RDX_ALIAS: (10,RDX)  -> EDX, DX , DL, DH);
122
123
124
125
126
127
128
129
130
131
132
133
134
135
GPR_ALIAS!(RBX_ALIAS: (15,RBX)  -> EBX, BX , BL, BH);
GPR_ALIAS!(RSP_ALIAS: (20,RSP)  -> ESP, SP , SPL);
GPR_ALIAS!(RBP_ALIAS: (24,RBP)  -> EBP, BP , BPL);
GPR_ALIAS!(RSI_ALIAS: (28,RSI)  -> ESI, SI , SIL);
GPR_ALIAS!(RDI_ALIAS: (32,RDI)  -> EDI, DI , DIL);
GPR_ALIAS!(R8_ALIAS : (36,R8 )  -> R8D, R8W, R8B);
GPR_ALIAS!(R9_ALIAS : (40,R9 )  -> R9D, R9W, R9B);
GPR_ALIAS!(R10_ALIAS: (44,R10) -> R10D,R10W,R10B);
GPR_ALIAS!(R11_ALIAS: (48,R11) -> R11D,R11W,R11B);
GPR_ALIAS!(R12_ALIAS: (52,R12) -> R12D,R12W,R12B);
GPR_ALIAS!(R13_ALIAS: (56,R13) -> R13D,R13W,R13B);
GPR_ALIAS!(R14_ALIAS: (60,R14) -> R14D,R14W,R14B);
GPR_ALIAS!(R15_ALIAS: (64,R15) -> R15D,R15W,R15B);
GPR_ALIAS!(RIP_ALIAS: (68,RIP));
qinsoon's avatar
qinsoon committed
136

qinsoon's avatar
qinsoon committed
137
lazy_static! {
qinsoon's avatar
qinsoon committed
138
139
    /// a map from 64-bit register IDs to a vector of its aliased register (Values),
    /// including the 64-bit register
140
141
    pub static ref GPR_ALIAS_TABLE : LinkedHashMap<MuID, Vec<P<Value>>> = {
        let mut ret = LinkedHashMap::new();
qinsoon's avatar
qinsoon committed
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

        ret.insert(RAX.id(), RAX_ALIAS.to_vec());
        ret.insert(RCX.id(), RCX_ALIAS.to_vec());
        ret.insert(RDX.id(), RDX_ALIAS.to_vec());
        ret.insert(RBX.id(), RBX_ALIAS.to_vec());
        ret.insert(RSP.id(), RSP_ALIAS.to_vec());
        ret.insert(RBP.id(), RBP_ALIAS.to_vec());
        ret.insert(RSI.id(), RSI_ALIAS.to_vec());
        ret.insert(RDI.id(), RDI_ALIAS.to_vec());
        ret.insert(R8.id() , R8_ALIAS.to_vec() );
        ret.insert(R9.id() , R9_ALIAS.to_vec() );
        ret.insert(R10.id(), R10_ALIAS.to_vec());
        ret.insert(R11.id(), R11_ALIAS.to_vec());
        ret.insert(R12.id(), R12_ALIAS.to_vec());
        ret.insert(R13.id(), R13_ALIAS.to_vec());
        ret.insert(R14.id(), R14_ALIAS.to_vec());
        ret.insert(R15.id(), R15_ALIAS.to_vec());
        ret.insert(RIP.id(), RIP_ALIAS.to_vec());

        ret
    };

qinsoon's avatar
qinsoon committed
164
    /// a map from any register to its 64-bit alias
qinsoon's avatar
qinsoon committed
165
166
167
168
169
170
171
172
173
174
175
176
    pub static ref GPR_ALIAS_LOOKUP : HashMap<MuID, P<Value>> = {
        let mut ret = HashMap::new();

        for vec in GPR_ALIAS_TABLE.values() {
            let colorable = vec[0].clone();

            for gpr in vec {
                ret.insert(gpr.id(), colorable.clone());
            }
        }

        ret
qinsoon's avatar
qinsoon committed
177
    };
qinsoon's avatar
qinsoon committed
178
179
}

qinsoon's avatar
qinsoon committed
180
181
/// returns P<Value> for a register ID of its alias of the given length
/// panics if the ID is not a machine register ID
qinsoon's avatar
qinsoon committed
182
183
184
185
pub fn get_alias_for_length(id: MuID, length: usize) -> P<Value> {
    if id < FPR_ID_START {
        let vec = match GPR_ALIAS_TABLE.get(&id) {
            Some(vec) => vec,
qinsoon's avatar
qinsoon committed
186
            None => panic!("didnt find {} as GPR", id),
qinsoon's avatar
qinsoon committed
187
188
189
190
191
192
193
194
        };

        match length {
            64 => vec[0].clone(),
            32 => vec[1].clone(),
            16 => vec[2].clone(),
            8 => vec[3].clone(),
            1 => vec[3].clone(),
qinsoon's avatar
qinsoon committed
195
            _ => panic!("unexpected length {} for {}", length, vec[0]),
qinsoon's avatar
qinsoon committed
196
197
        }
    } else {
qinsoon's avatar
qinsoon committed
198
        for r in ALL_FPRS.iter() {
qinsoon's avatar
qinsoon committed
199
200
201
202
203
204
205
206
            if r.id() == id {
                return r.clone();
            }
        }

        panic!("didnt find {} as FPR", id)
    }
}
qinsoon's avatar
qinsoon committed
207

qinsoon's avatar
qinsoon committed
208
/// are two registers aliased? (both must be machine register IDs, otherwise this function panics)
209
pub fn is_aliased(id1: MuID, id2: MuID) -> bool {
qinsoon's avatar
qinsoon committed
210
    if get_color_for_precolored(id1) == get_color_for_precolored(id2) {
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
        // we need to specially check the case for AH/BH/CH/DH
        // because both AH and AL are aliased to RAX, but AH and AL are not aliased
        macro_rules! is_match {
            ($a1: expr, $a2: expr; $b: expr) => {
                $a1 == $b.id() || $a2 == $b.id()
            }
        };

        if is_match!(id1, id2; AH) {
            return false;
        } else if is_match!(id1, id2; BH) {
            return false;
        } else if is_match!(id1, id2; CH) {
            return false;
        } else if is_match!(id1, id2; DH) {
            return false;
        } else {
            return true;
        }
230
    } else {
qinsoon's avatar
qinsoon committed
231
        false
232
233
234
    }
}

qinsoon's avatar
mod.rs    
qinsoon committed
235
/// gets the color for a machine register (returns 64-bit alias for it)
qinsoon's avatar
qinsoon committed
236
237
238
pub fn get_color_for_precolored(id: MuID) -> MuID {
    debug_assert!(id < MACHINE_ID_END);

qinsoon's avatar
qinsoon committed
239
240
241
    if id < FPR_ID_START {
        match GPR_ALIAS_LOOKUP.get(&id) {
            Some(val) => val.id(),
qinsoon's avatar
qinsoon committed
242
            None => panic!("cannot find GPR {}", id),
qinsoon's avatar
qinsoon committed
243
244
245
246
        }
    } else {
        // we do not have alias for FPRs
        id
qinsoon's avatar
qinsoon committed
247
248
    }
}
qinsoon's avatar
qinsoon committed
249

qinsoon's avatar
mod.rs    
qinsoon committed
250
/// returns register length (in bits) for an integer operand
qinsoon's avatar
qinsoon committed
251
252
253
254
255
256
#[inline(always)]
pub fn check_op_len(op: &P<Value>) -> usize {
    match op.ty.get_int_length() {
        Some(64) => 64,
        Some(32) => 32,
        Some(16) => 16,
qinsoon's avatar
qinsoon committed
257
258
259
        Some(8) => 8,
        Some(1) => 8,
        _ => panic!("unsupported register length for x64: {}", op.ty),
qinsoon's avatar
qinsoon committed
260
261
262
    }
}

qinsoon's avatar
qinsoon committed
263
lazy_static! {
qinsoon's avatar
mod.rs    
qinsoon committed
264
265
    /// GPRs for returning values
    //  order matters
qinsoon's avatar
qinsoon committed
266
    pub static ref RETURN_GPRS : [P<Value>; 2] = [
qinsoon's avatar
qinsoon committed
267
268
269
        RAX.clone(),
        RDX.clone(),
    ];
270

qinsoon's avatar
mod.rs    
qinsoon committed
271
272
    /// GPRs for passing arguments
    //  order matters
qinsoon's avatar
qinsoon committed
273
    pub static ref ARGUMENT_GPRS : [P<Value>; 6] = [
qinsoon's avatar
qinsoon committed
274
275
276
277
278
279
280
        RDI.clone(),
        RSI.clone(),
        RDX.clone(),
        RCX.clone(),
        R8.clone(),
        R9.clone()
    ];
281

qinsoon's avatar
mod.rs    
qinsoon committed
282
    /// callee saved GPRs
qinsoon's avatar
qinsoon committed
283
    pub static ref CALLEE_SAVED_GPRS : [P<Value>; 6] = [
qinsoon's avatar
qinsoon committed
284
285
286
287
288
289
290
        RBX.clone(),
        RBP.clone(),
        R12.clone(),
        R13.clone(),
        R14.clone(),
        R15.clone()
    ];
qinsoon's avatar
qinsoon committed
291

qinsoon's avatar
mod.rs    
qinsoon committed
292
    /// caller saved GPRs
qinsoon's avatar
qinsoon committed
293
    pub static ref CALLER_SAVED_GPRS : [P<Value>; 9] = [
qinsoon's avatar
qinsoon committed
294
295
296
297
298
299
300
301
302
303
        RAX.clone(),
        RCX.clone(),
        RDX.clone(),
        RSI.clone(),
        RDI.clone(),
        R8.clone(),
        R9.clone(),
        R10.clone(),
        R11.clone()
    ];
304

qinsoon's avatar
mod.rs    
qinsoon committed
305
306
    /// all the genral purpose registers
    //  FIXME: why RBP is commented out?
qinsoon's avatar
qinsoon committed
307
    static ref ALL_GPRS : [P<Value>; 15] = [
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
        RAX.clone(),
        RCX.clone(),
        RDX.clone(),
        RBX.clone(),
        RSP.clone(),
//        RBP.clone(),
        RSI.clone(),
        RDI.clone(),
        R8.clone(),
        R9.clone(),
        R10.clone(),
        R11.clone(),
        R12.clone(),
        R13.clone(),
        R14.clone(),
        R15.clone()
    ];
qinsoon's avatar
qinsoon committed
325
326
}

qinsoon's avatar
qinsoon committed
327
pub const FPR_ID_START: usize = 100;
qinsoon's avatar
qinsoon committed
328

qinsoon's avatar
qinsoon committed
329
lazy_static!{
qinsoon's avatar
mod.rs    
qinsoon committed
330
    // floating point registers, we use SSE registers
qinsoon's avatar
qinsoon committed
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
    pub static ref XMM0  : P<Value> = FPR!(FPR_ID_START,    "xmm0");
    pub static ref XMM1  : P<Value> = FPR!(FPR_ID_START + 1,"xmm1");
    pub static ref XMM2  : P<Value> = FPR!(FPR_ID_START + 2,"xmm2");
    pub static ref XMM3  : P<Value> = FPR!(FPR_ID_START + 3,"xmm3");
    pub static ref XMM4  : P<Value> = FPR!(FPR_ID_START + 4,"xmm4");
    pub static ref XMM5  : P<Value> = FPR!(FPR_ID_START + 5,"xmm5");
    pub static ref XMM6  : P<Value> = FPR!(FPR_ID_START + 6,"xmm6");
    pub static ref XMM7  : P<Value> = FPR!(FPR_ID_START + 7,"xmm7");
    pub static ref XMM8  : P<Value> = FPR!(FPR_ID_START + 8,"xmm8");
    pub static ref XMM9  : P<Value> = FPR!(FPR_ID_START + 9,"xmm9");
    pub static ref XMM10 : P<Value> = FPR!(FPR_ID_START + 10,"xmm10");
    pub static ref XMM11 : P<Value> = FPR!(FPR_ID_START + 11,"xmm11");
    pub static ref XMM12 : P<Value> = FPR!(FPR_ID_START + 12,"xmm12");
    pub static ref XMM13 : P<Value> = FPR!(FPR_ID_START + 13,"xmm13");
    pub static ref XMM14 : P<Value> = FPR!(FPR_ID_START + 14,"xmm14");
    pub static ref XMM15 : P<Value> = FPR!(FPR_ID_START + 15,"xmm15");
347

qinsoon's avatar
mod.rs    
qinsoon committed
348
349
    /// FPRs to return values
    //  order matters
qinsoon's avatar
qinsoon committed
350
    pub static ref RETURN_FPRS : [P<Value>; 2] = [
qinsoon's avatar
qinsoon committed
351
352
353
        XMM0.clone(),
        XMM1.clone()
    ];
354

qinsoon's avatar
mod.rs    
qinsoon committed
355
356
    /// FPRs to pass arguments
    //  order matters
qinsoon's avatar
qinsoon committed
357
    pub static ref ARGUMENT_FPRS : [P<Value>; 8] = [
qinsoon's avatar
qinsoon committed
358
359
        XMM0.clone(),
        XMM1.clone(),
qinsoon's avatar
qinsoon committed
360
361
362
363
364
365
366
        XMM2.clone(),
        XMM3.clone(),
        XMM4.clone(),
        XMM5.clone(),
        XMM6.clone(),
        XMM7.clone()
    ];
367

qinsoon's avatar
mod.rs    
qinsoon committed
368
    /// callee saved FPRs (none for x86_64)
qinsoon's avatar
qinsoon committed
369
    pub static ref CALLEE_SAVED_FPRS : [P<Value>; 0] = [];
qinsoon's avatar
qinsoon committed
370

qinsoon's avatar
mod.rs    
qinsoon committed
371
    /// caller saved FPRs
qinsoon's avatar
qinsoon committed
372
    pub static ref CALLER_SAVED_FPRS : [P<Value>; 16] = [
qinsoon's avatar
qinsoon committed
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
        XMM0.clone(),
        XMM1.clone(),
        XMM2.clone(),
        XMM3.clone(),
        XMM4.clone(),
        XMM5.clone(),
        XMM6.clone(),
        XMM7.clone(),
        XMM8.clone(),
        XMM9.clone(),
        XMM10.clone(),
        XMM11.clone(),
        XMM12.clone(),
        XMM13.clone(),
        XMM14.clone(),
        XMM15.clone(),
    ];
390

qinsoon's avatar
mod.rs    
qinsoon committed
391
    /// all the floating point registers
qinsoon's avatar
qinsoon committed
392
    static ref ALL_FPRS : [P<Value>; 16] = [
qinsoon's avatar
qinsoon committed
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
        XMM0.clone(),
        XMM1.clone(),
        XMM2.clone(),
        XMM3.clone(),
        XMM4.clone(),
        XMM5.clone(),
        XMM6.clone(),
        XMM7.clone(),
        XMM8.clone(),
        XMM9.clone(),
        XMM10.clone(),
        XMM11.clone(),
        XMM12.clone(),
        XMM13.clone(),
        XMM14.clone(),
        XMM15.clone(),
    ];
qinsoon's avatar
qinsoon committed
410
411
}

qinsoon's avatar
qinsoon committed
412
lazy_static! {
qinsoon's avatar
mod.rs    
qinsoon committed
413
    /// a map for all the machine registers, from ID to P<Value>
qinsoon's avatar
qinsoon committed
414
    pub static ref ALL_MACHINE_REGS : LinkedHashMap<MuID, P<Value>> = {
415
        let mut map = LinkedHashMap::new();
qinsoon's avatar
qinsoon committed
416
417
418
419
420
421
422

        for vec in GPR_ALIAS_TABLE.values() {
            for reg in vec {
                map.insert(reg.id(), reg.clone());
            }
        }

423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
        map.insert(XMM0.id(), XMM0.clone());
        map.insert(XMM1.id(), XMM1.clone());
        map.insert(XMM2.id(), XMM2.clone());
        map.insert(XMM3.id(), XMM3.clone());
        map.insert(XMM4.id(), XMM4.clone());
        map.insert(XMM5.id(), XMM5.clone());
        map.insert(XMM6.id(), XMM6.clone());
        map.insert(XMM7.id(), XMM7.clone());
        map.insert(XMM8.id(), XMM8.clone());
        map.insert(XMM9.id(), XMM9.clone());
        map.insert(XMM10.id(), XMM10.clone());
        map.insert(XMM11.id(), XMM11.clone());
        map.insert(XMM12.id(), XMM12.clone());
        map.insert(XMM13.id(), XMM13.clone());
        map.insert(XMM14.id(), XMM14.clone());
        map.insert(XMM15.id(), XMM15.clone());

        map
    };
442

443
    /// all the usable general purpose registers for reg allocator to assign
qinsoon's avatar
mod.rs    
qinsoon committed
444
445
446
    //  order matters here (since register allocator will prioritize assigning temporaries
    //  to a register that appears early)
    //  we put caller saved regs first (they imposes no overhead if there is no call instruction)
447
    pub static ref ALL_USABLE_GPRS : Vec<P<Value>> = vec![
qinsoon's avatar
mod.rs    
qinsoon committed
448
        // caller saved registers
449
450
451
452
453
454
455
456
457
        RAX.clone(),
        RCX.clone(),
        RDX.clone(),
        RSI.clone(),
        RDI.clone(),
        R8.clone(),
        R9.clone(),
        R10.clone(),
        R11.clone(),
qinsoon's avatar
mod.rs    
qinsoon committed
458
        // callee saved registers
459
460
461
462
463
        RBX.clone(),
        R12.clone(),
        R13.clone(),
        R14.clone(),
        R15.clone(),
464
465
466
467
468
469
470
    ];

    /// all the usable floating point registers for reg allocator to assign
    //  order matters here (since register allocator will prioritize assigning temporaries
    //  to a register that appears early)
    //  we put caller saved regs first (they imposes no overhead if there is no call instruction)
    pub static ref ALL_USABLE_FPRS : Vec<P<Value>> = vec![
qinsoon's avatar
mod.rs    
qinsoon committed
471
        // floating point registers
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
        XMM0.clone(),
        XMM1.clone(),
        XMM2.clone(),
        XMM3.clone(),
        XMM4.clone(),
        XMM5.clone(),
        XMM6.clone(),
        XMM7.clone(),
        XMM8.clone(),
        XMM9.clone(),
        XMM10.clone(),
        XMM11.clone(),
        XMM12.clone(),
        XMM13.clone(),
        XMM14.clone(),
        XMM15.clone()
    ];
489
490
491
492
493
494
495
496
497
498
499

    /// all the usable registers for register allocators to assign
    //  order matters here (since register allocator will prioritize assigning temporaries
    //  to a register that appears early)
    //  we put caller saved regs first (they imposes no overhead if there is no call instruction)
    pub static ref ALL_USABLE_MACHINE_REGS : Vec<P<Value>> = {
        let mut ret = vec![];
        ret.extend_from_slice(&ALL_USABLE_GPRS);
        ret.extend_from_slice(&ALL_USABLE_FPRS);
        ret
    };
qinsoon's avatar
qinsoon committed
500
501
}

qinsoon's avatar
mod.rs    
qinsoon committed
502
/// creates context for each machine register in FunctionContext
qinsoon's avatar
qinsoon committed
503
pub fn init_machine_regs_for_func(func_context: &mut FunctionContext) {
qinsoon's avatar
qinsoon committed
504
    for reg in ALL_MACHINE_REGS.values() {
qinsoon's avatar
qinsoon committed
505
        let reg_id = reg.extract_ssa_id().unwrap();
qinsoon's avatar
qinsoon committed
506
        let entry = SSAVarEntry::new(reg.clone());
507

qinsoon's avatar
qinsoon committed
508
509
510
511
        func_context.values.insert(reg_id, entry);
    }
}

qinsoon's avatar
mod.rs    
qinsoon committed
512
/// gets the number of registers in a certain register group
513
pub fn number_of_usable_regs_in_group(group: RegGroup) -> usize {
qinsoon's avatar
qinsoon committed
514
    match group {
qinsoon's avatar
qinsoon committed
515
        RegGroup::GPR => ALL_USABLE_GPRS.len(),
516
        RegGroup::GPREX => ALL_USABLE_GPRS.len(),
qinsoon's avatar
qinsoon committed
517
        RegGroup::FPR => ALL_USABLE_FPRS.len(),
qinsoon's avatar
qinsoon committed
518
519
520
    }
}

qinsoon's avatar
mod.rs    
qinsoon committed
521
/// returns the number of all registers on this platform
qinsoon's avatar
qinsoon committed
522
pub fn number_of_all_regs() -> usize {
qinsoon's avatar
qinsoon committed
523
    ALL_MACHINE_REGS.len()
qinsoon's avatar
qinsoon committed
524
525
}

qinsoon's avatar
mod.rs    
qinsoon committed
526
/// returns a reference to a map for all the registers
527
pub fn all_regs() -> &'static LinkedHashMap<MuID, P<Value>> {
qinsoon's avatar
qinsoon committed
528
    &ALL_MACHINE_REGS
qinsoon's avatar
qinsoon committed
529
530
}

qinsoon's avatar
mod.rs    
qinsoon committed
531
/// returns a reference to a vector of all usable registers
532
pub fn all_usable_regs() -> &'static Vec<P<Value>> {
qinsoon's avatar
qinsoon committed
533
    &ALL_USABLE_MACHINE_REGS
534
535
}

qinsoon's avatar
mod.rs    
qinsoon committed
536
537
/// returns RegGroup for a given machine register (by ID)
/// panics if the ID is not a machine register
538
pub fn pick_group_for_reg(reg_id: MuID) -> RegGroup {
539
    let reg = all_regs().get(&reg_id).unwrap();
540
    RegGroup::get_from_value(reg)
541
542
}

543
/// gets the previouse frame pointer with respect to the current
544
545
546
547
548
#[inline(always)]
pub fn get_previous_frame_pointer(frame_pointer: Address) -> Address {
    unsafe { frame_pointer.load::<Address>() }
}

549
/// gets the return address for the current frame pointer
550
551
#[inline(always)]
pub fn get_return_address(frame_pointer: Address) -> Address {
552
    unsafe { (frame_pointer + 8 as ByteSize).load::<Address>() }
553
554
}

555
/// gets the stack pointer before the current frame was created
556
#[inline(always)]
557
pub fn get_previous_stack_pointer(frame_pointer: Address, stack_arg_size: usize) -> Address {
558
    frame_pointer + 16 as ByteSize + stack_arg_size
559
560
}

561
/// sets the stack point
562
563
564
565
566
#[inline(always)]
pub fn set_previous_frame_pointer(frame_pointer: Address, value: Address) {
    unsafe { frame_pointer.store::<Address>(value) }
}

567
/// gets the return address for the current frame pointer
568
569
#[inline(always)]
pub fn set_return_address(frame_pointer: Address, value: Address) {
570
    unsafe { (frame_pointer + 8 as ByteSize).store::<Address>(value) }
571
572
}

573
574
/// returns offset of callee saved register
/// Reg should be a 64-bit callee saved GPR or FPR
575
576
577
578
579
580
pub fn get_callee_saved_offset(reg: MuID) -> isize {
    debug_assert!(is_callee_saved(reg) && reg != RBP.id());

    let id = if reg == RBX.id() {
        0
    } else {
qinsoon's avatar
qinsoon committed
581
        (reg - R12.id()) / 4 + 1
582
    };
qinsoon's avatar
qinsoon committed
583
    (id as isize + 1) * (-8)
584
}
585

qinsoon's avatar
mod.rs    
qinsoon committed
586
587
/// is a machine register (by ID) callee saved?
/// returns false if the ID is not a machine register
588
pub fn is_callee_saved(reg_id: MuID) -> bool {
qinsoon's avatar
qinsoon committed
589
    for reg in CALLEE_SAVED_GPRS.iter() {
590
591
592
593
        if reg_id == reg.extract_ssa_id().unwrap() {
            return true;
        }
    }
594
595

    false
596
597
}

qinsoon's avatar
mod.rs    
qinsoon committed
598
/// is a constant a valid x86_64 immediate number (32 bits integer)?
599
pub fn is_valid_x86_imm(op: &P<Value>) -> bool {
600
601
602
603
    use std::i32;

    if op.ty.get_int_length().is_some() && op.ty.get_int_length().unwrap() <= 32 {
        match op.v {
qinsoon's avatar
qinsoon committed
604
605
606
            Value_::Constant(Constant::Int(val))
                if val as i32 >= i32::MIN && val as i32 <= i32::MAX => true,
            _ => false,
607
608
609
        }
    } else {
        false
610
    }
qinsoon's avatar
qinsoon committed
611
612
613
}

use ast::inst::*;
qinsoon's avatar
mod.rs    
qinsoon committed
614
615

/// estimate the number of machine instruction for each IR instruction
qinsoon's avatar
qinsoon committed
616
617
618
619
620
pub fn estimate_insts_for_ir(inst: &Instruction) -> usize {
    use ast::inst::Instruction_::*;

    match inst.v {
        // simple
qinsoon's avatar
qinsoon committed
621
        BinOp(_, _, _) => 1,
qinsoon's avatar
qinsoon committed
622
        BinOpWithStatus(_, _, _, _) => 2,
qinsoon's avatar
qinsoon committed
623
624
        CmpOp(_, _, _) => 1,
        ConvOp { .. } => 0,
qinsoon's avatar
qinsoon committed
625
626

        // control flow
qinsoon's avatar
qinsoon committed
627
628
629
630
631
632
        Branch1(_) => 1,
        Branch2 { .. } => 1,
        Select { .. } => 2,
        Watchpoint { .. } => 1,
        WPBranch { .. } => 2,
        Switch { .. } => 3,
qinsoon's avatar
qinsoon committed
633
634

        // call
qinsoon's avatar
qinsoon committed
635
636
        ExprCall { .. } | ExprCCall { .. } | Call { .. } | CCall { .. } => 5,
        Return(_) => 1,
qinsoon's avatar
qinsoon committed
637
638
639
        TailCall(_) => 1,

        // memory access
qinsoon's avatar
qinsoon committed
640
641
642
643
644
645
        Load { .. } | Store { .. } => 1,
        CmpXchg { .. } => 1,
        AtomicRMW { .. } => 1,
        AllocA(_) => 1,
        AllocAHybrid(_, _) => 1,
        Fence(_) => 1,
qinsoon's avatar
qinsoon committed
646
647

        // memory addressing
qinsoon's avatar
qinsoon committed
648
649
650
651
652
        GetIRef(_) |
        GetFieldIRef { .. } |
        GetElementIRef { .. } |
        ShiftIRef { .. } |
        GetVarPartIRef { .. } => 0,
qinsoon's avatar
qinsoon committed
653

qinsoon's avatar
mod.rs    
qinsoon committed
654
        // runtime call
qinsoon's avatar
qinsoon committed
655
656
        New(_) | NewHybrid(_, _) => 10,
        NewStack(_) | NewThread(_, _) | NewThreadExn(_, _) | NewFrameCursor(_) => 10,
qinsoon's avatar
qinsoon committed
657
658
659
        ThreadExit => 10,
        Throw(_) => 10,
        SwapStack { .. } => 10,
qinsoon's avatar
qinsoon committed
660
        CommonInst_GetThreadLocal | CommonInst_SetThreadLocal(_) => 10,
qinsoon's avatar
qinsoon committed
661
        CommonInst_Pin(_) | CommonInst_Unpin(_) => 10,
qinsoon's avatar
qinsoon committed
662
663
664

        // others
        Move(_) => 0,
qinsoon's avatar
qinsoon committed
665
        PrintHex(_) => 10,
666
        SetRetval(_) => 10,
qinsoon's avatar
qinsoon committed
667
        ExnInstruction { ref inner, .. } => estimate_insts_for_ir(&inner),
668
        _ => unimplemented!(),
qinsoon's avatar
qinsoon committed
669
    }
670
}