codegen.rs

// Copyright 2017 The Australian National University
//
// 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
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// 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.

use ast::ir::*;
use ast::ptr::P;
use runtime::ValueLocation;

use compiler::backend::{Mem, Reg};
use compiler::machine_code::MachineCode;

pub trait CodeGenerator {
    fn start_code(&mut self, func_name: MuName, entry: MuName) -> ValueLocation;
    fn finish_code(&mut self, func_name: MuName)
        -> (Box<MachineCode + Sync + Send>, ValueLocation);

    // generate unnamed sequence of linear code (no branch)
    fn start_code_sequence(&mut self);
    fn finish_code_sequence(&mut self) -> Box<MachineCode + Sync + Send>;

    fn print_cur_code(&self);

    fn start_block(&mut self, block_name: MuName);
    fn block_exists(&self, block_name: MuName) -> bool;
    fn start_exception_block(&mut self, block_name: MuName) -> ValueLocation;
    fn end_block(&mut self, block_name: MuName);

    // add CFI info
    fn add_cfi_sections(&mut self, arg: &str);
    fn add_cfi_startproc(&mut self);
    fn add_cfi_endproc(&mut self);
    fn add_cfi_def_cfa(&mut self, reg: Reg, offset: i32);
    fn add_cfi_def_cfa_register(&mut self, reg: Reg);
    fn add_cfi_def_cfa_offset(&mut self, offset: i32);
    fn add_cfi_offset(&mut self, reg: Reg, offset: i32);

    //===========================================================================================

    // emit code to adjust frame
    fn emit_frame_grow(&mut self); // Emits a SUB

    // stack minimpulation
    fn emit_push_pair(&mut self, src1: Reg, src2: Reg, stack: Reg); // Emits a STP
    fn emit_pop_pair(&mut self, dest1: Reg, dest2: Reg, stack: Reg); // Emits a LDP

    // For callee saved loads and stores (flags them so that only they are removed)
    fn emit_ldr_callee_saved(&mut self, dest: Reg, src: Mem);
    fn emit_str_callee_saved(&mut self, dest: Mem, src: Reg);

    //===========================================================================================

    /* Bellow ar all ARMv8-A Aarch64 instruction menmonics (with all operand modes) except:
        PRFM, PRFUM, CRC32*
        All advanced SIMD instructions (except MOVI)

    NOTE:
        with loads and stores the menmonic indicated may be given a suffix indicating the size
        and signenedness of the access also b_cond's menmononic is 'B.cond' (where cond is the
        value of the 'cond' parameter) all other instructions have the menmonic being the first
        word of the function name after emit_
            (subsequent words are used to disambiguate different overloads)
    NOTE unless otherwise indicated:
        An instruction that dosn't start with an F operates on GPRS, those that start with
        an F operate on FPRs. All instructions operate on 32-bit and 64-bit registers (but all
        register arguments must be the same size) Also all arguments that may take the SP can't
        take the ZR (and vice versa)
    */

    // loads
    // supports the full full range of addressing modes
    fn emit_ldr(&mut self, dest: Reg /*GPR or FPR*/, src: Mem, signed: bool);
    fn emit_ldtr(&mut self, dest: Reg, src: Mem, signed: bool); // [base, #simm9]
    fn emit_ldur(&mut self, dest: Reg /*GPR or FPR*/, src: Mem, signed: bool); // [base, #simm9]
    fn emit_ldxr(&mut self, dest: Reg, src: Mem); // [base]
    fn emit_ldaxr(&mut self, dest: Reg, src: Mem); // [base]
    fn emit_ldar(&mut self, dest: Reg, src: Mem); // [base]

    // [base, #simm7], [base], #simm7, [base, #simm7]!
    fn emit_ldp(&mut self, dest1: Reg, dest2: Reg /*GPR or FPR*/, src: Mem);
    fn emit_ldxp(&mut self, dest1: Reg, dest2: Reg, src: Mem); // [base]
    fn emit_ldaxp(&mut self, dest1: Reg, dest2: Reg, src: Mem); // [base]
    fn emit_ldnp(
        &mut self,
        dest1: Reg, /*GPR or FPR*/
        dest2: Reg, /*GPR or FPR*/
        src: Mem,
    ); // [base, #simm7]

    // Stores
    // supports the full full range of addressing modes
    fn emit_str(&mut self, dest: Mem, src: Reg /*GPR or FPR*/);
    fn emit_sttr(&mut self, dest: Mem, src: Reg); // [base, #simm9]
    fn emit_stur(&mut self, dest: Mem, src: Reg /*GPR or FPR*/); // [base, #simm9]
    fn emit_stlr(&mut self, dest: Mem, src: Reg); // [base]
    fn emit_stxr(&mut self, dest: Mem, status: Reg, src: Reg); // [base]
    fn emit_stlxr(&mut self, dest: Mem, status: Reg, src: Reg); // [base]

    // [base, #simm7], [base], #simm7, [base, #simm7]!
    fn emit_stp(&mut self, dest: Mem, src1: Reg, src2: Reg);
    fn emit_stxp(&mut self, dest: Mem, status: Reg, src1: Reg, src2: Reg); // [base]
    fn emit_stlxp(&mut self, dest: Mem, status: Reg, src1: Reg, src2: Reg); // [base]
    fn emit_stnp(
        &mut self,
        dest: Mem,
        src1: Reg, /*GPR or FPR*/
        src2: Reg, /*GPR or FPR*/
    ); // [base, #simm7]

    // Calls
    fn emit_bl(
        &mut self,
        callsite: Option<MuName>,
        func: MuName,
        pe: Option<MuName>,
        args: Vec<P<Value>>,
        ret: Vec<P<Value>>,
        is_native: bool,
    ) -> Option<ValueLocation>;
    fn emit_blr(
        &mut self,
        callsite: Option<MuName>,
        func: Reg,
        pe: Option<MuName>,
        args: Vec<P<Value>>,
        ret: Vec<P<Value>>,
    ) -> Option<ValueLocation>;
    // Branches
    fn emit_b(&mut self, dest_name: MuName);
    fn emit_b_cond(&mut self, cond: &str, dest_name: MuName);
    fn emit_br(&mut self, dest_address: Reg);
    fn emit_b_call(
        &mut self,
        callsite: Option<MuName>,
        func: MuName,
        pe: Option<MuName>,
        args: Vec<P<Value>>,
        ret: Vec<P<Value>>,
        is_native: bool,
        may_return: bool,
    ) -> Option<ValueLocation>;
    fn emit_br_call(
        &mut self,
        callsite: Option<MuName>,
        func: Reg,
        pe: Option<MuName>,
        args: Vec<P<Value>>,
        ret: Vec<P<Value>>,
        may_return: bool,
    ) -> Option<ValueLocation>;

    fn emit_ret(&mut self, src: Reg);
    fn emit_cbnz(&mut self, src: Reg, dest_name: MuName);
    fn emit_cbz(&mut self, src: Reg, dest_name: MuName);
    fn emit_tbnz(&mut self, src1: Reg, src2: u8, dest_name: MuName);
    fn emit_tbz(&mut self, src1: Reg, src2: u8, dest_name: MuName);

    // Read and write flags
    fn emit_msr(&mut self, dest: &str, src: Reg);
    fn emit_mrs(&mut self, dest: Reg, src: &str);

    // Address calculation
    fn emit_adr(&mut self, dest: Reg, src: Mem);
    fn emit_adrp(&mut self, dest: Reg, src: Mem);

    // Unary ops
    // The SP and ZR cannot both be used
    fn emit_mov(&mut self, dest: Reg /*GPR or SP or ZR*/, src: Reg /*GPR or SP or ZR*/);
    fn emit_mvn(&mut self, dest: Reg, src: Reg);
    fn emit_neg(&mut self, dest: Reg, src: Reg);
    fn emit_negs(&mut self, dest: Reg, src: Reg);
    fn emit_ngc(&mut self, dest: Reg, src: Reg);
    fn emit_ngcs(&mut self, dest: Reg, src: Reg);
    fn emit_sxtb(&mut self, dest: Reg /*32*/, src: Reg /*32*/);
    fn emit_sxth(&mut self, dest: Reg /*32*/, src: Reg /*32*/);
    fn emit_sxtw(&mut self, dest: Reg /*64*/, src: Reg /*32*/);
    fn emit_uxtb(&mut self, dest: Reg /*32*/, src: Reg /*32*/);
    fn emit_uxth(&mut self, dest: Reg /*32*/, src: Reg /*32*/);
    fn emit_cls(&mut self, dest: Reg, src: Reg);
    fn emit_clz(&mut self, dest: Reg, src: Reg);
    fn emit_rbit(&mut self, dest: Reg, src: Reg);
    fn emit_rev(&mut self, dest: Reg, src: Reg);
    fn emit_rev16(&mut self, dest: Reg, src: Reg);
    fn emit_rev32(&mut self, dest: Reg /*64*/, src: Reg);
    fn emit_rev64(&mut self, dest: Reg /*64*/, src: Reg); // alias of REV
    fn emit_fabs(&mut self, dest: Reg, src: Reg);
    fn emit_fcvt(&mut self, dest: Reg, src: Reg /*Must have different size*/);
    fn emit_fcvtas(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtau(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtms(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtmu(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtns(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtnu(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtps(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtpu(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtzs(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    fn emit_fcvtzu(&mut self, dest: Reg /*GPR, may have different size*/, src: Reg);
    // One register must be an FPR, the other may be a GPR or an FPR
    fn emit_fmov(&mut self, dest: Reg, src: Reg);
    fn emit_fneg(&mut self, dest: Reg, src: Reg);
    fn emit_frinta(&mut self, dest: Reg, src: Reg);
    fn emit_frinti(&mut self, dest: Reg, src: Reg);
    fn emit_frintm(&mut self, dest: Reg, src: Reg);
    fn emit_frintn(&mut self, dest: Reg, src: Reg);
    fn emit_frintp(&mut self, dest: Reg, src: Reg);
    fn emit_frintx(&mut self, dest: Reg, src: Reg);
    fn emit_frintz(&mut self, dest: Reg, src: Reg);
    fn emit_fsqrt(&mut self, dest: Reg, src: Reg);
    fn emit_scvtf(&mut self, dest: Reg /*FPR, may have different size*/, src: Reg);
    fn emit_ucvtf(&mut self, dest: Reg /*FPR, may have different size*/, src: Reg);

    // Unary operations with shift
    fn emit_mov_shift(&mut self, dest: Reg, src: Reg, shift: &str, ammount: u8);
    fn emit_mvn_shift(&mut self, dest: Reg, src: Reg, shift: &str, ammount: u8);
    fn emit_neg_shift(&mut self, dest: Reg, src: Reg, shift: &str, ammount: u8);
    fn emit_negs_shift(&mut self, dest: Reg, src: Reg, shift: &str, ammount: u8);

    // Unary operations with immediates
    fn emit_mov_imm(&mut self, dest: Reg, src: u64);
    fn emit_movz(&mut self, dest: Reg, src: u16, shift: u8);
    fn emit_movk(&mut self, dest: Reg, src: u16, shift: u8);
    fn emit_movn(&mut self, dest: Reg, src: u16, shift: u8);
    fn emit_movi(&mut self, dest: Reg /*FPR*/, src: u64);
    fn emit_fmov_imm(&mut self, dest: Reg, src: f32);

    // Extended binary ops
    fn emit_add_ext(
        &mut self,
        dest: Reg, /*GPR or SP*/
        src1: Reg, /*GPR or SP*/
        src2: Reg,
        signed: bool,
        shift: u8,
    );
    fn emit_adds_ext(
        &mut self,
        dest: Reg,
        src1: Reg, /*GPR or SP*/
        src2: Reg,
        signed: bool,
        shift: u8,
    );
    fn emit_sub_ext(
        &mut self,
        dest: Reg, /*GPR or SP*/
        src1: Reg, /*GPR or SP*/
        src2: Reg,
        signed: bool,
        shift: u8,
    );
    fn emit_subs_ext(
        &mut self,
        dest: Reg,
        src1: Reg, /*GPR or SP*/
        src2: Reg,
        signed: bool,
        shift: u8,
    );

    // Multiplication
    fn emit_mul(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_mneg(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_smulh(&mut self, dest: Reg /*64*/, src1: Reg /*64*/, src2: Reg /*64*/);
    fn emit_umulh(&mut self, dest: Reg /*64*/, src1: Reg /*64*/, src2: Reg /*64*/);
    fn emit_smnegl(&mut self, dest: Reg /*64*/, src1: Reg /*32*/, src2: Reg /*32*/);
    fn emit_smull(&mut self, dest: Reg /*64*/, src1: Reg /*32*/, src2: Reg /*32*/);
    fn emit_umnegl(&mut self, dest: Reg /*64*/, src1: Reg /*32*/, src2: Reg /*32*/);
    fn emit_umull(&mut self, dest: Reg /*64*/, src1: Reg /*32*/, src2: Reg /*32*/);

    // Other binaries
    fn emit_adc(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_adcs(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_add(&mut self, dest: Reg, src1: Reg /*GPR or SP*/, src2: Reg);
    fn emit_adds(&mut self, dest: Reg, src1: Reg /*GPR or SP*/, src2: Reg);
    fn emit_sbc(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_sbcs(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_sub(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_subs(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_sdiv(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_udiv(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_asr(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_asrv(&mut self, dest: Reg, src1: Reg, src2: Reg); // Alias of ASR
    fn emit_lsl(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_lslv(&mut self, dest: Reg, src1: Reg, src2: Reg); // Alias of LSL
    fn emit_lsr(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_lsrv(&mut self, dest: Reg, src1: Reg, src2: Reg); // Alias of LSR
    fn emit_ror(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_bic(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_bics(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_and(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_ands(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_eon(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_eor(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_orn(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_orr(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fadd(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fdiv(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fmax(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fmaxnm(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fmin(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fminm(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fmul(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fnmul(&mut self, dest: Reg, src1: Reg, src2: Reg);
    fn emit_fsub(&mut self, dest: Reg, src1: Reg, src2: Reg);

    // Binary operations with shift
    fn emit_add_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_adds_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_sub_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_subs_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_bic_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_bics_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_and_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_ands_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_eon_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_eor_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_orn_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);
    fn emit_orr_shift(&mut self, dest: Reg, src1: Reg, src2: Reg, shift: &str, amount: u8);

    // binary ops with immediates
    fn emit_add_imm(
        &mut self,
        dest: Reg, /*GPR or SP*/
        src1: Reg, /*GPR or SP*/
        src2: u16,
        shift: bool,
    );
    fn emit_adds_imm(&mut self, dest: Reg, src1: Reg /*GPR or SP*/, src2: u16, shift: bool);
    fn emit_sub_imm(
        &mut self,
        dest: Reg, /*GPR or SP*/
        src1: Reg, /*GPR or SP*/
        src2: u16,
        shift: bool,
    );
    fn emit_subs_imm(&mut self, dest: Reg, src1: Reg /*GPR or SP*/, src2: u16, shift: bool);

    fn emit_and_imm(&mut self, dest: Reg /*GPR or SP*/, src1: Reg, src2: u64);
    fn emit_ands_imm(&mut self, dest: Reg, src1: Reg, src2: u64);
    fn emit_eor_imm(&mut self, dest: Reg /*GPR or SP*/, src1: Reg, src2: u64);
    fn emit_orr_imm(&mut self, dest: Reg /*GPR or SP*/, src1: Reg, src2: u64);

    fn emit_asr_imm(&mut self, dest: Reg, src1: Reg, src2: u8);
    fn emit_lsr_imm(&mut self, dest: Reg, src1: Reg, src2: u8);
    fn emit_lsl_imm(&mut self, dest: Reg, src1: Reg, src2: u8);
    fn emit_ror_imm(&mut self, dest: Reg, src1: Reg, src2: u8);

    // ternary ops

    fn emit_madd(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);
    fn emit_msub(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);
    fn emit_smaddl(
        &mut self,
        dest: Reg, /*64*/
        src1: Reg, /*32*/
        src2: Reg, /*32*/
        src3: Reg, /*64*/
    );
    fn emit_smsubl(
        &mut self,
        dest: Reg, /*64*/
        src1: Reg, /*32*/
        src2: Reg, /*32*/
        src3: Reg, /*64*/
    );
    fn emit_umaddl(
        &mut self,
        dest: Reg, /*64*/
        src1: Reg, /*32*/
        src2: Reg, /*32*/
        src3: Reg, /*64*/
    );
    fn emit_umsubl(
        &mut self,
        dest: Reg, /*64*/
        src1: Reg, /*32*/
        src2: Reg, /*32*/
        src3: Reg, /*64*/
    );
    fn emit_fmadd(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);
    fn emit_fmsub(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);
    fn emit_fnmadd(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);
    fn emit_fnmsub(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: Reg);

    // Ternary ops with immediates
    fn emit_bfm(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_bfi(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_bfxil(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_ubfm(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_ubfx(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_ubfiz(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_sbfm(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_sbfx(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);
    fn emit_sbfiz(&mut self, dest: Reg, src1: Reg, src2: u8, src3: u8);

    // Comparison (dosn't store a result, only updates flags)
    fn emit_tst(&mut self, src1: Reg, src2: Reg);
    fn emit_cmn(&mut self, src1: Reg, src2: Reg);
    fn emit_cmp(&mut self, src1: Reg, src2: Reg);
    fn emit_fcmp(&mut self, src1: Reg, src2: Reg);
    fn emit_fcmpe(&mut self, src1: Reg, src2: Reg);

    // Comparisons with extension
    fn emit_cmn_ext(&mut self, src1: Reg /*GPR or SP*/, src2: Reg, signed: bool, shift: u8);
    fn emit_cmp_ext(&mut self, src1: Reg /*GPR or SP*/, src2: Reg, signed: bool, shift: u8);

    // Comparisons with shift
    fn emit_tst_shift(&mut self, src1: Reg, src2: Reg, shift: &str, ammount: u8);
    fn emit_cmn_shift(&mut self, src1: Reg, src2: Reg, shift: &str, ammount: u8);
    fn emit_cmp_shift(&mut self, src1: Reg, src2: Reg, shift: &str, ammount: u8);

    // Immediat Comparisons
    fn emit_tst_imm(&mut self, src1: Reg, src2: u64);
    fn emit_cmn_imm(&mut self, src1: Reg /*GPR or SP*/, src2: u16, shift: bool);
    fn emit_cmp_imm(&mut self, src1: Reg /*GPR or SP*/, src2: u16, shift: bool);

    // Comparison against 0
    fn emit_fcmp_0(&mut self, src: Reg);
    fn emit_fcmpe_0(&mut self, src: Reg);

    // Conditional ops
    fn emit_cset(&mut self, dest: Reg, cond: &str);
    fn emit_csetm(&mut self, dest: Reg, cond: &str);

    // Conditional unary ops
    fn emit_cinc(&mut self, dest: Reg, src: Reg, cond: &str);
    fn emit_cneg(&mut self, dest: Reg, src: Reg, cond: &str);
    fn emit_cinv(&mut self, dest: Reg, src: Reg, cond: &str);

    // Conditional binary ops
    fn emit_csel(&mut self, dest: Reg, src1: Reg, src2: Reg, cond: &str);
    fn emit_csinc(&mut self, dest: Reg, src1: Reg, src2: Reg, cond: &str);
    fn emit_csinv(&mut self, dest: Reg, src1: Reg, src2: Reg, cond: &str);
    fn emit_csneg(&mut self, dest: Reg, src1: Reg, src2: Reg, cond: &str);
    fn emit_fcsel(&mut self, dest: Reg, src1: Reg, src2: Reg, cond: &str);

    // Conditional comparisons
    fn emit_ccmn(&mut self, src1: Reg, src2: Reg, flags: u8, cond: &str);
    fn emit_ccmp(&mut self, src1: Reg, src2: Reg, flags: u8, cond: &str);
    fn emit_fccmp(&mut self, src1: Reg, src2: Reg, flags: u8, cond: &str);
    fn emit_fccmpe(&mut self, src1: Reg, src2: Reg, flags: u8, cond: &str);

    // Conditional comparisons (with immediate)
    fn emit_ccmn_imm(&mut self, src1: Reg, src2: u8, flags: u8, cond: &str);
    fn emit_ccmp_imm(&mut self, src1: Reg, src2: u8, flags: u8, cond: &str);

    fn emit_bfc(&mut self, dest: Reg, src1: u8, src2: u8);
    fn emit_extr(&mut self, dest: Reg, src1: Reg, src2: Reg, src3: u8);

    // Synchronisation
    fn emit_dsb(&mut self, option: &str);
    fn emit_dmb(&mut self, option: &str);
    fn emit_isb(&mut self, option: &str);
    fn emit_clrex(&mut self);

    // Hint instructions
    fn emit_sevl(&mut self);
    fn emit_sev(&mut self);
    fn emit_wfe(&mut self);
    fn emit_wfi(&mut self);
    fn emit_yield(&mut self);
    fn emit_nop(&mut self);
    fn emit_hint(&mut self, val: u8);

    // Debug instructions
    fn emit_drps(&mut self);
    fn emit_dcps1(&mut self, val: u16);
    fn emit_dcps2(&mut self, val: u16);
    fn emit_dcps3(&mut self, val: u16);

    // System instruction
    fn emit_dc(&mut self, option: &str, src: Reg);
    fn emit_at(&mut self, option: &str, src: Reg);
    fn emit_ic(&mut self, option: &str, src: Reg);
    fn emit_tlbi(&mut self, option: &str, src: Reg);

    fn emit_sys(&mut self, imm1: u8, cn: u8, cm: u8, imm2: u8, src: Reg);
    fn emit_sysl(&mut self, dest: Reg, imm1: u8, cn: u8, cm: u8, imm2: u8);

    // Exceptiuon instructions (NOTE: these will alter the PC)
    fn emit_brk(&mut self, val: u16);
    fn emit_hlt(&mut self, val: u16);
    fn emit_hvc(&mut self, val: u16);
    fn emit_smc(&mut self, val: u16);
    fn emit_svc(&mut self, val: u16);
    fn emit_eret(&mut self);
}