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_mo... |
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_mo... |
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 | ... |
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_in... |
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 ... |
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... |
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 _... |
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_... |
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 ] ... |
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... |
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 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 r... |
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 . le... |
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 | ( ... |
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 ... |
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 _ ) ... |
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 [ 0x... |
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 ; bu... |
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 { ... |
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 ) ... |
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 | CVTSI2... |
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 ) ) ; ... |
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 , _ )... |
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 ) | Som... |
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 |... |
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 ->... |
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.