text
stringlengths 12
786k
|
|---|
let emit_movsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x10 ] rm ( rd_of_regf reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Regf reg -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x11 ] rm ( rd_of_regf reg ) | _ -> Format . eprintf " src =% a dst =% a . " @ print_old_arg src print_old_arg dst ; assert false |
let emit_movss b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF3 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x10 ] rm ( rd_of_regf reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Regf reg -> buf_int8 b 0xF3 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x11 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_andpd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x54 ] rm ( rd_of_regf reg ) | _ -> assert false |
let imm8_of_rounding rounding = match rounding with | RoundNearest -> 0b0000 | RoundDown -> 0b0001 | RoundUp -> 0b0010 | RoundTruncate -> 0b0011 |
let emit_roundsd b dst rounding src = let rounding = imm8_of_rounding rounding in match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x3A ; 0x0B ] rm ( rd_of_regf reg ) ; buf_int8 b rounding | _ -> assert false |
let emit_addsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x58 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_sqrtsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x51 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_mulsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x59 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_divsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x5E ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_subsd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x5C ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_xorpd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x57 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_CVTSI2SD b dst src = match ( dst , src ) with | Regf reg , ( ( Reg64 _ | Mem { typ = QWORD } ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b rexw [ 0x0f ; 0x2A ] rm ( rd_of_regf reg ) | Regf reg , ( ( Reg32 _ | Mem { typ = DWORD } ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x2A ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_CVTSD2SI b dst src = match ( dst , src ) with | Reg64 reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b rexw [ 0x0f ; 0x2D ] rm ( rd_of_reg64 reg ) | Reg32 reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x2D ] rm ( rd_of_reg64 reg ) | _ -> assert false |
let emit_CVTTSD2SI b dst src = match ( dst , src ) with | Reg64 reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b rexw [ 0x0f ; 0x2C ] rm ( rd_of_reg64 reg ) | Reg32 reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x2C ] rm ( rd_of_reg64 reg ) | _ -> assert false |
let emit_CVTSD2SS b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF2 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x5A ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_CVTSS2SD b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0xF3 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x5A ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_comisd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x2F ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_ucomisd b dst src = match ( dst , src ) with | Regf reg , ( ( Regf _ | Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x2E ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_MOV b dst src = match ( dst , src ) with | ( ( Reg8L ( RAX | RCX | RDX | RBX ) | Reg8H _ ) as r8 ) , Imm n -> assert ( is_imm8L n ) ; buf_opcodes b [ 0xB0 + reg7 ( rd_of_reg8 r8 ) ] ; buf_int8L b n | ( ( Mem _ | Mem64_RIP _ ) as rm ) , ( ( Reg8L _ | Reg8H _ ) as reg ) -> emit_mod_rm_reg b ( rex_of_reg8 reg ) [ 0x88 ] rm ( rd_of_reg8 reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Reg16 reg -> buf_int8 b 0x66 ; emit_mod_rm_reg b rex [ 0x89 ] rm ( rd_of_reg64 reg ) | Reg16 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b rex [ 0x8B ] rm ( rd_of_reg64 reg ) | Reg32 reg32 , ( ( Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) -> let reg = rd_of_reg64 reg32 in emit_mod_rm_reg b 0 [ 0x8B ] rm reg | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Reg32 reg32 -> let reg = rd_of_reg64 reg32 in emit_mod_rm_reg b 0 [ 0x89 ] rm reg | ( Mem { typ = DWORD } as rm ) , ( ( Imm _ | Sym _ ) as n ) -> emit_mod_rm_reg b 0 [ 0xC7 ] rm 0 ; buf_int32_imm b n | ( Mem { typ = NONE ; arch = X86 } as rm ) , ( ( Imm _ | Sym _ ) as n ) -> let reg = 0 in emit_mod_rm_reg b 0 [ 0xC7 ] rm reg ; buf_int32_imm b n | Reg32 r32 , ( ( Imm _ | Sym _ ) as n ) -> let n = match n with | Imm n -> Imm ( Int64 . of_int32 ( Int64 . to_int32 n ) ) | _ as n -> n in let reg = rd_of_reg64 r32 in emit_rex b ( rexb_opcode reg ) ; buf_int8 b ( 0xB8 lor reg7 reg ) ; buf_int32_imm b n | Reg64 reg , ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b rexw [ 0x8B ] rm ( rd_of_reg64 reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Reg64 reg -> emit_mod_rm_reg b rexw [ 0x89 ] rm ( rd_of_reg64 reg ) | Reg64 r64 , Imm n when not ( is_imm32L n ) -> let reg = rd_of_reg64 r64 in emit_rex b ( rexw lor rexb_opcode reg ) ; buf_int8 b ( 0xB8 lor reg7 reg ) ; buf_int64L b n | Reg64 r64 , Sym symbol when windows -> let reg = rd_of_reg64 r64 in emit_rex b ( rexw lor rexb_opcode reg ) ; buf_int8 b ( 0xB8 lor reg7 reg ) ; sym64 b symbol | ( ( Mem { arch = X64 } | Reg64 _ ) as rm ) , ( ( Imm _ | Sym _ ) as n ) -> emit_mod_rm_reg b rexw [ 0xC7 ] rm 0 ; buf_int32_imm b n | _ -> Format . printf " dst = % a . " @ print_old_arg dst ; Format . printf " src = % a . " @ print_old_arg src ; assert false |
type simple_encoding = { rm8_r8 : int list ; rm64_r64 : int list ; r8_rm8 : int list ; r64_rm64 : int list ; al_imm8 : int list ; rax_imm32 : int list ; rm8_imm8 : int list ; rm64_imm32 : int list ; rm64_imm8 : int list ; reg : int ; } |
let emit_simple_encoding enc b dst src = match ( enc , dst , src ) with | { rm64_r64 = opcodes } , ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg64 reg -> emit_mod_rm_reg b rexw opcodes rm ( rd_of_reg64 reg ) | { rm64_r64 = opcodes } , ( ( Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg32 reg -> emit_mod_rm_reg b 0 opcodes rm ( rd_of_reg64 reg ) | { r64_rm64 = opcodes } , Reg64 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b rexw opcodes rm ( rd_of_reg64 reg ) | { r64_rm64 = opcodes } , Reg32 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b 0 opcodes rm ( rd_of_reg64 reg ) | ( { rm64_imm8 = opcodes ; reg } , ( ( Reg64 _ | Mem { typ = NONE | QWORD | REAL8 ; arch = X64 } ) as rm ) , Imm n ) when is_imm8L n -> emit_mod_rm_reg b rexw opcodes rm reg ; buf_int8L b n | ( { rm8_imm8 = opcodes ; reg } , ( ( Reg8L _ | Reg8H _ | Mem { typ = BYTE ; arch = X64 } ) as rm ) , Imm n ) -> assert ( is_imm8L n ) ; emit_mod_rm_reg b rexw opcodes rm reg ; buf_int8L b n | ( { rm64_imm8 = opcodes ; reg } , ( ( Reg32 _ | Mem { typ = DWORD | REAL4 } | Mem { typ = NONE ; arch = X86 } ) as rm ) , Imm n ) when is_imm8L n -> emit_mod_rm_reg b 0 opcodes rm reg ; buf_int8L b n | { rax_imm32 = opcodes } , Reg64 RAX , ( ( Imm _ | Sym _ ) as n ) -> emit_rex b rexw ; buf_opcodes b opcodes ; buf_int32_imm b n | { rax_imm32 = opcodes } , Reg32 RAX , ( ( Imm _ | Sym _ ) as n ) -> buf_opcodes b opcodes ; buf_int32_imm b n | ( { rm64_imm32 = opcodes ; reg } , ( ( Reg32 _ | Mem { typ = NONE ; arch = X86 } | Mem { typ = DWORD | REAL4 } ) as rm ) , ( ( Imm _ | Sym _ ) as n ) ) -> emit_mod_rm_reg b 0 opcodes rm reg ; buf_int32_imm b n | ( { rm64_imm32 = opcodes ; reg } , ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) , ( ( Imm _ | Sym _ ) as n ) ) -> emit_mod_rm_reg b rexw opcodes rm reg ; buf_int32_imm b n | _ -> Format . eprintf " src =% a dst =% a . " @ print_old_arg src print_old_arg dst ; assert false |
let emit_simple_encoding base reg = emit_simple_encoding { rm8_r8 = [ base ] ; rm64_r64 = [ base + 1 ] ; r8_rm8 = [ base + 2 ] ; r64_rm64 = [ base + 3 ] ; al_imm8 = [ base + 4 ] ; rax_imm32 = [ base + 5 ] ; rm8_imm8 = [ 0x80 ] ; rm64_imm32 = [ 0x81 ] ; rm64_imm8 = [ 0x83 ] ; reg ; } |
let emit_ADD = emit_simple_encoding 0x00 0 |
let emit_OR = emit_simple_encoding 0x08 1 |
let emit_AND = emit_simple_encoding 0x20 4 |
let emit_SUB = emit_simple_encoding 0x28 5 |
let emit_XOR = emit_simple_encoding 0x30 6 |
let emit_CMP = emit_simple_encoding 0x38 7 |
let emit_test b dst src = match ( dst , src ) with | ( ( Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg32 reg -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b 0 [ 0x85 ] rm reg | ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg64 reg -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x85 ] rm reg | Reg64 RAX , ( ( Imm _ | Sym _ ) as n ) -> emit_rex b rexw ; buf_opcodes b [ 0xA9 ] ; buf_int32_imm b n | Reg32 RAX , ( ( Imm _ | Sym _ ) as n ) -> buf_opcodes b [ 0xA9 ] ; buf_int32_imm b n | ( ( Reg32 _ | Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) , ( ( Imm _ | Sym _ ) as n ) -> emit_mod_rm_reg b rexw [ 0xF7 ] rm 0 ; buf_int32_imm b n | Reg8L RAX , Imm n -> assert ( is_imm8L n ) ; buf_opcodes b [ 0xA8 ] ; buf_int8L b n | ( ( Reg8L _ | Reg8H _ ) as rm ) , Imm n -> assert ( is_imm8L n ) ; emit_mod_rm_reg b 0 [ 0xF6 ] rm 0 ; buf_int8L b n | _ -> assert false |
let emit_imul b dst src = match ( dst , src ) with | Some ( Reg32 reg ) , ( ( Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b 0 [ 0x0F ; 0xAF ] rm reg | Some ( Reg64 reg ) , ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x0F ; 0xAF ] rm reg | Some ( ( Reg64 reg | Reg32 reg ) as rm ) , Imm n when is_imm8L n -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x6B ] rm reg ; buf_int8L b n | Some ( ( Reg64 reg | Reg32 reg ) as rm ) , ( ( Imm _ | Sym _ ) as n ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x69 ] rm reg ; buf_int32_imm b n | None , ( ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) -> let reg = 5 in emit_mod_rm_reg b rexw [ 0xF7 ] rm reg | _ -> assert false |
let emit_idiv b dst = let reg = 7 in match dst with | ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b rexw [ 0xF7 ] rm reg | _ -> assert false |
let emit_shift reg b dst src = match ( dst , src ) with | ( ( Reg64 _ | Reg32 _ | Mem _ ) as rm ) , Imm 1L -> emit_mod_rm_reg b rexw [ 0xD1 ] rm reg | ( ( Reg64 _ | Reg32 _ | Mem _ ) as rm ) , Imm n -> assert ( is_imm8L n ) ; emit_mod_rm_reg b rexw [ 0xC1 ] rm reg ; buf_int8L b n | ( ( Reg64 _ | Reg32 _ ) as rm ) , Reg8L RCX -> emit_mod_rm_reg b rexw [ 0xD3 ] rm reg | _ -> Format . eprintf " emit_shift : src =% a dst =% a . " @ print_old_arg src print_old_arg dst ; assert false |
let emit_SAL b dst src = emit_shift 4 b dst src |
let emit_SHR b dst src = emit_shift 5 b dst src |
let emit_SAR b dst src = emit_shift 7 b dst src |
let record_local_reloc b local_reloc = local_relocs := ( Buffer . length b . buf , local_reloc ) :: ! local_relocs |
let emit_reloc_jump near_opcodes far_opcodes b loc symbol = if String . Map . mem symbol ! local_labels then let target_loc = String . Map . find symbol ! local_labels in if target_loc < loc then ( let target_pos = try label_pos b symbol with Not_found -> assert false in let source_pos = Buffer . length b . buf in assert ( target_pos < source_pos ) ; let togo = Int64 . of_int ( target_pos - source_pos ) in let togo_short = Int64 . sub togo ( Int64 . of_int ( 1 + List . length near_opcodes ) ) in if togo_short >= - 128L && togo_short < 128L then ( buf_opcodes b near_opcodes ; buf_int8L b togo_short ) else ( buf_opcodes b far_opcodes ; buf_int32L b ( Int64 . sub togo ( Int64 . of_int ( 4 + List . length far_opcodes ) ) ) ) ) else let force_far = Int64 . of_int ( ( target_loc - loc ) * ! instr_size ) >= 120L || IntSet . mem loc ! forced_long_jumps in if force_far then ( buf_opcodes b far_opcodes ; record_local_reloc b ( RelocLongJump symbol ) ; buf_int32L b 0L ) else ( buf_opcodes b near_opcodes ; record_local_reloc b ( RelocShortJump ( symbol , loc ) ) ; buf_int8L b 0L ) else ( buf_opcodes b far_opcodes ; record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . REL32 ( symbol , 0L ) ) ; buf_int32L b 0L ) |
let emit_jmp b loc dst = match dst with | Sym symbol -> emit_reloc_jump [ 0xEB ] [ 0xE9 ] b loc symbol | ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm -> let reg = 4 in emit_mod_rm_reg b 0 [ 0xFF ] rm reg | _ -> assert false |
let emit_call b dst = match dst with | Sym symbol -> buf_int8 b 0xE8 ; if String . Map . mem symbol ! local_labels then record_local_reloc b ( RelocCall symbol ) else record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . REL32 ( symbol , 0L ) ) ; buf_int32L b 0L | ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b no_rex [ 0xFF ] rm 2 | _ -> assert false |
let emit_j b loc condition dst = match dst with | Sym symbol -> let opcode_offset = cd_of_condition condition in emit_reloc_jump [ 0x70 + opcode_offset ] [ 0x0F ; 0x80 + opcode_offset ] b loc symbol | _ -> assert false |
let emit_cmov b condition dst src = match ( dst , src ) with | ( Reg64 reg | Reg32 reg ) , ( ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b rexw [ 0x0F ; 0x40 + cd_of_condition condition ] rm ( rd_of_reg64 reg ) | _ -> assert false |
let emit_set b condition dst = match dst with | ( Reg8L _ | Reg8H _ ) as rm -> emit_mod_rm_reg b 0 [ 0x0F ; 0x90 + cd_of_condition condition ] rm 0 | _ -> assert false |
let emit_movsx b dst src = match ( dst , src ) with | ( Reg64 reg | Reg32 reg ) , ( ( Mem { typ = BYTE } | Reg8L _ | Reg8H _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rex [ 0x0F ; 0xBE ] rm reg | ( Reg64 reg | Reg32 reg ) , ( ( Mem { typ = WORD } | Reg16 _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x0F ; 0xBF ] rm reg | _ -> assert false |
let emit_movsxd b dst src = match ( dst , src ) with | ( Reg64 reg | Reg32 reg ) , ( ( Mem _ | Mem64_RIP _ | Reg32 _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x63 ] rm reg | _ -> assert false |
let emit_MOVZX b dst src = match ( dst , src ) with | ( Reg64 reg | Reg32 reg ) , ( ( Mem { typ = BYTE } | Reg8L _ | Reg8H _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x0F ; 0xB6 ] rm reg | Reg64 reg , ( ( Mem { typ = WORD } | Reg16 _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x0F ; 0xB7 ] rm reg | Reg32 reg , ( ( Mem { typ = WORD } | Reg16 _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b 0 [ 0x0F ; 0xB7 ] rm reg | _ -> assert false |
let emit_FSTP b dst = match dst with | Mem { typ = REAL8 | QWORD } as rm -> emit_mod_rm_reg b 0 [ 0xDD ] rm 3 | Mem { typ = REAL4 } as rm -> emit_mod_rm_reg b 0 [ 0xD9 ] rm 3 | Regf ( ST i ) -> buf_opcodes b [ 0xDD ; 0xD8 + i ] | _ -> assert false |
let emit_neg b dst = match dst with | ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b rexw [ 0xF7 ] rm 3 | _ -> assert false |
let emit_LEA b dst src = match ( dst , src ) with | Reg64 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b rexw [ 0x8D ] rm reg | Reg32 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> let reg = rd_of_reg64 reg in emit_mod_rm_reg b 0 [ 0x8D ] rm reg | _ -> Format . eprintf " lea src =% a dst =% a . " @ print_old_arg src print_old_arg dst ; assert false |
let emit_stack_reg b opcode dst = match dst with | Reg64 reg -> let reg = rd_of_reg64 reg in if reg > 7 then emit_rex b ( rex lor rexb_opcode reg ) ; buf_int8 b ( opcode + reg7 reg ) | Reg32 reg -> let reg = rd_of_reg64 reg in buf_int8 b ( opcode + reg7 reg ) | _ -> assert false |
let emit_push b dst = match dst with | Reg32 _ | Reg64 _ -> emit_stack_reg b 0x50 dst | ( Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b no_rex [ 0xFF ] rm 6 | Imm n -> if is_imm8L n then ( buf_int8 b 0x6A ; buf_int8L b n ) else ( assert ( is_imm32L n ) ; buf_int8 b 0x68 ; buf_int32L b n ) | Sym sym -> buf_int8 b 0x68 ; sym32 b sym | _ -> assert false |
let emit_pop b dst = match dst with | Reg32 _ | Reg64 _ -> emit_stack_reg b 0x58 dst | ( Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b no_rex [ 0x8F ] rm 0 | _ -> assert false |
let emit_leave b = buf_int8 b 0xC9 |
let emit_inc b = function | ( Reg64 _ | Reg32 _ | Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b rexw [ 0xFF ] rm 0 | _ -> assert false |
let emit_DEC b = function | [ ( ( Reg8L _ | Reg8H _ | Mem { typ = BYTE } ) as rm ) ] -> emit_mod_rm_reg b no_rex [ 0xFE ] rm 1 | [ ( ( Reg16 _ | Mem { typ = WORD } ) as rm ) ] -> emit_mod_rm_reg b no_rex [ 0x66 ; 0xFF ] rm 1 | [ ( ( Reg32 _ | Mem { typ = DWORD } ) as rm ) ] -> emit_mod_rm_reg b no_rex [ 0xFF ] rm 1 | [ ( ( Reg64 _ | Mem { typ = QWORD } ) as rm ) ] -> emit_mod_rm_reg b rexw [ 0xFF ] rm 1 | _ -> assert false |
let emit_ret b = buf_int8 b 0xC3 |
let emit_cqto b = emit_rex b rexw ; buf_int8 b 0x99 |
let emit_BSWAP b = function | Reg32 reg -> buf_opcodes b [ 0x0F ; 0xC8 + reg7 ( rd_of_reg64 reg ) ] | Reg64 reg -> let reg = rd_of_reg64 reg in emit_rex b ( rexw lor rexb_opcode reg ) ; buf_opcodes b [ 0x0F ; 0xC8 + reg7 reg ] | _ -> assert false |
let emit_FLDCW b = function | ( Mem _ | Mem64_RIP _ ) as rm -> emit_mod_rm_reg b no_rex [ 0xD9 ] rm 5 | _ -> assert false |
let emit_FXCH b = function | Regf ( ST i ) -> buf_opcodes b [ 0xD9 ; 0xC8 + i ] | _ -> assert false |
let emit_FLD b = function | Mem { typ = REAL4 | DWORD } as rm -> emit_mod_rm_reg b 0 [ 0xD9 ] rm 0 | Mem { typ = REAL8 | QWORD } as rm -> emit_mod_rm_reg b 0 [ 0xDD ] rm 0 | Regf ( ST i ) -> buf_opcodes b [ 0xD9 ; 0xC0 + i ] | _ -> assert false |
let emit_FCOMP b = function | Mem { typ = REAL4 | DWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xD8 ] rm 3 | Mem { typ = REAL8 | QWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDC ] rm 3 | Regf ( ST i ) -> buf_opcodes b [ 0xD8 ; 0xD8 + i ] | _ -> assert false |
let emit_FXXX reg b rm = match rm with | Mem { typ = REAL4 | DWORD } -> emit_mod_rm_reg b no_rex [ 0xD8 ] rm reg | Mem { typ = REAL8 | QWORD } -> emit_mod_rm_reg b no_rex [ 0xDC ] rm reg | _ -> assert false |
let emit_FADD = emit_FXXX 0 |
let emit_FMUL = emit_FXXX 1 |
let emit_FSUB = emit_FXXX 4 |
let emit_FSUBR = emit_FXXX 5 |
let emit_FDIV = emit_FXXX 6 |
let emit_FDIVR = emit_FXXX 7 |
let emit_FILD b = function | Mem { typ = QWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDF ] rm 5 | Mem { typ = DWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDB ] rm 0 | Mem { typ = WORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDF ] rm 0 | _ -> assert false |
let emit_FISTP b = function | Mem { typ = WORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDF ] rm 3 | Mem { typ = DWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDB ] rm 3 | Mem { typ = QWORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDF ] rm 7 | _ -> assert false |
let emit_FNSTCW b = function | Mem { typ = NONE | WORD } as rm -> emit_mod_rm_reg b no_rex [ 0x9B ; 0xD9 ] rm 7 | _ -> assert false |
let emit_FNSTSW b = function | Reg16 RAX -> buf_opcodes b [ 0xDF ; 0xE0 ] | Mem { typ = NONE | WORD } as rm -> emit_mod_rm_reg b no_rex [ 0xDD ] rm 7 | _ -> assert false |
let emit_FXXXP opcode b a1 a2 = match ( a1 , a2 ) with | Regf ( ST i ) , Regf ( ST 0 ) -> buf_opcodes b [ 0xDE ; opcode + i ] | _ -> assert false |
let emit_FADDP b = emit_FXXXP 0xC0 b |
let emit_FMULP b = emit_FXXXP 0xC8 b |
let emit_FSUBRP b = emit_FXXXP 0xE0 b |
let emit_FSUBP b = emit_FXXXP 0xE8 b |
let emit_FDIVRP b = emit_FXXXP 0xF0 b |
let emit_FDIVP b = emit_FXXXP 0xF8 b |
let emit_XCHG b src dst = match ( dst , src ) with | ( ( Reg64 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg64 reg | Reg64 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b rexw [ 0x87 ] rm ( rd_of_reg64 reg ) | ( ( Reg32 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg32 reg | Reg32 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b no_rex [ 0x87 ] rm ( rd_of_reg64 reg ) | ( ( Reg16 _ | Mem _ | Mem64_RIP _ ) as rm ) , Reg16 reg | Reg16 reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b rex [ 0x66 ; 0x87 ] rm ( rd_of_reg64 reg ) | ( ( ( Reg8L _ | Reg8H _ | Mem _ | Mem64_RIP _ ) as rm ) , ( ( Reg8L _ | Reg8H _ ) as reg ) ) | ( ( Reg8L _ | Reg8H _ ) as reg ) , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> emit_mod_rm_reg b no_rex [ 0x86 ] rm ( rd_of_reg8 reg ) | _ -> assert false |
let assemble_instr b loc = function | ADD ( src , dst ) -> emit_ADD b dst src | ADDSD ( src , dst ) -> emit_addsd b dst src | AND ( src , dst ) -> emit_AND b dst src | ANDPD ( src , dst ) -> emit_andpd b dst src | BSWAP arg -> emit_BSWAP b arg | CALL dst -> emit_call b dst | CVTSI2SD ( src , dst ) -> emit_CVTSI2SD b dst src | CVTSD2SI ( src , dst ) -> emit_CVTSD2SI b dst src | CVTTSD2SI ( src , dst ) -> emit_CVTTSD2SI b dst src | CVTSD2SS ( src , dst ) -> emit_CVTSD2SS b dst src | CVTSS2SD ( src , dst ) -> emit_CVTSS2SD b dst src | COMISD ( src , dst ) -> emit_comisd b dst src | CQO -> emit_cqto b | CMP ( src , dst ) -> emit_CMP b dst src | CMOV ( condition , src , dst ) -> emit_cmov b condition dst src | CDQ -> buf_int8 b 0x99 | DIVSD ( src , dst ) -> emit_divsd b dst src | DEC dst -> emit_DEC b [ dst ] | FCOMPP -> buf_opcodes b [ 0xDE ; 0xD9 ] | FLD1 -> buf_opcodes b [ 0xD9 ; 0xE8 ] | FLDLG2 -> buf_opcodes b [ 0xD9 ; 0xEC ] | FLDLN2 -> buf_opcodes b [ 0xD9 ; 0xED ] | FLDZ -> buf_opcodes b [ 0xD9 ; 0xEE ] | FPATAN -> buf_opcodes b [ 0xD9 ; 0xF3 ] | FCOS -> buf_opcodes b [ 0xD9 ; 0xFF ] | FYL2X -> buf_opcodes b [ 0xD9 ; 0xF1 ] | FSIN -> buf_opcodes b [ 0xD9 ; 0xFE ] | FSQRT -> buf_opcodes b [ 0xD9 ; 0xFA ] | FPTAN -> buf_opcodes b [ 0xD9 ; 0xF2 ] | FSTP dst -> emit_FSTP b dst | FXCH arg -> emit_FXCH b arg | FCOMP arg -> emit_FCOMP b arg | FNSTSW arg -> emit_FNSTSW b arg | FNSTCW arg -> emit_FNSTCW b arg | FCHS -> buf_opcodes b [ 0xD9 ; 0xE0 ] | FABS -> buf_opcodes b [ 0xD9 ; 0xE1 ] | FADD arg -> emit_FADD b arg | FSUB arg -> emit_FSUB b arg | FMUL arg -> emit_FMUL b arg | FDIV arg -> emit_FDIV b arg | FDIVR arg -> emit_FDIVR b arg | FSUBR arg -> emit_FSUBR b arg | FILD arg -> emit_FILD b arg | FISTP arg -> emit_FISTP b arg | FLD arg -> emit_FLD b arg | FLDCW arg -> emit_FLDCW b arg | FADDP ( src , dst ) -> emit_FADDP b dst src | FSUBP ( src , dst ) -> emit_FSUBP b dst src | FMULP ( src , dst ) -> emit_FMULP b dst src | FDIVP ( src , dst ) -> emit_FDIVP b dst src | FSUBRP ( src , dst ) -> emit_FSUBRP b dst src | FDIVRP ( src , dst ) -> emit_FDIVRP b dst src | HLT -> buf_int8 b 0xF4 | INC dst -> emit_inc b dst | IMUL ( src , dst ) -> emit_imul b dst src | IDIV dst -> emit_idiv b dst | J ( condition , dst ) -> emit_j b ! loc condition dst | JMP dst -> emit_jmp b ! loc dst | LEAVE -> emit_leave b | LEA ( src , dst ) -> emit_LEA b dst src | MOV ( src , dst ) -> emit_MOV b dst src | MOVAPD ( src , dst ) -> emit_movapd b dst src | MOVLPD ( src , dst ) -> emit_movlpd b dst src | MOVSD ( src , dst ) -> emit_movsd b dst src | MOVSS ( src , dst ) -> emit_movss b dst src | MULSD ( src , dst ) -> emit_mulsd b dst src | MOVSX ( src , dst ) -> emit_movsx b dst src | MOVZX ( src , dst ) -> emit_MOVZX b dst src | MOVSXD ( src , dst ) -> emit_movsxd b dst src | NEG dst -> emit_neg b dst | NOP -> buf_int8 b 0x90 | OR ( src , dst ) -> emit_OR b dst src | PUSH dst -> emit_push b dst | POP dst -> emit_pop b dst | RET -> emit_ret b | ROUNDSD ( rounding , src , dst ) -> emit_roundsd b dst rounding src | SAL ( src , dst ) -> emit_SAL b dst src | SAR ( src , dst ) -> emit_SAR b dst src | SHR ( src , dst ) -> emit_SHR b dst src | SUBSD ( src , dst ) -> emit_subsd b dst src | SQRTSD ( src , dst ) -> emit_sqrtsd b dst src | SUB ( src , dst ) -> emit_SUB b dst src | SET ( condition , dst ) -> emit_set b condition dst | TEST ( src , dst ) -> emit_test b dst src | UCOMISD ( src , dst ) -> emit_ucomisd b dst src | XCHG ( src , dst ) -> emit_XCHG b dst src | XOR ( src , dst ) -> emit_XOR b dst src | XORPD ( src , dst ) -> emit_xorpd b dst src |
let assemble_line b loc ins = try match ins with | Ins instr -> assemble_instr b loc instr ; incr loc | Comment _ -> ( ) | Global s -> ( get_symbol b s ) . sy_global <- true | Quad ( Const n ) -> buf_int64L b n | Quad cst -> record_local_reloc b ( RelocConstant ( cst , B64 ) ) ; buf_int64L b 0L | Long ( Const n ) -> buf_int32L b n | Long cst -> record_local_reloc b ( RelocConstant ( cst , B32 ) ) ; buf_int32L b 0L | Word ( Const n ) -> buf_int16L b n | Word cst -> record_local_reloc b ( RelocConstant ( cst , B16 ) ) ; buf_int16L b 0L | Byte ( Const n ) -> buf_int8L b n | Byte cst -> record_local_reloc b ( RelocConstant ( cst , B8 ) ) ; buf_int8L b 0L | NewLabel ( s , _ ) -> declare_label b s | Bytes s -> Buffer . add_string b . buf s | External ( _ , _ ) -> ( ) | Set ( _ , _ ) -> assert false | Section _ -> assert false | Mode386 -> assert ( system = S_win32 ) | Model _ -> assert ( system = S_win32 ) | Cfi_startproc -> ( ) | Cfi_endproc -> ( ) | Cfi_adjust_cfa_offset _ -> ( ) | File _ -> ( ) | Loc _ -> ( ) | Private_extern _ -> assert false | Indirect_symbol _ -> assert false | Type ( lbl , kind ) -> ( get_symbol b lbl ) . sy_type <- Some kind | Size ( lbl , cst ) -> ( match eval_const b ( Buffer . length b . buf ) cst with | Rint n -> ( get_symbol b lbl ) . sy_size <- Some ( Int64 . to_int n ) | _ -> assert false ) | Align ( data , n ) -> ( let pos = Buffer . length b . buf in let current = pos mod n in if current > 0 then let n = n - current in if data then for _ = 1 to n do buf_int8 b 0x00 done else match n with | 0 -> ( ) | 1 -> buf_int8 b 0x90 | 2 -> buf_opcodes b [ 0x66 ; 0x90 ] | 3 -> buf_opcodes b [ 0x0f ; 0x1f ; 0x00 ] | 4 -> buf_opcodes b [ 0x0f ; 0x1f ; 0x40 ; 0x00 ] | 5 -> buf_opcodes b [ 0x0f ; 0x1f ; 0x44 ; 0x00 ; 0x00 ] | 6 -> buf_opcodes b [ 0x66 ; 0x0f ; 0x1f ; 0x44 ] ; buf_int16L b 0L | 7 -> buf_opcodes b [ 0x0f ; 0x1f ; 0x80 ] ; buf_int32L b 0L | _ -> for _ = 9 to n do buf_int8 b 0x66 done ; buf_opcodes b [ 0x0f ; 0x1f ; 0x84 ; 0x00 ] ; buf_int32L b 0L ) | Space n -> for _ = 1 to n do buf_int8 b 0 done with e -> Printf . eprintf " Exception % s :\ n " %! ( Printexc . to_string e ) ; raise e |
let add_patch b pos size v = b . patches <- ( pos , size , v ) :: b . patches |
let assemble_section arch section = ( match arch with X86 -> instr_size := 5 | X64 -> instr_size := 6 ) ; forced_long_jumps := IntSet . empty ; local_labels := String . Map . empty ; let icount = ref 0 in Array . iter section . sec_instrs ~ f ( : function | NewLabel ( lbl , _ ) -> local_labels := String . Map . add ~ key : lbl ~ data :! icount ! local_labels | Ins _ -> incr icount | _ -> ( ) ) ; let passes = ref 0 in let rec iter_assemble ( ) = incr passes ; let b = new_buffer section in local_relocs := [ ] ; let loc = ref 0 in Array . iter ~ f ( : assemble_line b loc ) section . sec_instrs ; let retry = ref false in let do_local_reloc pos = function | RelocShortJump ( label , loc ) -> let source_pos = pos + 1 in let target_pos = label_pos b label in let n = target_pos - source_pos in if n >= - 128 && n < 128 then add_patch b pos B8 ( Int64 . of_int n ) else ( forced_long_jumps := IntSet . add loc ! forced_long_jumps ; retry := true ) | RelocCall label | RelocLongJump label -> let source_pos = pos + 4 in let target_pos = label_pos b label in let n = target_pos - source_pos in add_patch b pos B32 ( Int64 . of_int n ) | RelocConstant ( cst , data_size ) -> ( let v = eval_const b pos cst in match ( v , data_size ) with | Rint n , _ -> add_patch b pos data_size n | Rabs ( lbl , offset ) , B32 -> record_reloc b pos ( Relocation . Kind . DIR32 ( lbl , offset ) ) | Rabs ( lbl , offset ) , B64 -> record_reloc b pos ( Relocation . Kind . DIR64 ( lbl , offset ) ) | Rrel ( lbl , offset ) , B32 -> record_reloc b pos ( Relocation . Kind . REL32 ( lbl , Int64 . add offset 4L ) ) | Rrel _ , _ -> assert false | Rabs _ , _ -> assert false ) in List . iter ! local_relocs ~ f ( : fun ( pos , local_reloc ) -> do_local_reloc pos local_reloc ) ; if ! retry then iter_assemble ( ) else b in iter_assemble ( ) |
let size b = Buffer . length b . buf |
let add_patch ~ offset ~ size ~ data t = add_patch t offset size data |
let contents b = let buf = Buffer . to_bytes b . buf in List . iter b . patches ~ f ( : fun ( pos , nbits , v ) -> match nbits with | B64 -> str_int64L buf pos v | B32 -> str_int32L buf pos v | B16 -> str_int16L buf pos v | B8 -> str_int8L buf pos v ) ; Bytes . to_string buf |
let relocations b = b . relocations |
let labels b = b . labels |
let print_reg b f r = Buffer . add_char b ' ' ; % Buffer . add_string b ( f r ) |
let opt_displ b displ = if displ = 0 then ( ) else if displ > 0 then bprintf b " +% d " displ else bprintf b " % d " displ |
let arg_mem b { arch ; typ = _ ; idx ; scale ; base ; sym ; displ } = let string_of_register = match arch with | X86 -> string_of_reg32 | X64 -> string_of_reg64 in begin match sym with | None -> if displ <> 0 || scale = 0 then Buffer . add_string b ( Int . to_string displ ) | Some s -> Buffer . add_string b s ; opt_displ b displ end ; if scale <> 0 then begin Buffer . add_char b ' ( ' ; begin match base with | None -> ( ) | Some base -> print_reg b string_of_register base end ; if base != None || scale <> 1 then Buffer . add_char b ' , ' ; print_reg b string_of_register idx ; if scale <> 1 then bprintf b " , % s " ( Int . to_string scale ) ; Buffer . add_char b ' ) ' end |
let arg b = function | Sym x -> Buffer . add_char b ' ' ; $ Buffer . add_string b x | Imm x -> bprintf b " $% Ld " x | Reg8L x -> print_reg b string_of_reg8l x | Reg8H x -> print_reg b string_of_reg8h x | Reg16 x -> print_reg b string_of_reg16 x | Reg32 x -> print_reg b string_of_reg32 x | Reg64 x -> print_reg b string_of_reg64 x | Regf x -> print_reg b string_of_registerf x | Mem addr -> arg_mem b addr | Mem64_RIP ( _ , s , displ ) -> bprintf b " % s % a ( %% rip ) " s opt_displ displ |
let rec cst b = function | ConstLabel _ | Const _ | ConstThis as c -> scst b c | ConstAdd ( c1 , c2 ) -> bprintf b " % a + % a " scst c1 scst c2 | ConstSub ( c1 , c2 ) -> bprintf b " % a - % a " scst c1 scst c2 | ConstThis -> Buffer . add_string b " . " | ConstLabel l -> Buffer . add_string b l | Const n when n <= 0x7FFF_FFFFL && n >= - 0x8000_0000L -> Buffer . add_string b ( Int64 . to_string n ) | Const n -> bprintf b " 0x % Lx " n | ConstAdd ( c1 , c2 ) -> bprintf b " ( % a + % a ) " scst c1 scst c2 | ConstSub ( c1 , c2 ) -> bprintf b " ( % a - % a ) " scst c1 scst c2 |
let typeof = function | Mem { typ ; _ } | Mem64_RIP ( typ , _ , _ ) -> typ | Reg8L _ | Reg8H _ -> BYTE | Reg16 _ -> WORD | Reg32 _ -> DWORD | Reg64 _ -> QWORD | Imm _ | Sym _ -> NONE | Regf _ -> assert false |
let suf arg = match typeof arg with | BYTE -> " b " | WORD -> " w " | DWORD | REAL8 -> " l " | QWORD -> " q " | REAL4 -> " s " | NONE -> " " | OWORD | NEAR | PROC -> assert false |
let i0 b s = bprintf b " \ t % s " s |
let i1 b s x = bprintf b " \ t % s \ t % a " s arg x |
let i1_s b s x = bprintf b " \ t % s % s \ t % a " s ( suf x ) arg x |
let i2 b s x y = bprintf b " \ t % s \ t % a , % a " s arg x arg y |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.