GitLab will be upgraded to the 12.10.14-ce.0 on 28 Sept 2020 at 2.00pm (AEDT) to 2.30pm (AEDT). During the update, GitLab and Mattermost services will not be available. If you have any concerns with this, please talk to us at N110 (b) CSIT building.

mod.rs 15.4 KB
Newer Older
qinsoon's avatar
qinsoon committed
1 2
#![allow(dead_code)]

qinsoon's avatar
qinsoon committed
3
/// Tree pattern matching instruction selection.
4 5 6
pub mod inst_sel;

mod codegen;
qinsoon's avatar
qinsoon committed
7 8 9
/// 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;
10

qinsoon's avatar
qinsoon committed
11 12 13 14 15 16
/// 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")]
17
pub use compiler::backend::x86_64::asm_backend::emit_code;
qinsoon's avatar
qinsoon committed
18
#[cfg(feature = "aot")]
19
pub use compiler::backend::x86_64::asm_backend::emit_context;
qinsoon's avatar
qinsoon committed
20
#[cfg(feature = "aot")]
qinsoon's avatar
qinsoon committed
21
pub use compiler::backend::x86_64::asm_backend::emit_context_with_reloc;
22 23
#[cfg(feature = "aot")]
pub use compiler::backend::x86_64::asm_backend::spill_rewrite;
24 25 26

use ast::ptr::P;
use ast::ir::*;
qinsoon's avatar
qinsoon committed
27
use ast::types::*;
qinsoon's avatar
qinsoon committed
28
use compiler::backend::RegGroup;
qinsoon's avatar
qinsoon committed
29

30
use utils::LinkedHashMap;
31 32
use std::collections::HashMap;

qinsoon's avatar
qinsoon committed
33
/// a macro to declare a set of general purpose registers that are aliased to the first one
qinsoon's avatar
qinsoon committed
34
macro_rules! GPR_ALIAS {
qinsoon's avatar
qinsoon committed
35 36 37 38 39 40 41 42 43 44 45 46
    ($alias: ident: ($id64: expr, $r64: ident) -> $r32: ident, $r16: ident, $r8l: ident, $r8h: 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 $r8l : P<Value> = GPR!($id64 +3, stringify!($r8l), UINT8_TYPE);
            pub static ref $r8h : P<Value> = GPR!($id64 +4, stringify!($r8h), UINT8_TYPE);

            pub static ref $alias : [P<Value>; 5] = [$r64.clone(), $r32.clone(), $r16.clone(), $r8l.clone(), $r8h.clone()];
        }
    };

qinsoon's avatar
qinsoon committed
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    ($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 );

            pub static ref $alias : [P<Value>; 4] = [$r64.clone(), $r32.clone(), $r16.clone(), $r8.clone()];
        }
    };

    ($alias: ident: ($id64: expr, $r64: ident)) => {
        lazy_static!{
            pub static ref $r64 : P<Value> = GPR!($id64,    stringify!($r64), UINT64_TYPE);

            pub static ref $alias : [P<Value>; 4] = [$r64.clone(), $r64.clone(), $r64.clone(), $r64.clone()];
        }
    };
}

qinsoon's avatar
qinsoon committed
67
/// a macro to declare a general purpose register
68
macro_rules! GPR {
qinsoon's avatar
qinsoon committed
69
    ($id:expr, $name: expr, $ty: ident) => {
qinsoon's avatar
qinsoon committed
70 71
        {
            P(Value {
qinsoon's avatar
qinsoon committed
72
                hdr: MuEntityHeader::named($id, $name.to_string()),
qinsoon's avatar
qinsoon committed
73
                ty: $ty.clone(),
qinsoon's avatar
qinsoon committed
74
                v: Value_::SSAVar($id)
qinsoon's avatar
qinsoon committed
75 76
            })
        }
qinsoon's avatar
qinsoon committed
77 78 79
    };
}

qinsoon's avatar
qinsoon committed
80
/// a macro to declare a floating point register
qinsoon's avatar
qinsoon committed
81
macro_rules! FPR {
qinsoon's avatar
qinsoon committed
82
    ($id:expr, $name: expr) => {
qinsoon's avatar
qinsoon committed
83 84
        {
            P(Value {
qinsoon's avatar
qinsoon committed
85
                hdr: MuEntityHeader::named($id, $name.to_string()),
qinsoon's avatar
qinsoon committed
86
                ty: DOUBLE_TYPE.clone(),
qinsoon's avatar
qinsoon committed
87
                v: Value_::SSAVar($id)
qinsoon's avatar
qinsoon committed
88 89
            })
        }
qinsoon's avatar
qinsoon committed
90 91 92
    };
}

qinsoon's avatar
qinsoon committed
93 94 95
// declare all general purpose registers for x86_64
// non 64-bit registers are alias of its 64-bit one

96 97
GPR_ALIAS!(RAX_ALIAS: (0, RAX)  -> EAX, AX , AL, AH);
GPR_ALIAS!(RCX_ALIAS: (5, RCX)  -> ECX, CX , CL, CH);
98
GPR_ALIAS!(RDX_ALIAS: (10,RDX)  -> EDX, DX , DL, DH);
99 100 101 102 103 104 105 106 107 108 109 110 111 112
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
113

114
lazy_static! {
qinsoon's avatar
qinsoon committed
115 116
    /// a map from 64-bit register IDs to a vector of its aliased register (Values),
    /// including the 64-bit register
117 118
    pub static ref GPR_ALIAS_TABLE : LinkedHashMap<MuID, Vec<P<Value>>> = {
        let mut ret = LinkedHashMap::new();
qinsoon's avatar
qinsoon committed
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

        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
141
    /// a map from any register to its 64-bit alias
qinsoon's avatar
qinsoon committed
142 143 144 145 146 147 148 149 150 151 152 153
    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
154
    };
qinsoon's avatar
qinsoon committed
155 156
}

qinsoon's avatar
qinsoon committed
157 158
/// 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
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
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,
            None => panic!("didnt find {} as GPR", id)
        };

        match length {
            64 => vec[0].clone(),
            32 => vec[1].clone(),
            16 => vec[2].clone(),
            8 => vec[3].clone(),
            1 => vec[3].clone(),
            _ => panic!("unexpected length {} for {}", length, vec[0])
        }
    } else {
qinsoon's avatar
qinsoon committed
175
        for r in ALL_FPRS.iter() {
qinsoon's avatar
qinsoon committed
176 177 178 179 180 181 182 183
            if r.id() == id {
                return r.clone();
            }
        }

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

qinsoon's avatar
qinsoon committed
185
/// are two registers aliased? (both must be machine register IDs, otherwise this function panics)
186
pub fn is_aliased(id1: MuID, id2: MuID) -> bool {
qinsoon's avatar
qinsoon committed
187
    if get_color_for_precolored(id1) == get_color_for_precolored(id2) {
qinsoon's avatar
qinsoon committed
188
        true
189
    } else {
qinsoon's avatar
qinsoon committed
190
        false
191 192 193
    }
}

qinsoon's avatar
qinsoon committed
194 195 196
pub fn get_color_for_precolored(id: MuID) -> MuID {
    debug_assert!(id < MACHINE_ID_END);

qinsoon's avatar
qinsoon committed
197 198 199 200 201 202 203 204
    if id < FPR_ID_START {
        match GPR_ALIAS_LOOKUP.get(&id) {
            Some(val) => val.id(),
            None => panic!("cannot find GPR {}", id)
        }
    } else {
        // we do not have alias for FPRs
        id
qinsoon's avatar
qinsoon committed
205 206
    }
}
207

qinsoon's avatar
qinsoon committed
208 209 210 211 212 213 214 215 216 217 218 219
#[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,
        Some(8)  => 8,
        Some(1)  => 8,
        _ => panic!("unimplemented int types: {}", op.ty)
    }
}

qinsoon's avatar
qinsoon committed
220
lazy_static! {
qinsoon's avatar
qinsoon committed
221
    pub static ref RETURN_GPRS : [P<Value>; 2] = [
qinsoon's avatar
qinsoon committed
222 223 224
        RAX.clone(),
        RDX.clone(),
    ];
225

qinsoon's avatar
qinsoon committed
226
    pub static ref ARGUMENT_GPRS : [P<Value>; 6] = [
qinsoon's avatar
qinsoon committed
227 228 229 230 231 232 233
        RDI.clone(),
        RSI.clone(),
        RDX.clone(),
        RCX.clone(),
        R8.clone(),
        R9.clone()
    ];
234

qinsoon's avatar
qinsoon committed
235
    pub static ref CALLEE_SAVED_GPRS : [P<Value>; 6] = [
qinsoon's avatar
qinsoon committed
236 237 238 239 240 241 242
        RBX.clone(),
        RBP.clone(),
        R12.clone(),
        R13.clone(),
        R14.clone(),
        R15.clone()
    ];
qinsoon's avatar
qinsoon committed
243

qinsoon's avatar
qinsoon committed
244
    pub static ref CALLER_SAVED_GPRS : [P<Value>; 9] = [
qinsoon's avatar
qinsoon committed
245 246 247 248 249 250 251 252 253 254
        RAX.clone(),
        RCX.clone(),
        RDX.clone(),
        RSI.clone(),
        RDI.clone(),
        R8.clone(),
        R9.clone(),
        R10.clone(),
        R11.clone()
    ];
255

qinsoon's avatar
qinsoon committed
256
    static ref ALL_GPRS : [P<Value>; 15] = [
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
        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
274 275
}

276
pub const FPR_ID_START : usize = 100;
qinsoon's avatar
qinsoon committed
277

qinsoon's avatar
qinsoon committed
278
lazy_static!{
qinsoon's avatar
qinsoon committed
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
    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");
295

qinsoon's avatar
qinsoon committed
296
    pub static ref RETURN_FPRS : [P<Value>; 2] = [
qinsoon's avatar
qinsoon committed
297 298 299
        XMM0.clone(),
        XMM1.clone()
    ];
300

qinsoon's avatar
qinsoon committed
301
    pub static ref ARGUMENT_FPRS : [P<Value>; 8] = [
qinsoon's avatar
qinsoon committed
302 303
        XMM0.clone(),
        XMM1.clone(),
qinsoon's avatar
qinsoon committed
304 305 306 307 308 309 310
        XMM2.clone(),
        XMM3.clone(),
        XMM4.clone(),
        XMM5.clone(),
        XMM6.clone(),
        XMM7.clone()
    ];
311

qinsoon's avatar
qinsoon committed
312
    pub static ref CALLEE_SAVED_FPRS : [P<Value>; 0] = [];
qinsoon's avatar
qinsoon committed
313

qinsoon's avatar
qinsoon committed
314
    pub static ref CALLER_SAVED_FPRS : [P<Value>; 16] = [
qinsoon's avatar
qinsoon committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
        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(),
    ];
332

qinsoon's avatar
qinsoon committed
333
    static ref ALL_FPRS : [P<Value>; 16] = [
qinsoon's avatar
qinsoon committed
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
        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(),
    ];
351 352
}

qinsoon's avatar
qinsoon committed
353
lazy_static! {
qinsoon's avatar
qinsoon committed
354
    pub static ref ALL_MACHINE_REGS : LinkedHashMap<MuID, P<Value>> = {
355
        let mut map = LinkedHashMap::new();
qinsoon's avatar
qinsoon committed
356 357 358 359 360 361 362

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

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
        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
    };
382

383
    // put caller saved regs first (they imposes no overhead if there is no call instruction)
qinsoon's avatar
qinsoon committed
384
    pub static ref ALL_USABLE_MACHINE_REGS : Vec<P<Value>> = vec![
385 386 387 388 389 390 391 392 393
        RAX.clone(),
        RCX.clone(),
        RDX.clone(),
        RSI.clone(),
        RDI.clone(),
        R8.clone(),
        R9.clone(),
        R10.clone(),
        R11.clone(),
394

395 396 397 398 399
        RBX.clone(),
        R12.clone(),
        R13.clone(),
        R14.clone(),
        R15.clone(),
400

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
        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
418 419
}

qinsoon's avatar
qinsoon committed
420
pub fn init_machine_regs_for_func (func_context: &mut FunctionContext) {
qinsoon's avatar
qinsoon committed
421
    for reg in ALL_MACHINE_REGS.values() {
qinsoon's avatar
qinsoon committed
422
        let reg_id = reg.extract_ssa_id().unwrap();
qinsoon's avatar
qinsoon committed
423
        let entry = SSAVarEntry::new(reg.clone());
424

qinsoon's avatar
qinsoon committed
425 426 427 428 429 430
        func_context.values.insert(reg_id, entry);
    }
}

pub fn number_of_regs_in_group(group: RegGroup) -> usize {
    match group {
qinsoon's avatar
qinsoon committed
431 432 433
        RegGroup::GPR   => ALL_GPRS.len(),
        RegGroup::GPREX => ALL_GPRS.len(),
        RegGroup::FPR   => ALL_FPRS.len()
qinsoon's avatar
qinsoon committed
434 435 436
    }
}

qinsoon's avatar
qinsoon committed
437
pub fn number_of_all_regs() -> usize {
qinsoon's avatar
qinsoon committed
438
    ALL_MACHINE_REGS.len()
qinsoon's avatar
qinsoon committed
439 440
}

441
pub fn all_regs() -> &'static LinkedHashMap<MuID, P<Value>> {
qinsoon's avatar
qinsoon committed
442
    &ALL_MACHINE_REGS
qinsoon's avatar
qinsoon committed
443 444
}

445
pub fn all_usable_regs() -> &'static Vec<P<Value>> {
qinsoon's avatar
qinsoon committed
446
    &ALL_USABLE_MACHINE_REGS
447 448
}

449
pub fn pick_group_for_reg(reg_id: MuID) -> RegGroup {
450
    let reg = all_regs().get(&reg_id).unwrap();
451
    RegGroup::get_from_value(reg)
452 453
}

454
pub fn is_callee_saved(reg_id: MuID) -> bool {
qinsoon's avatar
qinsoon committed
455
    for reg in CALLEE_SAVED_GPRS.iter() {
456 457 458 459
        if reg_id == reg.extract_ssa_id().unwrap() {
            return true;
        }
    }
460 461

    false
462 463
}

464
pub fn is_valid_x86_imm(op: &P<Value>) -> bool {
qinsoon's avatar
qinsoon committed
465
    use std::u32;
qinsoon's avatar
qinsoon committed
466
    match op.v {
qinsoon's avatar
qinsoon committed
467
        Value_::Constant(Constant::Int(val)) if val <= u32::MAX as u64 => {
qinsoon's avatar
qinsoon committed
468 469
            true
        },
470 471
        _ => false
    }
472 473 474 475 476 477 478 479 480
}

use ast::inst::*;
pub fn estimate_insts_for_ir(inst: &Instruction) -> usize {
    use ast::inst::Instruction_::*;

    match inst.v {
        // simple
        BinOp(_, _, _)  => 1,
qinsoon's avatar
qinsoon committed
481
        BinOpWithStatus(_, _, _, _) => 2,
482
        CmpOp(_, _, _)  => 1,
qinsoon's avatar
qinsoon committed
483
        ConvOp{..}      => 0,
484 485

        // control flow
qinsoon's avatar
qinsoon committed
486 487 488
        Branch1(_)     => 1,
        Branch2{..}    => 1,
        Select{..}     => 2,
489
        Watchpoint{..} => 1,
qinsoon's avatar
qinsoon committed
490 491
        WPBranch{..}   => 2,
        Switch{..}     => 3,
492 493 494

        // call
        ExprCall{..} | ExprCCall{..} | Call{..} | CCall{..} => 5,
qinsoon's avatar
qinsoon committed
495
        Return(_)   => 1,
496 497 498 499
        TailCall(_) => 1,

        // memory access
        Load{..} | Store{..} => 1,
qinsoon's avatar
qinsoon committed
500 501 502 503 504
        CmpXchg{..}          => 1,
        AtomicRMW{..}        => 1,
        AllocA(_)            => 1,
        AllocAHybrid(_, _)   => 1,
        Fence(_)             => 1,
505 506 507 508 509 510 511

        // memory addressing
        GetIRef(_) | GetFieldIRef{..} | GetElementIRef{..} | ShiftIRef{..} | GetVarPartIRef{..} => 0,

        // runtime
        New(_) | NewHybrid(_, _) => 10,
        NewStack(_) | NewThread(_, _) | NewThreadExn(_, _) | NewFrameCursor(_) => 10,
qinsoon's avatar
qinsoon committed
512 513
        ThreadExit    => 10,
        Throw(_)      => 10,
514 515
        SwapStack{..} => 10,
        CommonInst_GetThreadLocal | CommonInst_SetThreadLocal(_) => 10,
qinsoon's avatar
qinsoon committed
516
        CommonInst_Pin(_) | CommonInst_Unpin(_) => 10,
517 518 519

        // others
        Move(_) => 0,
520
        PrintHex(_) => 10,
521 522
        ExnInstruction{ref inner, ..} => estimate_insts_for_ir(&inner)
    }
523
}