text stringlengths 0 601k |
|---|
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 )... |
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 ds... |
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 ) -> bu... |
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 ~ k... |
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_dis... |
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... |
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 <= 0x7F... |
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 |
let i2_s b s x y = bprintf b " \ t % s % s \ t % a , % a " s ( suf y ) arg x arg y |
let i2_ss b s x y = bprintf b " \ t % s % s % s \ t % a , % a " s ( suf x ) ( suf y ) arg x arg y |
let i1_call_jmp b s = function | Mem { arch = X86 ; idx = _ ; scale = 0 ; base = None ; sym = Some _ ; _ } as x -> i1 b s x | Reg32 _ | Reg64 _ | Mem _ | Mem64_RIP _ as x -> bprintf b " \ t % s \ t *% a " s arg x | Sym x -> bprintf b " \ t % s \ t % s " s x | _ -> assert false |
let print_instr b = function | ADD ( arg1 , arg2 ) -> i2_s b " add " arg1 arg2 | ADDSD ( arg1 , arg2 ) -> i2 b " addsd " arg1 arg2 | AND ( arg1 , arg2 ) -> i2_s b " and " arg1 arg2 | ANDPD ( arg1 , arg2 ) -> i2 b " andpd " arg1 arg2 | BSWAP arg -> i1 b " bswap " arg | CALL arg -> i1_call_jmp b " call " arg | CDQ -> i0 ... |
let print_line b = function | Ins instr -> print_instr b instr | Align ( _data , n ) -> let n = if system = S_macosx then Misc . log2 n else n in bprintf b " \ t . align \ t % d " n | Byte n -> bprintf b " \ t . byte \ t % a " cst n | Bytes s -> if system = S_solaris then buf_bytes_directive b " . byte " s else bprintf... |
let generate_asm oc lines = let b = Buffer . create 10000 in output_string oc " \ t . file " " \\\ n " ; List . iter ( fun i -> Buffer . clear b ; print_line b i ; Buffer . add_char b ' \ n ' ; Buffer . output_buffer oc b ; ) lines |
let string_of_datatype = function | QWORD -> " QWORD " | OWORD -> " OWORD " | NONE -> assert false | REAL4 -> " REAL4 " | REAL8 -> " REAL8 " | BYTE -> " BYTE " | WORD -> " WORD " | DWORD -> " DWORD " | NEAR -> " NEAR " | PROC -> " PROC " |
let string_of_datatype_ptr = function | QWORD -> " QWORD PTR " | OWORD -> " OWORD PTR " | NONE -> " " | REAL4 -> " REAL4 PTR " | REAL8 -> " REAL8 PTR " | BYTE -> " BYTE PTR " | WORD -> " WORD PTR " | DWORD -> " DWORD PTR " | NEAR -> " NEAR PTR " | PROC -> " PROC PTR " |
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 Buffer . add_string b ( string_of_datatype_ptr typ ) ; Buffer . add_char b ' [ ' ; begin match sym with | None -> ( ) | Some s -> Buffer . add_string b s end ; ... |
let arg b = function | Sym s -> bprintf b " OFFSET % s " s | Imm n when n <= 0x7FFF_FFFFL && n >= - 0x8000_0000L -> bprintf b " % Ld " n | Imm int -> bprintf b " 0 % LxH " int | Reg8L x -> Buffer . add_string b ( string_of_reg8l x ) | Reg8H x -> Buffer . add_string b ( string_of_reg8h x ) | Reg16 x -> Buffer . add_stri... |
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 " THIS BYTE " | ConstLabel l -> Buffer . add_string b l | Const n when n... |
let i0 b s = bprintf b " \ t % s " s |
let i1 b s x = bprintf b " \ t % s \ t % a " s arg x |
let i2 b s x y = bprintf b " \ t % s \ t % a , % a " s arg y arg x |
let i1_call_jmp b s = function | Sym x -> bprintf b " \ t % s \ t % s " s x | x -> i1 b s x |
let print_instr b = function | ADD ( arg1 , arg2 ) -> i2 b " add " arg1 arg2 | ADDSD ( arg1 , arg2 ) -> i2 b " addsd " arg1 arg2 | AND ( arg1 , arg2 ) -> i2 b " and " arg1 arg2 | ANDPD ( arg1 , arg2 ) -> i2 b " andpd " arg1 arg2 | BSWAP arg -> i1 b " bswap " arg | CALL arg -> i1_call_jmp b " call " arg | CDQ -> i0 b " ... |
let print_line b = function | Ins instr -> print_instr b instr | Align ( _data , n ) -> bprintf b " \ tALIGN \ t % d " n | Byte n -> bprintf b " \ tBYTE \ t % a " cst n | Bytes s -> buf_bytes_directive b " BYTE " s | Comment s -> bprintf b " ; % s " s | Global s -> bprintf b " \ tPUBLIC \ t % s " s | Long n -> bprintf ... |
let generate_asm oc lines = let b = Buffer . create 10000 in List . iter ( fun i -> Buffer . clear b ; print_line b i ; Buffer . add_char b ' \ n ' ; Buffer . output_buffer oc b ) lines ; output_string oc " \ tEND \ n " |
type system = | S_macosx | S_gnu | S_cygwin | S_solaris | S_win32 | S_linux_elf | S_bsd_elf | S_beos | S_mingw | S_win64 | S_linux | S_mingw64 | S_unknown |
let system = match Config . system with | " macosx " -> S_macosx | " solaris " -> S_solaris | " win32 " -> S_win32 | " linux_elf " -> S_linux_elf | " bsd_elf " -> S_bsd_elf | " beos " -> S_beos | " gnu " -> S_gnu | " cygwin " -> S_cygwin | " mingw " -> S_mingw | " mingw64 " -> S_mingw64 | " win64 " -> S_win64 | " linux... |
let windows = match system with | S_mingw64 | S_cygwin | S_win64 -> true | _ -> false |
let string_of_string_literal s = let b = Buffer . create ( String . length s + 2 ) in let last_was_escape = ref false in for i = 0 to String . length s - 1 do let c = s . [ i ] in if c >= ' 0 ' && c <= ' 9 ' then if ! last_was_escape then Printf . bprintf b " \\% o " ( Char . code c ) else Buffer . add_char b c else if... |
let string_of_symbol prefix s = let spec = ref false in for i = 0 to String . length s - 1 do match String . unsafe_get s i with | ' A ' . . ' Z ' | ' a ' . . ' z ' | ' 0 ' . . ' 9 ' | ' _ ' -> ( ) | _ -> spec := true ; done ; if not ! spec then if prefix = " " then s else prefix ^ s else let b = Buffer . create ( Stri... |
let buf_bytes_directive b directive s = let pos = ref 0 in for i = 0 to String . length s - 1 do if ! pos = 0 then begin if i > 0 then Buffer . add_char b ' \ n ' ; Buffer . add_char b ' \ t ' ; Buffer . add_string b directive ; Buffer . add_char b ' \ t ' ; end else Buffer . add_char b ' , ' ; Printf . bprintf b " % d... |
let string_of_reg64 = function | RAX -> " rax " | RBX -> " rbx " | RDI -> " rdi " | RSI -> " rsi " | RDX -> " rdx " | RCX -> " rcx " | RBP -> " rbp " | RSP -> " rsp " | R8 -> " r8 " | R9 -> " r9 " | R10 -> " r10 " | R11 -> " r11 " | R12 -> " r12 " | R13 -> " r13 " | R14 -> " r14 " | R15 -> " r15 " |
let string_of_reg8l = function | RAX -> " al " | RBX -> " bl " | RCX -> " cl " | RDX -> " dl " | RSP -> " spl " | RBP -> " bpl " | RSI -> " sil " | RDI -> " dil " | R8 -> " r8b " | R9 -> " r9b " | R10 -> " r10b " | R11 -> " r11b " | R12 -> " r12b " | R13 -> " r13b " | R14 -> " r14b " | R15 -> " r15b " |
let string_of_reg8h = function | AH -> " ah " | BH -> " bh " | CH -> " ch " | DH -> " dh " |
let string_of_reg16 = function | RAX -> " ax " | RBX -> " bx " | RCX -> " cx " | RDX -> " dx " | RSP -> " sp " | RBP -> " bp " | RSI -> " si " | RDI -> " di " | R8 -> " r8w " | R9 -> " r9w " | R10 -> " r10w " | R11 -> " r11w " | R12 -> " r12w " | R13 -> " r13w " | R14 -> " r14w " | R15 -> " r15w " |
let string_of_reg32 = function | RAX -> " eax " | RBX -> " ebx " | RCX -> " ecx " | RDX -> " edx " | RSP -> " esp " | RBP -> " ebp " | RSI -> " esi " | RDI -> " edi " | R8 -> " r8d " | R9 -> " r9d " | R10 -> " r10d " | R11 -> " r11d " | R12 -> " r12d " | R13 -> " r13d " | R14 -> " r14d " | R15 -> " r15d " |
let string_of_registerf = function | XMM n -> Printf . sprintf " xmm % d " n | TOS -> Printf . sprintf " tos " | ST n -> Printf . sprintf " st ( % d ) " n |
let string_of_condition = function | E -> " e " | AE -> " ae " | A -> " a " | GE -> " ge " | G -> " g " | NE -> " ne " | B -> " b " | BE -> " be " | L -> " l " | LE -> " le " | NP -> " np " | P -> " p " | NS -> " ns " | S -> " s " | NO -> " no " | O -> " o " |
let string_of_rounding = function | RoundDown -> " roundsd . down " | RoundUp -> " roundsd . up " | RoundTruncate -> " roundsd . trunc " | RoundNearest -> " roundsd . near " |
let internal_assembler = ref None |
let register_internal_assembler f = internal_assembler := Some f |
let masm = match system with | S_win32 | S_win64 -> true | _ -> false |
let use_plt = match system with | S_macosx | S_mingw64 | S_cygwin | S_win64 -> false | _ -> ! Clflags . dlcode |
let binary_content = ref None |
let compile infile outfile = if masm then Ccomp . command ( Config . asm ^ Filename . quote outfile ^ " " ^ Filename . quote infile ^ ( if ! Clflags . verbose then " " else " > NUL " ) ) else Ccomp . command ( Config . asm ^ " " ^ ( String . concat " " ( Misc . debug_prefix_map_flags ( ) ) ) ^ " - o " ^ Filename . quot... |
let assemble_file infile outfile = match ! binary_content with | None -> compile infile outfile | Some content -> content outfile ; binary_content := None ; 0 |
let asm_code = ref [ ] |
let directive dir = asm_code := dir :: ! asm_code |
let emit ins = directive ( Ins ins ) |
let reset_asm_code ( ) = asm_code := [ ] |
let generate_code asm = let instrs = List . rev ! asm_code in begin match asm with | Some f -> f instrs | None -> ( ) end ; begin match ! internal_assembler with | Some f -> binary_content := Some ( f instrs ) | None -> binary_content := None end |
let name s_l s_opt s_l ' = let first = String . concat ~ sep " , " : s_l in let mid = match s_opt with None -> " " | Some s -> Printf . sprintf " , % S " s in let last = match s_l ' with [ ] -> " " | l -> " , " ^ String . concat ~ sep " , " : l in first ^ mid ^ last |
type t = { name : string ; instructions : X86_ast . asm_line list } |
let assemble ~ arch { name ; instructions } = let section = { X86_emitter . sec_name = name ; sec_instrs = Array . of_list instructions } in X86_emitter . assemble_section arch section |
module Map = struct type nonrec t = X86_ast . asm_line list String . Map . t let append key l t = String . Map . update ~ key t ~ f ( : function | None -> Some l | Some l ' -> Some ( l ' @ l ) ) let from_program l = let open X86_ast in let rec aux acc current_section current_instrs l = let add_current ( ) = append curr... |
type ' a xarray = { mutable len : int ; mutable buf : ' a array ; default : ' a } ' a |
type ' a t = ' a xarray |
let expand x len = if Array . length x . buf >= len then ( ) else let buf ' = Array . make ( 2 * len ) len x . default in Array . blit x . buf 0 buf ' 0 x . len ; x . buf <- buf ' |
let get x i = if 0 <= i && i < x . len then x . buf ( . i ) i else invalid_arg " XArray . get " |
let set x i e = if i < x . len then x . buf ( . i ) i <- e else begin expand x ( i + 1 ) 1 ; if x . len < i then Array . fill x . buf x . len ( i - x . len ) len x . default ; x . buf ( . i ) i <- e ; x . len <- i + 1 end |
let length x = x . len |
let init ? bufsize len def f = let buf = Array . make ( match bufsize with None -> len | Some n -> n ) n def in for i = 0 to len - 1 do buf ( . i ) i <- f i done ; { len = len ; buf = buf ; default = def } def |
let nth _ i = i |
let first _ = 0 |
let last x = length x - 1 |
let out_of_range x i = i < 0 || x . len <= i |
let next _ i = i + 1 |
let prev _ i = i - 1 |
let move _ i n = i + n |
let compare_index _ i j = i - j |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.