text stringlengths 12 786k |
|---|
let log2_size_addr = Misc . log2 size_addr |
let log2_size_float = Misc . log2 size_float |
let numfloat_shift = 9 + log2_size_float - log2_size_addr |
let is_addr_array_hdr hdr dbg = Cop ( Ccmpi Cne , [ Cop ( Cand , [ hdr ; Cconst_int ( 255 , dbg ) ] , dbg ) ; floatarray_tag dbg ] , dbg ) |
let is_addr_array_ptr ptr dbg = Cop ( Ccmpi Cne , [ get_tag ptr dbg ; floatarray_tag dbg ] , dbg ) |
let addr_array_length_shifted hdr dbg = Cop ( Clsr , [ hdr ; Cconst_int ( wordsize_shift , dbg ) ] , dbg ) |
let float_array_length_shifted hdr dbg = Cop ( Clsr , [ hdr ; Cconst_int ( numfloat_shift , dbg ) ] , dbg ) |
let lsl_const c n dbg = if n = 0 then c else Cop ( Clsl , [ c ; Cconst_int ( n , dbg ) ] , dbg ) |
let array_indexing ? typ log2size ptr ofs dbg = let add = match typ with | None | Some Addr -> Cadda | Some Int -> Caddi | _ -> assert false in match ofs with | Cconst_int ( n , _ ) -> let i = n asr 1 in if i = 0 then ptr else Cop ( add , [ ptr ; Cconst_int ( i lsl log2size , dbg ) ... |
let addr_array_ref arr ofs dbg = Cop ( Cload ( Word_val , Mutable ) , [ array_indexing log2_size_addr arr ofs dbg ] , dbg ) |
let int_array_ref arr ofs dbg = Cop ( Cload ( Word_int , Mutable ) , [ array_indexing log2_size_addr arr ofs dbg ] , dbg ) |
let unboxed_float_array_ref arr ofs dbg = Cop ( Cload ( Double , Mutable ) , [ array_indexing log2_size_float arr ofs dbg ] , dbg ) |
let float_array_ref arr ofs dbg = box_float dbg Lambda . alloc_heap ( unboxed_float_array_ref arr ofs dbg ) |
let addr_array_set arr ofs newval dbg = Cop ( Cextcall ( " caml_modify " , typ_void , [ ] , false ) , [ array_indexing log2_size_addr arr ofs dbg ; newval ] , dbg ) |
let int_array_set arr ofs newval dbg = Cop ( Cstore ( Word_int , Assignment ) , [ array_indexing log2_size_addr arr ofs dbg ; newval ] , dbg ) |
let float_array_set arr ofs newval dbg = Cop ( Cstore ( Double , Assignment ) , [ array_indexing log2_size_float arr ofs dbg ; newval ] , dbg ) |
let addr_array_set_local arr ofs newval dbg = Cop ( Cextcall ( " caml_modify_local " , typ_void , [ ] , false ) , [ arr ; untag_int ofs dbg ; newval ] , dbg ) |
let string_length exp dbg = bind " str " exp ( fun str -> let tmp_var = V . create_local " tmp " in Clet ( VP . create tmp_var , Cop ( Csubi , [ Cop ( Clsl , [ get_size str dbg ; Cconst_int ( log2_size_addr , dbg ) ] , dbg ) ; Cconst_int ( 1 , dbg ) ] , dbg ) ... |
let bigstring_length ba dbg = Cop ( Cload ( Word_int , Mutable ) , [ field_address ba 5 dbg ] , dbg ) |
let lookup_tag obj tag dbg = bind " tag " tag ( fun tag -> Cop ( Cextcall ( " caml_get_public_method " , typ_val , [ ] , false ) , [ obj ; tag ] , dbg ) ) |
let lookup_label obj lab dbg = bind " lab " lab ( fun lab -> let table = Cop ( Cload ( Word_val , Mutable ) , [ obj ] , dbg ) in addr_array_ref table lab dbg ) |
let send_function_name n ( mode : Lambda . alloc_mode ) = let suff = match mode with Alloc_heap -> " " | Alloc_local -> " L " in " caml_send " ^ Int . to_string n ^ suff |
let call_cached_method obj tag cache pos args ( apos , mode ) dbg = let arity = List . length args in let cache = array_indexing log2_size_addr cache pos dbg in Compilenv . need_send_fun arity mode ; Cop ( Capply ( typ_val , apos ) , Cconst_symbol ( send_function_name arity mode , dbg ) ... |
let make_alloc_generic ~ mode set_fn dbg tag wordsize args = if Lambda . is_local_mode mode || wordsize <= Config . max_young_wosize then let hdr = match mode with | Lambda . Alloc_local -> local_block_header tag wordsize | Lambda . Alloc_heap -> block_header tag wordsize in Cop ( Calloc mode , Cco... |
let make_alloc ~ mode dbg tag args = let addr_array_init arr ofs newval dbg = Cop ( Cextcall ( " caml_initialize " , typ_void , [ ] , false ) , [ array_indexing log2_size_addr arr ofs dbg ; newval ] , dbg ) in make_alloc_generic ~ mode addr_array_init dbg tag ( List . length args... |
let make_float_alloc ~ mode dbg tag args = make_alloc_generic ~ mode float_array_set dbg tag ( List . length args * size_float / size_addr ) args |
let make_checkbound dbg = function | [ Cop ( Clsr , [ a1 ; Cconst_int ( n , _ ) ] , _ ) ; Cconst_int ( m , _ ) ] when ( m lsl n ) > n -> Cop ( Ccheckbound , [ a1 ; Cconst_int ( m lsl n + 1 lsl n - 1 , dbg ) ] , dbg ) | args -> Cop ( Ccheckbound , ... |
let apply_function_name ( n , ( mode : Lambda . alloc_mode ) ) = let suff = match mode with Alloc_heap -> " " | Alloc_local -> " L " in " caml_apply " ^ Int . to_string n ^ suff |
let apply_function_sym n mode = assert ( n > 0 ) ; Compilenv . need_apply_fun n mode ; apply_function_name ( n , mode ) |
let curry_function_sym ar = Compilenv . need_curry_fun ar ; match ar with | Lambda . Curried { nlocal } , n -> " caml_curry " ^ Int . to_string n ^ ( if nlocal > 0 then " L " ^ Int . to_string nlocal else " " ) | Lambda . Tupled , n -> " caml_tuplify " ^ Int . to_str... |
let bigarray_elt_size : Lambda . bigarray_kind -> int = function Pbigarray_unknown -> assert false | Pbigarray_float32 -> 4 | Pbigarray_float64 -> 8 | Pbigarray_sint8 -> 1 | Pbigarray_uint8 -> 1 | Pbigarray_sint16 -> 2 | Pbigarray_uint16 -> 2 | Pbigarray_int32 -> 4 | Pbigarray_int64 -> 8 ... |
let bigarray_indexing unsafe elt_kind layout b args dbg = let check_ba_bound bound idx v = Csequence ( make_checkbound dbg [ bound ; idx ] , v ) in let rec ba_indexing dim_ofs delta_ofs = function [ ] -> assert false | [ arg ] -> if unsafe then arg else bind " idx " arg ( fun idx -> let... |
let bigarray_word_kind : Lambda . bigarray_kind -> memory_chunk = function Pbigarray_unknown -> assert false | Pbigarray_float32 -> Single | Pbigarray_float64 -> Double | Pbigarray_sint8 -> Byte_signed | Pbigarray_uint8 -> Byte_unsigned | Pbigarray_sint16 -> Sixteen_signed | Pbigarray_uint16 -> Sixtee... |
let bigarray_get unsafe elt_kind layout b args dbg = bind " ba " b ( fun b -> match ( elt_kind : Lambda . bigarray_kind ) with Pbigarray_complex32 | Pbigarray_complex64 -> let kind = bigarray_word_kind elt_kind in let sz = bigarray_elt_size elt_kind / 2 in bind " addr " ( bigarray_indexing un... |
let bigarray_set unsafe elt_kind layout b args newval dbg = bind " ba " b ( fun b -> match ( elt_kind : Lambda . bigarray_kind ) with Pbigarray_complex32 | Pbigarray_complex64 -> let kind = bigarray_word_kind elt_kind in let sz = bigarray_elt_size elt_kind / 2 in bind " newval " newval ( fun ... |
let ( ) = assert ( size_int = 4 || size_int = 8 ) |
let rec low_32 dbg = function | x when size_int = 4 -> x | Cop ( Casr , [ Cop ( Clsl , [ x ; Cconst_int ( 32 , _ ) ] , _ ) ; Cconst_int ( 32 , _ ) ] , _ ) | Cop ( Cand , [ x ; Cconst_natint ( 0xFFFFFFFFn , _ ) ] , _ ) -> low_32 dbg x | Clet (... |
let sign_extend_32 dbg e = if size_int = 4 then e else Cop ( Casr , [ Cop ( Clsl , [ low_32 dbg e ; Cconst_int ( 32 , dbg ) ] , dbg ) ; Cconst_int ( 32 , dbg ) ] , dbg ) |
let zero_extend_32 dbg e = if size_int = 4 then e else Cop ( Cand , [ low_32 dbg e ; natint_const_untagged dbg 0xFFFFFFFFn ] , dbg ) |
let operations_boxed_int ( bi : Primitive . boxed_integer ) = match bi with Pnativeint -> caml_nativeint_ops | Pint32 -> caml_int32_ops | Pint64 -> caml_int64_ops |
let alloc_header_boxed_int ( bi : Primitive . boxed_integer ) mode dbg = match bi with Pnativeint -> alloc_boxedintnat_header mode dbg | Pint32 -> alloc_boxedint32_header mode dbg | Pint64 -> alloc_boxedint64_header mode dbg |
let box_int_gen dbg ( bi : Primitive . boxed_integer ) mode arg = let arg ' = if bi = Primitive . Pint32 && size_int = 8 then if big_endian then Cop ( Clsl , [ arg ; Cconst_int ( 32 , dbg ) ] , dbg ) else sign_extend_32 dbg arg else arg in Cop ( Calloc mode , [ alloc_header_b... |
let split_int64_for_32bit_target arg dbg = bind " split_int64 " arg ( fun arg -> let first = Cop ( Cadda , [ Cconst_int ( size_int , dbg ) ; arg ] , dbg ) in let second = Cop ( Cadda , [ Cconst_int ( 2 * size_int , dbg ) ; arg ] , dbg ) in Ctuple [ Cop ( Cload ( ... |
let alloc_matches_boxed_int bi ~ hdr ~ ops = match ( bi : Primitive . boxed_integer ) , hdr , ops with | Pnativeint , Cconst_natint ( hdr , _dbg ) , Cconst_symbol ( sym , _ ) -> Nativeint . equal hdr boxedintnat_header && String . equal sym caml_nativeint_ops | Pint32 , Cconst_... |
let unbox_int dbg bi = let default arg = if size_int = 4 && bi = Primitive . Pint64 then split_int64_for_32bit_target arg dbg else Cop ( Cload ( ( if bi = Primitive . Pint32 then Thirtytwo_signed else Word_int ) , Immutable ) , [ Cop ( Cadda , [ arg ; Cconst_int ( size_addr , dbg ... |
let make_unsigned_int bi arg dbg = if bi = Primitive . Pint32 && size_int = 8 then zero_extend_32 dbg arg else arg |
let unaligned_load_16 ptr idx dbg = if Arch . allow_unaligned_access then Cop ( Cload ( Sixteen_unsigned , Mutable ) , [ add_int ptr idx dbg ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cload ( Byte_unsigned , Mutable ) , [ add_int ptr idx dbg ] ,... |
let unaligned_set_16 ptr idx newval dbg = if Arch . allow_unaligned_access then Cop ( Cstore ( Sixteen_unsigned , Assignment ) , [ add_int ptr idx dbg ; newval ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cand , [ Cop ( Clsr , [ newval ; cconst_... |
let unaligned_load_32 ptr idx dbg = if Arch . allow_unaligned_access then Cop ( Cload ( Thirtytwo_unsigned , Mutable ) , [ add_int ptr idx dbg ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cload ( Byte_unsigned , Mutable ) , [ add_int ptr idx dbg ] ... |
let unaligned_set_32 ptr idx newval dbg = if Arch . allow_unaligned_access then Cop ( Cstore ( Thirtytwo_unsigned , Assignment ) , [ add_int ptr idx dbg ; newval ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cand , [ Cop ( Clsr , [ newval ; ccons... |
let unaligned_load_64 ptr idx dbg = assert ( size_int = 8 ) ; if Arch . allow_unaligned_access then Cop ( Cload ( Word_int , Mutable ) , [ add_int ptr idx dbg ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cload ( Byte_unsigned , Mutable ) , [ ... |
let unaligned_set_64 ptr idx newval dbg = assert ( size_int = 8 ) ; if Arch . allow_unaligned_access then Cop ( Cstore ( Word_int , Assignment ) , [ add_int ptr idx dbg ; newval ] , dbg ) else let cconst_int i = Cconst_int ( i , dbg ) in let v1 = Cop ( Cand , [ Cop ( Clsr ... |
let max_or_zero a dbg = bind " size " a ( fun a -> let sign = Cop ( Casr , [ a ; Cconst_int ( size_int * 8 - 1 , dbg ) ] , dbg ) in let sign_negation = Cop ( Cxor , [ sign ; Cconst_int ( - 1 , dbg ) ] , dbg ) in Cop ( Cand , [ sign_negation ; a ] , dbg... |
let check_bound safety access_size dbg length a2 k = match ( safety : Lambda . is_safe ) with | Unsafe -> k | Safe -> let offset = match ( access_size : Clambda_primitives . memory_access_size ) with | Sixteen -> 1 | Thirty_two -> 3 | Sixty_four -> 7 in let a1 = sub_int length ( Cconst_i... |
let opaque e dbg = Cop ( Copaque , [ e ] , dbg ) |
let unaligned_set size ptr idx newval dbg = match ( size : Clambda_primitives . memory_access_size ) with | Sixteen -> unaligned_set_16 ptr idx newval dbg | Thirty_two -> unaligned_set_32 ptr idx newval dbg | Sixty_four -> unaligned_set_64 ptr idx newval dbg |
let unaligned_load size ptr idx dbg = match ( size : Clambda_primitives . memory_access_size ) with | Sixteen -> unaligned_load_16 ptr idx dbg | Thirty_two -> unaligned_load_32 ptr idx dbg | Sixty_four -> unaligned_load_64 ptr idx dbg |
let box_sized size mode dbg exp = match ( size : Clambda_primitives . memory_access_size ) with | Sixteen -> tag_int exp dbg | Thirty_two -> box_int_gen dbg Pint32 mode exp | Sixty_four -> box_int_gen dbg Pint64 mode exp |
let default_prim name = Primitive . simple ~ name ~ arity : 0 ~ alloc : true |
let int64_native_prim name arity ~ alloc = let u64 = Primitive . ( Prim_global , Unboxed_integer Pint64 ) in let rec make_args = function 0 -> [ ] | n -> u64 :: make_args ( n - 1 ) in let effects = Primitive . Arbitrary_effects in let coeffects = Primitive . Has_coeffects in Primitive .... |
let simplif_primitive_32bits : Clambda_primitives . primitive -> Clambda_primitives . primitive = function Pbintofint ( Pint64 , _ ) -> Pccall ( default_prim " caml_int64_of_int " ) | Pintofbint Pint64 -> Pccall ( default_prim " caml_int64_to_int " ) | Pcvtbint ( Pint32 , Pint64 , ... |
let simplif_primitive p : Clambda_primitives . primitive = match ( p : Clambda_primitives . primitive ) with | Pduprecord _ -> Pccall ( default_prim " caml_obj_dup " ) | Pbigarrayref ( _unsafe , n , Pbigarray_unknown , _layout ) -> Pccall ( default_prim ( " caml_ba_get_ " ^ ... |
let transl_isout h arg dbg = tag_int ( Cop ( Ccmpa Clt , [ h ; arg ] , dbg ) ) dbg |
let make_switch arg cases actions dbg = let extract_uconstant = function | Cconst_int ( n , _ ) , _dbg when ( n land 1 ) = 1 -> Some ( Cint ( Nativeint . of_int n ) ) | Cconst_natint ( n , _ ) , _dbg when Nativeint . ( to_int ( logand n one ) = 1 ) -> Some ( Cint... |
module SArgBlocks = struct type primitive = operation let eqint = Ccmpi Ceq let neint = Ccmpi Cne let leint = Ccmpi Cle let ltint = Ccmpi Clt let geint = Ccmpi Cge let gtint = Ccmpi Cgt type act = expression type loc = Debuginfo . t type value_kind = unit let make_const i = Cconst_int ( i , Debuginfo ... |
module StoreExpForSwitch = Switch . CtxStore ( struct type t = expression type key = int option * int type context = int let make_key index expr = let continuation = match expr with | Cexit ( i , [ ] ) -> Some i | _ -> None in Some ( continuation , index ) let compare_key ( cont , in... |
module StoreExp = Switch . Store ( struct type t = expression type key = int let make_key = function | Cexit ( i , [ ] ) -> Some i | _ -> None let compare_key = Stdlib . compare end ) |
let transl_int_switch dbg arg low high cases default = match cases with let store = StoreExp . mk_store ( ) in assert ( store . Switch . act_store ( ) default = 0 ) ; let cases = List . map ( fun ( i , act ) -> i , store . Switch . act_store ( ) act ) cases in let rec int... |
let transl_switch_clambda loc arg index cases = let store = StoreExpForSwitch . mk_store ( ) in let index = Array . map ( fun j -> store . Switch . act_store j cases . ( j ) ) index in let n_index = Array . length index in let inters = ref [ ] and this_high = ref ( n_index - 1 ) ... |
let strmatch_compile = let module S = Strmatch . Make ( struct let string_block_length ptr = get_size ptr Debuginfo . none let transl_switch = transl_int_switch end ) in S . compile |
let ptr_offset ptr offset dbg = if offset = 0 then ptr else Cop ( Caddv , [ ptr ; Cconst_int ( offset * size_addr , dbg ) ] , dbg ) |
let direct_apply lbl args ( pos , _mode ) dbg = Cop ( Capply ( typ_val , pos ) , Cconst_symbol ( lbl , dbg ) :: args , dbg ) |
let generic_apply mut clos args ( pos , mode ) dbg = match args with | [ arg ] -> bind " fun " clos ( fun clos -> Cop ( Capply ( typ_val , pos ) , [ get_field_gen mut clos 0 dbg ; arg ; clos ] , dbg ) ) | _ -> let arity = List . length args in let cargs = Cconst_symbo... |
let send kind met obj args akind dbg = let call_met obj args clos = generic_apply Asttypes . Mutable clos ( obj :: args ) akind dbg in bind " obj " obj ( fun obj -> match ( kind : Lambda . meth_kind ) , args with Self , _ -> bind " met " ( lookup_label obj met dbg ) ( call_met obj... |
let cache_public_method meths tag cache dbg = let raise_num = Lambda . next_raise_count ( ) in let cconst_int i = Cconst_int ( i , dbg ) in let li = V . create_local " * li " * and hi = V . create_local " * hi " * and mi = V . create_local " * mi " * and tagged = V . create_... |
let has_local_allocs e = let rec loop = function | Cregion e -> loop_until_tail e | Cop ( Calloc Alloc_local , _ , _ ) | Cop ( ( Cextcall _ | Capply _ ) , _ , _ ) -> raise Exit | e -> iter_shallow loop e and loop_until_tail = function | Ctail e -> loop e | Cregion _ -> ( ) ... |
let remove_region_tail e = let rec has_tail = function | Ctail _ | Cop ( Capply ( _ , Rc_close_at_apply ) , _ , _ ) -> raise Exit | Cregion _ -> ( ) | e -> ignore ( iter_shallow_tail has_tail e ) in let rec remove_tail = function | Ctail e -> e | Cop ( Capply ( mach , Rc_cl... |
let region e = if has_local_allocs e then Cregion e else remove_region_tail e |
let placeholder_dbg ( ) = Debuginfo . none |
let placeholder_fun_dbg ~ human_name : _ = Debuginfo . none |
let apply_function_body ( arity , ( mode : Lambda . alloc_mode ) ) = let dbg = placeholder_dbg in let arg = Array . make arity ( V . create_local " arg " ) in for i = 1 to arity - 1 do arg . ( i ) <- V . create_local " arg " done ; let clos = V . create_local " clos "... |
let send_function ( arity , mode ) = let dbg = placeholder_dbg in let cconst_int i = Cconst_int ( i , dbg ( ) ) in let ( args , clos ' , body ) = apply_function_body ( 1 + arity , mode ) in let cache = V . create_local " cache " and obj = List . hd args and tag = V . c... |
let apply_function arity = let ( args , clos , body ) = apply_function_body arity in let all_args = args @ [ clos ] in let fun_name = apply_function_name arity in let fun_dbg = placeholder_fun_dbg ~ human_name : fun_name in Cfunction { fun_name ; fun_args = List . map ( fun arg -> ( VP .... |
let tuplify_function arity = let dbg = placeholder_dbg in let arg = V . create_local " arg " in let clos = V . create_local " clos " in let rec access_components i = if i >= arity then [ ] else get_field_gen Asttypes . Mutable ( Cvar arg ) i ( dbg ( ) ) :: access_components ( i +... |
let final_curry_function ~ nlocal ~ arity = let dbg = placeholder_dbg in let last_arg = V . create_local " arg " in let last_clos = V . create_local " clos " in let rec curry_fun args clos n = if n = 0 then Cop ( Capply ( typ_val , Rc_normal ) , get_field_gen Asttypes . Mutable ( Cvar... |
let rec intermediate_curry_functions ~ nlocal ~ arity num = let dbg = placeholder_dbg in if num = arity - 1 then [ final_curry_function ~ nlocal ~ arity ] else begin let name1 = " caml_curry " ^ Int . to_string arity ^ ( if nlocal > 0 then " L " ^ Int . to_string nlocal else " " ) ... |
let curry_function = function | Lambda . Tupled , n -> assert ( n > 0 ) ; [ tuplify_function n ] | Lambda . Curried { nlocal } , n -> assert ( n > 0 ) ; intermediate_curry_functions ~ nlocal ~ arity : n 0 |
module ApplyFnSet = Set . Make ( struct type t = int * Lambda . alloc_mode let compare = compare end ) |
module AritySet = Set . Make ( struct type t = Clambda . arity let compare = compare end ) |
let default_apply = ApplyFnSet . of_list [ 2 , Lambda . alloc_heap ; 3 , Lambda . alloc_heap ] |
let generic_functions shared units = let ( apply , send , curry ) = List . fold_left ( fun ( apply , send , curry ) ( ui : Cmx_format . unit_infos ) -> List . fold_right ApplyFnSet . add ui . ui_apply_fun apply , List . fold_right ApplyFnSet . add ui . ui_send_fun send , Li... |
type unary_primitive = expression -> Debuginfo . t -> expression |
let floatfield n ptr dbg = Cop ( Cload ( Double , Mutable ) , [ if n = 0 then ptr else Cop ( Cadda , [ ptr ; Cconst_int ( n * size_float , dbg ) ] , dbg ) ] , dbg ) |
let int_as_pointer arg dbg = Cop ( Caddi , [ arg ; Cconst_int ( - 1 , dbg ) ] , dbg ) |
let raise_prim raise_kind arg dbg = if ! Clflags . debug then Cop ( Craise raise_kind , [ arg ] , dbg ) else Cop ( Craise Lambda . Raise_notrace , [ arg ] , dbg ) |
let negint arg dbg = Cop ( Csubi , [ Cconst_int ( 2 , dbg ) ; arg ] , dbg ) |
let offsetref n arg dbg = return_unit dbg ( bind " ref " arg ( fun arg -> Cop ( Cstore ( Word_int , Assignment ) , [ arg ; add_const ( Cop ( Cload ( Word_int , Mutable ) , [ arg ] , dbg ) ) ( n lsl 1 ) dbg ] , dbg ) ) ) |
let arraylength kind arg dbg = let hdr = get_header_without_profinfo arg dbg in match ( kind : Lambda . array_kind ) with Pgenarray -> let len = if wordsize_shift = numfloat_shift then Cop ( Clsr , [ hdr ; Cconst_int ( wordsize_shift , dbg ) ] , dbg ) else bind " header " hdr ( fun... |
let bbswap bi arg dbg = let prim , tyarg = match ( bi : Primitive . boxed_integer ) with | Pnativeint -> " nativeint " , XInt | Pint32 -> " int32 " , XInt32 | Pint64 -> " int64 " , XInt64 in Cop ( Cextcall ( Printf . sprintf " caml_ % s_direct_bswap " prim , typ_int , [... |
let bswap16 arg dbg = ( Cop ( Cextcall ( " caml_bswap16_direct " , typ_int , [ ] , false ) , [ arg ] , dbg ) ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.