text stringlengths 12 786k |
|---|
let visibility : Ollvm . Ast . visibility -> Llvm . Visibility . t = let open Llvm . Visibility in function | VISIBILITY_Default -> Default | VISIBILITY_Hidden -> Hidden | VISIBILITY_Protected -> Protected |
let cconv : Ollvm . Ast . cconv -> int = let open Llvm . CallConv in function | CC_Ccc -> c | CC_Fastcc -> fast | CC_Coldcc -> cold | CC_Cc i -> assert false |
let typ_attr : Ollvm . Ast . param_attr -> Llvm . Attribute . t = let open Llvm . Attribute in function | PARAMATTR_Zeroext -> Zext | PARAMATTR_Signext -> Sext | PARAMATTR_Inreg -> Inreg | PARAMATTR_Byval -> Byval | PARAMATTR_Sret -> Structret | PARAMATTR_Noalias -> Noalias | PARAMATTR_Nocaptu... |
let fn_attr : Ollvm . Ast . fn_attr -> Llvm . Attribute . t = let open Llvm . Attribute in function | FNATTR_Alignstack i -> Stackalignment i | FNATTR_Alwaysinline -> Alwaysinline | FNATTR_Builtin -> assert false | FNATTR_Cold -> assert false | FNATTR_Inlinehint -> Inlinehint | FNATTR_Jumptable ... |
let rec typ : env -> Ollvm . Ast . typ -> Llvm . lltype = fun env -> let ctx = env . c in let open Llvm in function | TYPE_I i -> begin match i with | 1 -> i1_type ctx | 8 -> i8_type ctx | 16 -> i16_type ctx | 32 -> i32_type ctx | 64 -> i64_type ctx | _ -> integer_type ctx i end | TYP... |
let icmp : Ollvm . Ast . icmp -> Llvm . Icmp . t = let open Llvm . Icmp in function | Eq -> Eq | Ne -> Ne | Ugt -> Ugt | Uge -> Uge | Ult -> Ult | Ule -> Ule | Sgt -> Sgt | Sge -> Sge | Slt -> Slt | Sle -> Sle |
let fcmp : Ollvm . Ast . fcmp -> Llvm . Fcmp . t = let open Llvm . Fcmp in function | False -> False | Oeq -> Oeq | Ogt -> Ogt | Oge -> Oge | Olt -> Olt | Ole -> Ole | One -> One | Ord -> Ord | Uno -> Uno | Ueq -> Ueq | Ugt -> Ugt | Uge -> Uge | Ult -> Ult | Ule -> Ule | Une -... |
let ibinop : Ollvm . Ast . ibinop -> ( Llvm . llvalue -> Llvm . llvalue -> string -> Llvm . llbuilder -> Llvm . llvalue ) = let open Llvm in function | Add ( _ , _ ) -> build_add | Sub ( _ , _ ) -> build_sub | Mul ( _ , _ ) -> build_mul | UDiv _ -> build_udiv | S... |
let fbinop : Ollvm . Ast . fbinop -> ( Llvm . llvalue -> Llvm . llvalue -> string -> Llvm . llbuilder -> Llvm . llvalue ) = let open Llvm in function | FAdd -> build_fadd | FSub -> build_fsub | FMul -> build_fmul | FDiv -> build_fdiv | FRem -> build_frem |
let conversion_type : Ollvm . Ast . conversion_type -> ( Llvm . llvalue -> Llvm . lltype -> Llvm . llvalue ) = let open Llvm in function | Trunc -> const_trunc | Zext -> const_zext | Sext -> const_sext | Fptrunc -> const_fptrunc | Fpext -> const_fpext | Uitofp -> const_uitofp | Sitofp -... |
let rec value : env -> Ollvm . Ast . typ -> Ollvm . Ast . value -> Llvm . llvalue = fun env ty -> let open Llvm in function | VALUE_Ident i -> lookup env i | VALUE_Integer i -> const_int ( typ env ty ) i | VALUE_Float f -> const_float ( typ env ty ) f | VALUE_Bool b -> const_int ( Llvm... |
let rec instr : env -> Ollvm . Ast . instr -> ( env * Llvm . llvalue ) = fun env -> let open Llvm in function | INSTR_IBinop ( op , ty , v1 , v2 ) -> let v1 = value env ty v1 in let v2 = value env ty v2 in let op = ibinop op in ( env , op v1 v2 " " env . b ) | INSTR_ICmp ( ... |
let global : env -> Ollvm . Ast . global -> env = fun env g -> let llv = value env g . g_typ ( match g . g_value with Some x -> x | None -> assert false ) in let Ollvm . Ast . ID_Global name = g . g_ident in let llv = Llvm . define_global name llv env . m in { env with mem = ( g . ... |
let declaration : env -> Ollvm . Ast . declaration -> env * Llvm . llvalue = fun env dc -> let name = ( string_of_ident dc . dc_name ) in let fn = match Llvm . lookup_function name env . m with | None -> Llvm . declare_function name ( typ env dc . dc_type ) env . m ; | Some fn ->... |
let create_block : env -> Ollvm . Ast . block -> Llvm . llvalue -> env = fun env b fn -> if List . mem_assoc ( fst b ) env . labels then assert false ; let llb = Llvm . append_block env . c ( fst b ) fn in { env with labels = ( fst b , llb ) :: env . labels } |
let block : env -> Ollvm . Ast . block -> env = fun env block -> let bb = List . assoc ( fst block ) env . labels in Llvm . position_at_end bb env . b ; let env = List . fold_left ( fun env i -> instr env i |> fst ) env ( snd block ) in env |
let definition : env -> Ollvm . Ast . definition -> env = fun env df -> let ( env , fn ) = declaration env df . df_prototype in if Array . length ( Llvm . basic_blocks fn ) <> 0 then assert false ; let env = lookup_fn env df . df_prototype . dc_name |> Llvm . params |> Array . m... |
let modul : Ollvm . Ast . modul -> env = fun modul -> let c = Llvm . global_context ( ) in let m = Llvm . create_module c modul . m_name in let b = Llvm . builder c in let Ollvm . Ast . TLE_Target target = modul . m_target in let Ollvm . Ast . TLE_Datalayout datalayout = modul . m_d... |
let rec pp_print_list ( ? pp_sep = Format . pp_print_cut ) pp_v ppf = function pp_v ppf v ; if vs <> [ ] then ( pp_sep ppf ( ) ; pp_print_list ~ pp_sep pp_v ppf vs ) |
type t = { local : int ref * ( int , int ) Hashtbl . t ; global : int ref * ( int , int ) Hashtbl . t } |
let empty_env ( ) = { local = ref 0 , Hashtbl . create 0 ; global = ref 0 , Hashtbl . create 0 } |
let find_env ( cntr , tbl ) i = let i = int_of_string i in try Hashtbl . find tbl i with Not_found -> let i ' = ! cntr in Hashtbl . add tbl i i ' ; cntr := i ' + 1 ; i ' |
let find_local env = find_env env . local |
let find_global env = find_env env . global |
let reset_local env = { env with local = ref 0 , Hashtbl . create 0 } |
let pp_sep str = fun ppf ( ) -> pp_print_string ppf str |
let pp_space ppf ( ) = pp_print_char ppf ' ' |
let pp_comma_space ppf ( ) = pp_print_string ppf " , " |
let rec linkage : Format . formatter -> Ollvm_ast . linkage -> unit = fun ppf -> function | LINKAGE_Private -> fprintf ppf " private " | LINKAGE_Internal -> fprintf ppf " internal " | LINKAGE_Available_externally -> fprintf ppf " available_externally " | LINKAGE_Linkonce -> fprintf ppf " ... |
module type S = sig type t val compare : t -> t -> int val equal : t -> t -> bool val hash : t -> int val print : Format . formatter -> t -> unit val min_value : t val max_value : t val max_string_length : t val minus_one : t val zero : t val one : t val ten : t val hex_ff : t val ( <= ) : t... |
module Make ( I : S ) : S with type t = I . t = struct type t = I . t let compare = I . compare let equal = I . equal let hash = I . hash let [ @ ocamlformat " disable " ] print = I . print let sign_extend t = I . shift_right ( I . shift_left t 1 ) 1 let min_value = I . s... |
module LazyStream = struct type ' a t = Cons of ' a * ' a t Lazy . t | Nil let of_stream stream = let rec next stream = try Cons ( Stream . next stream , lazy ( next stream ) ) with Stream . Failure -> Nil in next stream let of_function f = let rec next f = match f ( ) with | Some x ... |
let implode l = String . concat " " ( List . map ( String . make 1 ) l ) |
let explode s = let l = ref [ ] in String . iter ( fun c -> l := c :: ! l ) s ; List . rev ! l |
let ( ) % f g = fun x -> g ( f x ) |
let parse parser input = match parser input with | Some ( res , _ ) -> Some res | None -> None |
type ' token input = ' token LazyStream . t |
type ( ' token , ' result ) monad = ( ' result * ' token input ) option |
type ( ' token , ' result ) parser = ' token input -> ( ' result * ' token input ) option |
let return x input = Some ( x , input ) |
let ( ) >>= x f = fun input -> match x input with | Some ( result ' , input ' ) -> f result ' input ' | None -> None |
let ( ) <|> x y = fun input -> match x input with | Some _ as ret -> ret | None -> y input |
let rec scan x input = match x input with | Some ( result ' , input ' ) -> LazyStream . Cons ( result ' , lazy ( scan x input ' ) ) | None -> LazyStream . Nil |
let mzero _ = None |
let any = function | LazyStream . Cons ( token , input ' ) -> Some ( token , Lazy . force input ' ) | LazyStream . Nil -> None |
let satisfy test = any >>= ( fun res -> if test res then return res else mzero ) |
let eof x = function | LazyStream . Nil -> Some ( x , LazyStream . Nil ) | _ -> None |
let ( ) => x f = x >>= fun r -> return ( f r ) |
let ( ) >> x y = x >>= fun _ -> y |
let ( ) << x y = x >>= fun r -> y >>= fun _ -> return r |
let ( ) <~> x xs = x >>= fun r -> xs >>= fun rs -> return ( r :: rs ) |
let rec choice = function | [ ] -> mzero | h :: t -> h <|> choice t |
let rec count n x = if n > 0 then x <~> count ( n - 1 ) x else return [ ] |
let between op ed x = op >> x << ed |
let option default x = x <|> return default |
let optional x = option ( ) ( x >> return ( ) ) |
let rec skip_many x = option ( ) ( x >>= fun _ -> skip_many x ) |
let skip_many1 x = x >> skip_many x |
let rec many x = option [ ] ( x >>= fun r -> many x >>= fun rs -> return ( r :: rs ) ) |
let many1 x = x <~> many x |
let sep_by1 x sep = x <~> many ( sep >> x ) |
let sep_by x sep = sep_by1 x sep <|> return [ ] |
let end_by1 x sep = sep_by1 x sep << sep |
let end_by x sep = end_by1 x sep <|> return [ ] |
let chainl1 x op = let rec loop a = ( op >>= fun f -> x >>= fun b -> loop ( f a b ) ) <|> return a in x >>= loop |
let chainl x op default = chainl1 x op <|> return default |
let rec chainr1 x op = x >>= fun a -> ( op >>= fun f -> chainr1 x op => f a ) <|> return a |
let chainr x op default = chainr1 x op <|> return default |
let exactly x = satisfy ( ( ) = x ) |
let one_of l = satisfy ( fun x -> List . mem x l ) |
let none_of l = satisfy ( fun x -> not ( List . mem x l ) ) |
let range l r = satisfy ( fun x -> l <= x && x <= r ) |
let space = one_of [ ' ' ; ' \ t ' ; ' \ r ' ; ' \ n ' ] |
let spaces = skip_many space |
let newline = exactly ' \ n ' |
let tab = exactly ' \ t ' |
let upper = range ' A ' ' Z ' |
let lower = range ' a ' ' z ' |
let digit = range ' 0 ' ' 9 ' |
let letter = lower <|> upper |
let alpha_num = letter <|> digit |
let hex_digit = range ' a ' ' f ' <|> range ' A ' ' F ' <|> digit |
let oct_digit = range ' 0 ' ' 7 ' |
let lexeme x = spaces >> x |
let token s = let rec loop s i = if i >= String . length s then return s else exactly s . [ i ] >> loop s ( i + 1 ) in lexeme ( loop s 0 ) |
let _ = ( Callback . register_exception " no_platform " NO_PLATFORM ; Callback . register_exception " no_opencl_device " No_OpenCL_Device ; Callback . register_exception " opencl_error_unknown " OPENCL_ERROR_UNKNOWN ; Callback . register_exception " opencl_invalid_context " INVALID_CON... |
module type TRACER = sig val call : string -> string list -> StringSet . t * Unix . process_status end |
module Ktrace = struct let process_line line ( wait_a_string , set ) = let strings = Lexers . space_sep_strings ( Lexing . from_string line ) in if wait_a_string then match strings with | [ _ ; _ ; " NAMI " ; file ] -> false , StringSet . add file set | _ -> failwith ( Printf... |
module Driver ( T : TRACER ) = struct let usage ( ) = Printf . eprintf " Usage : % s [ - a < authorized_file ] >* < cmd > < args >*\ n " %! Sys . argv . ( 0 ) ; exit 2 let main ( ) = let log = " opentracer . log " in let oc = if sys_file_exists log then open_out_g... |
let main = let module M = Driver ( Ktrace ) in M . main |
let ( ) = main ( ) |
let dw_op_regx ~ dwarf_reg_number : O . t = match dwarf_reg_number with | 0 -> DW_op_reg0 | 1 -> DW_op_reg1 | 2 -> DW_op_reg2 | 3 -> DW_op_reg3 | 4 -> DW_op_reg4 | 5 -> DW_op_reg5 | 6 -> DW_op_reg6 | 7 -> DW_op_reg7 | 8 -> DW_op_reg8 | 9 -> DW_op_reg9 | 10 -> DW_op_reg10 | 11 ->... |
let dw_op_bregx ~ dwarf_reg_number ~ offset_in_bytes : O . t = match dwarf_reg_number with | 0 -> DW_op_breg0 { offset_in_bytes } | 1 -> DW_op_breg1 { offset_in_bytes } | 2 -> DW_op_breg2 { offset_in_bytes } | 3 -> DW_op_breg3 { offset_in_bytes } | 4 -> DW_op_breg4 { offset_in_byt... |
let register_as_lvalue ~ dwarf_reg_number = dw_op_regx ~ dwarf_reg_number |
let contents_of_register ~ dwarf_reg_number = dw_op_bregx ~ dwarf_reg_number ~ offset_in_bytes : Targetint . zero |
let address_of_stack_slot ~ offset_in_bytes = [ O . DW_op_call_frame_cfa ; O . DW_op_consts ( Targetint . to_int64 offset_in_bytes ) ; O . DW_op_minus ] |
let contents_of_stack_slot ~ offset_in_bytes = [ O . DW_op_call_frame_cfa ; O . DW_op_consts ( Targetint . to_int64 offset_in_bytes ) ; O . DW_op_minus ; O . DW_op_deref ] |
let value_of_symbol ~ symbol : O . t = DW_op_addr ( Symbol symbol ) |
let signed_int_const i : O . t = DW_op_consts ( Targetint . to_int64 i ) |
let add_unsigned_const i : O . t list = if Targetint . compare i Targetint . zero < 0 then Misc . fatal_error " [ Operator_builder . add_unsigned_const ] only takes integers >= 0 " ; if Targetint . compare i Targetint . zero = 0 then [ ] else [ DW_op_plus_uconst ( Targetint . n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.