text
stringlengths 0
601k
|
|---|
let local_relocs = ref [ ] |
let local_labels = ref String . Map . empty |
let forced_long_jumps = ref IntSet . empty |
let instr_size = ref 4 |
let new_buffer sec = { sec ; buf = Buffer . create 10000 ; labels = String . Map . empty ; relocations = [ ] ; patches = [ ] ; } |
let label_pos b lbl = match ( String . Map . find lbl b . labels ) . sy_pos with | None -> raise Not_found | Some pos -> pos |
let eval_const b current_pos cst = let rec eval = function | Const n -> Rint n | ConstThis -> Rabs ( " " , 0L ) | ConstLabel lbl -> Rabs ( lbl , 0L ) | ConstSub ( c1 , c2 ) -> ( let c1 = eval c1 and c2 = eval c2 in match ( c1 , c2 ) with | Rint n1 , Rint n2 -> Rint ( Int64 . sub n1 n2 ) | Rabs ( s , n1 ) , Rint n2 -> Rabs ( s , Int64 . sub n1 n2 ) | Rrel ( s , n1 ) , Rint n2 -> Rrel ( s , Int64 . sub n1 n2 ) | Rabs ( " " , n1 ) , Rabs ( " " , n2 ) -> Rint ( Int64 . sub n1 n2 ) | Rabs ( " " , n1 ) , Rabs ( s2 , n2 ) -> ( try let sy2 = String . Map . find s2 b . labels in match sy2 . sy_pos with | Some pos2 -> let pos2 = Int64 . of_int pos2 in Rint ( Int64 . sub ( Int64 . add n1 ( Int64 . of_int current_pos ) ) ( Int64 . add pos2 n2 ) ) | _ -> assert false with Not_found -> assert false ) | Rabs ( s , n1 ) , Rabs ( " " , n2 ) -> ( try let sy = String . Map . find s b . labels in match sy . sy_pos with | Some pos -> let pos = Int64 . of_int pos in Rint ( Int64 . sub ( Int64 . add pos n1 ) ( Int64 . add n2 ( Int64 . of_int current_pos ) ) ) | _ -> assert false with Not_found -> Rrel ( s , Int64 . sub n1 n2 ) ) | Rabs ( s1 , n1 ) , Rabs ( s2 , n2 ) -> ( try let sy2 = String . Map . find s2 b . labels in try let sy1 = String . Map . find s1 b . labels in assert ( sy1 . sy_sec == sy2 . sy_sec ) ; match ( sy1 . sy_pos , sy2 . sy_pos ) with | Some pos1 , Some pos2 -> let pos1 = Int64 . of_int pos1 in let pos2 = Int64 . of_int pos2 in Rint ( Int64 . sub ( Int64 . add pos1 n1 ) ( Int64 . add pos2 n2 ) ) | _ -> assert false with Not_found -> ( match sy2 . sy_pos with | Some pos2 -> let pos2 = Int64 . of_int pos2 in Rrel ( s1 , Int64 . sub ( Int64 . add n1 ( Int64 . of_int current_pos ) ) ( Int64 . add pos2 n2 ) ) | _ -> assert false ) with Not_found -> assert false ) | _ -> assert false ) | ConstAdd ( c1 , c2 ) -> ( let c1 = eval c1 and c2 = eval c2 in match ( c1 , c2 ) with | Rint n1 , Rint n2 -> Rint ( Int64 . add n1 n2 ) | Rabs ( s , n1 ) , Rint n2 | Rint n2 , Rabs ( s , n1 ) -> Rabs ( s , Int64 . add n1 n2 ) | Rrel ( s , n1 ) , Rint n2 | Rint n2 , Rrel ( s , n1 ) -> Rrel ( s , Int64 . add n1 n2 ) | Rrel ( s , n1 ) , Rabs ( " " , n2 ) -> Rabs ( s , Int64 . add n1 n2 ) | _ -> assert false ) in try let r = eval cst in r with e -> Printf . eprintf " Error in eval_const : exception % S \ n " %! ( Printexc . to_string e ) ; raise e |
let is_imm32L n = n < 0x8000_0000L && n >= - 0x8000_0000L |
let is_imm8L x = x < 128L && x >= - 128L |
let rd_of_regf regf = match regf with | XMM n -> n | TOS -> assert false | ST _st -> assert false |
let rd_of_reg64 = function | RAX -> 0 | RCX -> 1 | RDX -> 2 | RBX -> 3 | RSP -> 4 | RBP -> 5 | RSI -> 6 | RDI -> 7 | R8 -> 8 | R9 -> 9 | R10 -> 10 | R11 -> 11 | R12 -> 12 | R13 -> 13 | R14 -> 14 | R15 -> 15 |
let rd_of_reg8 = function | Reg8L r -> rd_of_reg64 r | Reg8H AH -> 4 | Reg8H CH -> 5 | Reg8H DH -> 6 | Reg8H BH -> 7 | _ -> assert false |
let cd_of_condition condition = match condition with | O -> 0 | NO -> 1 | B -> 2 | AE -> 3 | E -> 4 | NE -> 5 | BE -> 6 | A -> 7 | S -> 8 | NS -> 9 | P -> 10 | NP -> 11 | L -> 12 | GE -> 13 | LE -> 14 | G -> 15 |
let rexr_reg reg = if reg > 7 then rexr else 0 |
let rexw = rex lor 0b00001000 |
let rexx_index reg = if reg > 7 then rexx else 0 |
let rexb_opcode reg = if reg > 7 then rexb else 0 |
let rexb_rm reg = if reg > 7 then rexb else 0 |
let rexb_base reg = if reg > 7 then rexb else 0 |
let reg7 reg = reg land 0x07 |
let rex_of_reg8 = function Reg8L ( RSP | RBP | RSI | RDI ) -> rex | _ -> 0 |
let rex_of_reg16 = function | RAX | RCX | RDX | RBX | RSP | RBP | RSI | RDI -> 0 | R8 | R9 | R10 | R11 | R12 | R13 | R14 | R15 -> rex |
let mod_rm_reg m rm reg = ( m lsl 6 ) + reg7 rm + ( reg7 reg lsl 3 ) |
let sib scale index base = let scale = match scale with 1 -> 0 | 2 -> 1 | 4 -> 2 | 8 -> 3 | _ -> assert false in ( scale lsl 6 ) lor ( reg7 index lsl 3 ) lor reg7 base |
let record_reloc b offset_from_section_beginning kind = b . relocations <- { Relocation . offset_from_section_beginning ; kind } :: b . relocations |
let declare_label b s = let sy = get_symbol b s in assert ( sy . sy_pos = None ) ; let pos = Buffer . length b . buf in sy . sy_pos <- Some pos |
let buf_opcodes b opcodes = List . iter ~ f ( : fun opcode -> buf_int8 b opcode ) opcodes |
let arch64 = Config . architecture = " amd64 " |
let emit_rex b rexcode = if arch64 && rexcode <> 0 then buf_int8 b ( rexcode lor rex ) |
let buf_int32_imm b = function | Imm n -> assert ( is_imm32L n ) ; buf_int32L b n | Sym symbol -> record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . DIR32 ( symbol , 0L ) ) ; buf_int32L b 0L | _ -> assert false |
type offset_exp = OImm8 of int64 | OImm32 of string option * int64 |
let sym32 b sym = record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . DIR32 ( sym , 0L ) ) ; buf_int32L b 0L |
let sym64 b sym = record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . DIR64 ( sym , 0L ) ) ; buf_int64L b 0L |
let buf_sym b sym offset = match sym with | None -> buf_int32L b offset | Some lbl -> record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . DIR32 ( lbl , offset ) ) ; buf_int32L b 0L |
let emit_mod_rm_reg b rex opcodes rm reg = match rm with | Reg32 rm -> let rm = rd_of_reg64 rm in emit_rex b ( rex lor rexr_reg reg lor rexb_rm rm ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b11 rm reg ) | Reg64 rm -> let rm = rd_of_reg64 rm in emit_rex b ( rex lor rexr_reg reg lor rexb_rm rm ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b11 rm reg ) | ( Reg8L _ | Reg8H _ ) as reg8 -> let rm = rd_of_reg8 reg8 in emit_rex b ( rex lor rex_of_reg8 reg8 lor rexr_reg reg lor rexb_rm rm ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b11 rm reg ) | Reg16 reg16 -> let rm = rd_of_reg64 reg16 in emit_rex b ( rex lor rex_of_reg16 reg16 lor rexr_reg reg lor rexb_rm rm ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b11 rm reg ) | Regf rm -> let rm = rd_of_regf rm in emit_rex b ( rex lor rexr_reg reg lor rexb_rm rm ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b11 rm reg ) | Mem64_RIP ( _ , symbol , offset ) -> emit_rex b ( rex lor rexr_reg reg ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b00 0b101 reg ) ; record_reloc b ( Buffer . length b . buf ) ( Relocation . Kind . REL32 ( symbol , Int64 . of_int offset ) ) ; buf_int32L b 0L | Mem { arch ; typ = _ ; idx ; scale ; base ; sym ; displ } -> ( let offset = let displ = Int64 . of_int displ in match sym with | None -> if is_imm8L displ then OImm8 displ else if is_imm32L displ then OImm32 ( None , displ ) else assert false | Some s -> OImm32 ( Some s , displ ) in let idx_reg = idx in let idx = rd_of_reg64 idx in if scale = 0 then ( assert ( base = None && arch = X86 ) ; match offset with | OImm8 _ -> assert false | OImm32 ( sym , offset ) -> buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b00 0b101 reg ) ; buf_sym b sym offset ) else match base with | None -> ( match ( idx_reg , scale , offset ) with | ( RSP | R12 ) , 1 , OImm8 0L -> emit_rex b ( rex lor rexr_reg reg lor rexb_base idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b00 idx reg ) ; buf_int8 b ( sib 1 0b100 idx ) | ( RSP | R12 ) , 1 , OImm8 offset8 -> emit_rex b ( rex lor rexr_reg reg lor rexb_base idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b01 0b100 reg ) ; buf_int8 b ( sib 1 0b100 idx ) ; buf_int8L b offset8 | ( RSP | R12 ) , 1 , OImm32 ( sym , offset ) -> emit_rex b ( rex lor rexr_reg reg lor rexb_base idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b10 0b100 reg ) ; buf_int8 b ( sib 1 0b100 idx ) ; buf_sym b sym offset | ( RBP | R13 ) , 1 , OImm8 _ -> ( emit_rex b ( rex lor rexr_reg reg lor rexb_base idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b01 idx reg ) ; match offset with | OImm8 offset8 -> buf_int8L b offset8 | _ -> assert false ) | _ , 1 , OImm8 0L -> emit_rex b ( rex lor rexr_reg reg lor rexb_rm idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b00 idx reg ) | _ , 1 , OImm8 offset8 -> emit_rex b ( rex lor rexr_reg reg lor rexb_rm idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b01 idx reg ) ; buf_int8L b offset8 | _ , 1 , OImm32 ( sym , offset ) -> emit_rex b ( rex lor rexr_reg reg lor rexb_rm idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b10 idx reg ) ; buf_sym b sym offset | _ , _ , _ -> ( emit_rex b ( rex lor rexr_reg reg lor rexx_index idx ) ; buf_opcodes b opcodes ; buf_int8 b ( mod_rm_reg 0b00 0b100 reg ) ; buf_int8 b ( sib scale idx 0b101 ) ; match offset with | OImm8 offset8 -> buf_int32L b offset8 | OImm32 ( sym , offset ) -> buf_sym b sym offset ) ) | Some base_reg -> ( assert ( scale = 1 || scale = 2 || scale = 4 || scale = 8 ) ; let base = rd_of_reg64 base_reg in emit_rex b ( rex lor rexr_reg reg lor rexx_index idx lor rexb_base base ) ; buf_opcodes b opcodes ; match ( base_reg , offset ) with | ( RBP | R13 ) , OImm8 0L -> buf_int8 b ( mod_rm_reg 0b01 0b100 reg ) ; buf_int8 b ( sib scale idx base ) ; buf_int8 b 0 | _ , OImm8 0L -> buf_int8 b ( mod_rm_reg 0b00 0b100 reg ) ; buf_int8 b ( sib scale idx base ) | _ , OImm8 offset -> buf_int8 b ( mod_rm_reg 0b01 0b100 reg ) ; buf_int8 b ( sib scale idx base ) ; buf_int8L b offset | _ , OImm32 ( sym , offset ) -> buf_int8 b ( mod_rm_reg 0b10 0b100 reg ) ; buf_int8 b ( sib scale idx base ) ; buf_sym b sym offset ) ) | Imm _ | Sym _ -> assert false |
let emit_movlpd b dst src = match ( dst , src ) with | Regf reg , ( ( Mem _ | Mem64_RIP _ ) as rm ) -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x12 ] rm ( rd_of_regf reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Regf reg -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x13 ] rm ( rd_of_regf reg ) | _ -> assert false |
let emit_movapd 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 ; 0x28 ] rm ( rd_of_regf reg ) | ( ( Mem _ | Mem64_RIP _ ) as rm ) , Regf reg -> buf_int8 b 0x66 ; emit_mod_rm_reg b 0 [ 0x0f ; 0x29 ] rm ( rd_of_regf reg ) | _ -> assert false |
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 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.