|
| ( * ) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| ( * ) [Bap.Std.Bil.Infix] |
x * y -> BinOp(TIMES,x,y)
|
| ( * ) [Bap.Std.Integer.S] |
|
| (!!) [Monads.Std.Monad.Syntax.S2] |
|
| (!!) [Monads.Std.Monad.Syntax.S] |
|
| (!!) [Bap.Std.Tid] |
infix notation for from_string_exn
|
| (!$$$$$) [Monads.Std.Monad.Syntax.S2] |
!$$$$$f is Lift.quinary f
|
| (!$$$$$) [Monads.Std.Monad.Syntax.S] |
!$$$$$f is Lift.quinary f
|
| (!$$$$) [Monads.Std.Monad.Syntax.S2] |
!$$$$f is Lift.quaternary f
|
| (!$$$$) [Monads.Std.Monad.Syntax.S] |
!$$$$f is Lift.quaternary f
|
| (!$$$) [Monads.Std.Monad.Syntax.S2] |
|
| (!$$$) [Monads.Std.Monad.Syntax.S] |
|
| (!$$) [Monads.Std.Monad.Syntax.S2] |
|
| (!$$) [Monads.Std.Monad.Syntax.S] |
|
| (!$) [Monads.Std.Monad.Syntax.S2] |
|
| (!$) [Monads.Std.Monad.Syntax.S] |
|
| (!$) [Bap.Std.Bitvector.Int_err] |
!$v lifts v to an Or_error monad.
|
| ($) [Bap_future.Std.Variadic.S] |
args $x appends argument x to a list of arguments args .
|
| ($) [Ogre.Query] |
attrs $ attr appends an attribute attr to the sequence of
chosen attributes attrs .
|
| ($) [Ogre.Type] |
scm $field adds a field to a scheme scm .
|
| (%$) [Bap.Std.Bil.Infix] |
x %$ y -> BinOp (SMOD,x,y)
|
| (%:) [Ogre.Type] |
name : t is the same as def name t
|
| (&&) [Ogre.Query] |
|
| (+) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (+) [Ogre.Query] |
|
| (+) [Bap.Std.Bil.Infix] |
x + y -> BinOp (PLUS,x,y)
|
| (+) [Bap.Std.Integer.S] |
|
| (++) [Bap.Std.Bitvector] |
|
| (-) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (-) [Ogre.Query] |
|
| (-) [Bap.Std.Bil.Infix] |
x - y -> BinOp(MINUS,x,y)
|
| (-) [Bap.Std.Integer.S] |
|
| (--) [Bap.Std.Bitvector] |
|
| (/$) [Bap.Std.Bil.Infix] |
x /$ y -> BinOp(SDIVIDE,x,y)
|
| (/) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (/) [Bap_config] |
|
| (/) [Bap.Std.Bil.Infix] |
x / y -> BinOp(DIVIDE,x,y)
|
| (/) [Bap.Std.Integer.S] |
|
| (//) [Bap_primus.Std.Primus.Lisp.Type.Spec] |
params // rest specifies that a function is variadic,
but have some number of mandatory arguments, i.e., it
accepts a tuple of parameters specified by the params
type specifier and a variadic list of arguments
specified by the rest type specifier.
|
| (:=) [Bap.Std.Bil.Infix] |
|
| (<$) [Bap.Std.Bil.Infix] |
|
| (<) [Ogre.Query] |
|
| (<) [Bap.Std.Bil.Infix] |
|
| (<=$) [Bap.Std.Bil.Infix] |
x <=$ x -> Binop(SLE,x,y)
|
| (<=) [Ogre.Query] |
x <= y less than or equal
|
| (<=) [Bap.Std.Bil.Infix] |
|
| (<>) [Ogre.Query] |
|
| (<>) [Bap.Std.Bil.Infix] |
|
| (=) [Ogre.Query] |
|
| (=) [Bap.Std.Bil.Infix] |
|
| (==>) [Ogre.Query] |
|
| (>$) [Bap.Std.Bil.Infix] |
|
| (>) [Ogre.Query] |
|
| (>) [Bap.Std.Bil.Infix] |
|
| (>=$) [Bap.Std.Bil.Infix] |
x >=$ x -> Binop(SLE,y,x)
|
| (>=) [Ogre.Query] |
|
| (>=) [Bap.Std.Bil.Infix] |
|
| (>=>) [Monads.Std.Monad.Syntax.S2] |
f >=> g is fun x -> f x >>= g
|
| (>=>) [Monads.Std.Monad.Syntax.S] |
f >=> g is fun x -> f x >>= g
|
| (>>=) [Monads.Std.Monad.Syntax.S2] |
|
| (>>=) [Monads.Std.Monad.Syntax.S] |
|
| (>>>) [Bap_primus.Std.Primus.Machine.S.Syntax] |
event >>> action is the same as
Observation.observe event action
|
| (>>|) [Monads.Std.Monad.Syntax.S2] |
|
| (>>|) [Monads.Std.Monad.Syntax.S] |
|
| (@->) [Bap_primus.Std.Primus.Lisp.Type.Spec] |
params @-> t constructs a signature from the
parameter list specifier params and the return type
specifier t
|
| (@.) [Bap.Std.Bitvector] |
|
| (@@) [Monads.Std.Monoid.S] |
|
| (^!) [Bap.Std.Memory] |
m^.n dereferences a byte at address n
|
| (^) [Bap.Std.Memory] |
m^n dereferences a byte at address n
|
| (^) [Bap.Std.Bil.Infix] |
|
| (^::) [Regular.Std] |
x ^:: xs is a consing operator for sequences
|
| (asr) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (asr) [Bap.Std.Bil.Infix] |
x asr y = BinOp (ARSHIFT,x,y)
|
| (asr) [Bap.Std.Integer.S] |
|
| (land) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (land) [Bap.Std.Bil.Infix] |
x land y = BinOp (AND,x,y)
|
| (land) [Bap.Std.Integer.S] |
|
| (lor) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (lor) [Bap.Std.Bil.Infix] |
|
| (lor) [Bap.Std.Integer.S] |
|
| (lsl) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (lsl) [Bap.Std.Bil.Infix] |
x lsl y = BinOp (LSHIFT,x,y)
|
| (lsl) [Bap.Std.Integer.S] |
|
| (lsr) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (lsr) [Bap.Std.Bil.Infix] |
x lsr y = BinOp (RSHIFT,x,y)
|
| (lsr) [Bap.Std.Integer.S] |
|
| (lxor) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (lxor) [Bap.Std.Bil.Infix] |
x lxor y = BinOp (XOR,x,y)
|
| (lxor) [Bap.Std.Integer.S] |
|
| (mod) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (mod) [Bap.Std.Bil.Infix] |
x mod y -> BinOp (MOD,x,y)
|
| (mod) [Bap.Std.Integer.S] |
|
| (||) [Ogre.Query] |
|
| (~-) [Bap_primus.Std.Primus.Value.Make.Syntax] |
|
| (~-) [Bap.Std.Integer.S] |
|
| __aggregate_of_sexp__ [Bap_c_type] |
|
| __basic_of_sexp__ [Bap_c_type] |
|
| __bin_read_aggregate__ [Bap_c_type] |
|
| __bin_read_array__ [Bap_c_type] |
|
| __bin_read_attr__ [Bap_c_type] |
|
| __bin_read_basic__ [Bap_c_type] |
|
| __bin_read_bits_insn__ [Arm_types] |
|
| __bin_read_branch_insn__ [Arm_types] |
|
| __bin_read_ccr_or_nil__ [Arm_types] |
|
| __bin_read_ccr_reg__ [Arm_types] |
|
| __bin_read_char__ [Bap_c_type] |
|
| __bin_read_cint__ [Bap_c_type] |
|
| __bin_read_complex__ [Bap_c_type] |
|
| __bin_read_compound__ [Bap_c_type] |
|
| __bin_read_cond__ [Arm_types] |
|
| __bin_read_cv__ [Bap_c_type] |
|
| __bin_read_cvr__ [Bap_c_type] |
|
| __bin_read_enum__ [Bap_c_type] |
|
| __bin_read_floating__ [Bap_c_type] |
|
| __bin_read_gpr_or_nil__ [Arm_types] |
|
| __bin_read_gpr_reg__ [Arm_types] |
|
| __bin_read_insn__ [Arm_types] |
|
| __bin_read_integer__ [Bap_c_type] |
|
| __bin_read_long__ [Bap_c_type] |
|
| __bin_read_long_long__ [Bap_c_type] |
|
| __bin_read_mem_insn__ [Arm_types] |
|
| __bin_read_mem_multi_insn__ [Arm_types] |
|
| __bin_read_move_insn__ [Arm_types] |
|
| __bin_read_mult_insn__ [Arm_types] |
|
| __bin_read_nil_reg__ [Arm_types] |
|
| __bin_read_no_qualifier__ [Bap_c_type] |
|
| __bin_read_non_nil_reg__ [Arm_types] |
|
| __bin_read_op__ [Arm_types] |
|
| __bin_read_proto__ [Bap_c_type] |
|
| __bin_read_qualifier__ [Bap_c_type] |
|
| __bin_read_real__ [Bap_c_type] |
|
| __bin_read_reg__ [Arm_types] |
|
| __bin_read_scalar__ [Bap_c_type] |
|
| __bin_read_short__ [Bap_c_type] |
|
| __bin_read_signed__ [Bap_c_type] |
|
| __bin_read_spec__ [Bap_c_type] |
|
| __bin_read_special_insn__ [Arm_types] |
|
| __bin_read_t__ [Bap_c_data] |
|
| __bin_read_t__ [Bap_c_type.Array] |
|
| __bin_read_t__ [Bap_c_type.Compound] |
|
| __bin_read_t__ [Bap_c_type.Proto] |
|
| __bin_read_t__ [Bap_c_type.Spec] |
|
| __bin_read_t__ [Bap_c_type.Attr] |
|
| __bin_read_t__ [Bap_c_type.Qualifier] |
|
| __bin_read_t__ [Bap_c_type] |
|
| __bin_read_unsigned__ [Bap_c_type] |
|
| __bin_read_value__ [Bap_c_data] |
|
| __bits_insn_of_sexp__ [Arm_types] |
|
| __branch_insn_of_sexp__ [Arm_types] |
|
| __ccr_or_nil_of_sexp__ [Arm_types] |
|
| __ccr_reg_of_sexp__ [Arm_types] |
|
| __char_of_sexp__ [Bap_c_type] |
|
| __cint_of_sexp__ [Bap_c_type] |
|
| __complex_of_sexp__ [Bap_c_type] |
|
| __cond_of_sexp__ [Arm_types] |
|
| __enum_of_sexp__ [Bap_c_type] |
|
| __floating_of_sexp__ [Bap_c_type] |
|
| __gpr_of_sexp__ [X86_asm_reg_types] |
|
| __gpr_or_nil_of_sexp__ [Arm_types] |
|
| __gpr_reg_of_sexp__ [Arm_types] |
|
| __insn_of_sexp__ [Arm_types] |
|
| __integer_of_sexp__ [Bap_c_type] |
|
| __ip_of_sexp__ [X86_asm_reg_types] |
|
| __long_long_of_sexp__ [Bap_c_type] |
|
| __long_of_sexp__ [Bap_c_type] |
|
| __mem_insn_of_sexp__ [Arm_types] |
|
| __mem_multi_insn_of_sexp__ [Arm_types] |
|
| __move_insn_of_sexp__ [Arm_types] |
|
| __mult_insn_of_sexp__ [Arm_types] |
|
| __nil_reg_of_sexp__ [Arm_types] |
|
| __no_qualifier_of_sexp__ [Bap_c_type] |
|
| __non_nil_reg_of_sexp__ [Arm_types] |
|
| __op_of_sexp__ [Arm_types] |
|
| __r128_of_sexp__ [X86_asm_reg_types] |
|
| __r16_of_sexp__ [X86_asm_reg_types] |
|
| __r256_of_sexp__ [X86_asm_reg_types] |
|
| __r32_of_sexp__ [X86_asm_reg_types] |
|
| __r64_of_sexp__ [X86_asm_reg_types] |
|
| __r8_of_sexp__ [X86_asm_reg_types] |
|
| __r8h_of_sexp__ [X86_asm_reg_types] |
|
| __r8l_of_sexp__ [X86_asm_reg_types] |
|
| __real_of_sexp__ [Bap_c_type] |
|
| __reg_of_sexp__ [X86_asm] |
|
| __reg_of_sexp__ [Arm_types] |
|
| __scalar_of_sexp__ [Bap_c_type] |
|
| __segment_base_of_sexp__ [X86_asm_reg_types] |
|
| __segment_of_sexp__ [X86_asm_reg_types] |
|
| __short_of_sexp__ [Bap_c_type] |
|
| __signed_of_sexp__ [Bap_c_type] |
|
| __special_insn_of_sexp__ [Arm_types] |
|
| __t_of_sexp__ [Bap_c_type] |
|
| __t_of_sexp__ [X86_asm_reg_types] |
|
| __unsigned_of_sexp__ [Bap_c_type] |
|
A |
| a [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| abort [Bap_strings_detector] |
|
| abs [Bap_primus.Std.Primus.Value.Make] |
|
| abs [Bap.Std.Integer.Base] |
abs x absolute value of x
|
| accept [Monads.Std.Monad.Choice.S2] |
accept x accepts x as a result of computation.
|
| accept [Monads.Std.Monad.Choice.S] |
accept x accepts x as a result of computation.
|
| add [Bap_traces.Std.Traces] |
add trace registers a trace into the repository
|
| add [Bap_primus.Std.Primus.Env.Make] |
add var generator adds a variable var to the
environment.
|
| add [Bap_primus.Std.Primus.Value.Make] |
|
| add [Regular.Std.Data.Cache.Digest] |
add digest fmt x y z ... is a variadic function that
builds a string from arguments x y z ... using specified
format fmt and adds this string to the digest.
|
| add [Bap.Std.Memmap] |
add map mem tag adds a new memory region mem tagged with
tag .
|
| add [Bap.Std.Table] |
add table mem v returns a new table with added mapping from a
mem region mem to a data value v
|
| add [Bap.Std.Dict] |
add map tag x adds new value
|
| add [Bap.Std.Interval_tree.S] |
add t k x adds a new binding (k,x) to the mapping.
|
| add [Bap.Std.Trie.S] |
add trie ~key ~data associates data with key .
|
| add [Bap.Std.Integer.Base] |
|
| add_arg [Bap.Std.Sub.Builder] |
|
| add_blk [Bap.Std.Sub.Builder] |
appends a block to a subroutine
|
| add_component [Bap_primus.Std.Primus.Machine] |
add_component comp registers a machine component in the
Primus Framework.
|
| add_data [Bap_primus.Std.Primus.Memory.Make] |
add_data maps a memory chunk mem as writable and
nonexecutable segment of machine memory.
|
| add_def [Bap.Std.Blk.Builder] |
|
| add_elt [Bap.Std.Blk.Builder] |
|
| add_jmp [Bap.Std.Blk.Builder] |
|
| add_phi [Bap.Std.Blk.Builder] |
|
| add_printer [Bap_primus.Std.Primus.Exn] |
add_printer to_string registers a printer.
|
| add_reader [Regular.Std.Data.S] |
add_reader ?desc ~ver name reader registers a new reader
with a provided name , version ver and optional description
desc
|
| add_sexp [Regular.Std.Data.Cache.Digest] |
add_sexp d sexp_of x is add d "%a" Sexp.pp (sexp_of x)
|
| add_sub [Bap.Std.Program.Builder] |
add_sub builder sub appends a subroutine term to the
program.
|
| add_symbol [Bap.Std.Symtab] |
add_symbol table name entry blocks extends table with a
new symbol with a given name , entry block and body
blocks .
|
| add_text [Bap_primus.Std.Primus.Memory.Make] |
add_text mem maps a memory chunk mem as executable and
readonly segment of machine memory.
|
| add_word [Bap_strings_unscrambler.Make] |
add_word d x extends the dictionary d with the new word x .
|
| add_writer [Regular.Std.Data.S] |
add_writer ?desc ~ver name writer registers a new writer
with a provided name , version ver and optional description
desc
|
| addr [Bap.Std.Block] |
addr block = Memory.min_addr (memory block) address of the first instruction
|
| addr [Bap.Std.Disasm_expert.Basic] |
current position of the disassembler
|
| addr [Bap.Std.Image.Scheme] |
|
| addr_of_int [Bap.Std.Size] |
addr_of_int n return Ok `rn if `rn exists, Error
otherwise.
|
| addr_of_int_exn [Bap.Std.Size] |
addr_of_int_exn n the same as addr_of_int , but raises exception
instead of returning Error
|
| addr_of_int_opt [Bap.Std.Size] |
addr_of_int_opt n the same as addr_of_int but uses option type
instead of Or_error.t
|
| addr_of_word_size [Bap.Std.Size] |
|
| addr_size [Bap.Std.Image] |
addr_size image same as Arch.addr_size (Image.arch image)
|
| addr_size [Bap.Std.Arch] |
addr_size arch returns an address size for a a given arch
|
| address [Bap.Std] |
A virtual address of an entity
|
| af [X86_env] |
|
| affect_control_flow [Bap.Std.Insn] |
the instruction may perform a non-regular control flow
|
| after [Bap.Std.Term] |
after t ?rev p tid returns all subterms in term p that
occur after a term with a given tid .
|
| aggregate_of_sexp [Bap_c_type] |
|
| aliases [Bap.Std.Sub] |
other names for the given subroutine.
|
| all [Bap_primus.Std.Primus.Lisp.Type.Spec] |
all t specifies that a function accepts a variable
number of arguments all having type t .
|
| all [Bap_primus.Std.Primus.Env.Make] |
all is a sequence of all variables defined in the
environment.
|
| all [Monads.Std.Monad.Collection.S] |
all cs perfoms all computations in cs and returns a
list of results in the same order.
|
| all [Monads.Std.Monad.Collection.S2] |
all cs perfoms all computations in cs and returns a
list of results in the same order.
|
| all_ignore [Monads.Std.Monad.Collection.S] |
all_ignore cs performs all computations in cs in an
unspecified order, and discards the results.
|
| all_ignore [Monads.Std.Monad.Collection.S2] |
all_ignore cs performs all computations in cs in an
unspecified order, and discards the results.
|
| all_of_bits_insn [Arm_types] |
|
| all_of_branch_insn [Arm_types] |
|
| all_of_ccr_or_nil [Arm_types] |
|
| all_of_ccr_reg [Arm_types] |
|
| all_of_char [Bap_c_type] |
|
| all_of_cint [Bap_c_type] |
|
| all_of_complex [Bap_c_type] |
|
| all_of_cond [Arm_types] |
|
| all_of_floating [Bap_c_type] |
|
| all_of_gpr_or_nil [Arm_types] |
|
| all_of_gpr_reg [Arm_types] |
|
| all_of_insn [Arm_types] |
|
| all_of_long [Bap_c_type] |
|
| all_of_long_long [Bap_c_type] |
|
| all_of_mem_insn [Arm_types] |
|
| all_of_mem_multi_insn [Arm_types] |
|
| all_of_move_insn [Arm_types] |
|
| all_of_mult_insn [Arm_types] |
|
| all_of_nil_reg [Arm_types] |
|
| all_of_non_nil_reg [Arm_types] |
|
| all_of_real [Bap_c_type] |
|
| all_of_reg [Arm_types] |
|
| all_of_short [Bap_c_type] |
|
| all_of_signed [Bap_c_type] |
|
| all_of_special_insn [Arm_types] |
|
| all_of_unsigned [Bap_c_type] |
|
| alloc_size [Bap.Std.Arg] |
the size of allocated memory is the product of arguments
marked with alloc_size attribute
|
| allocate [Bap_primus.Std.Primus.Memory.Make] |
allocate addr size allocates a segment of the specified
size .
|
| ancestor [Monads.Std.Monad.State.Multi.S2] |
ancestor ids returns an identifier of the closest
common ancestor of states with the given identifiers.
|
| ancestor [Monads.Std.Monad.State.Multi.S] |
ancestor ids returns an identifier of the closest
common ancestor of states with the given identifiers.
|
| ancestors [Graphlib.Std.Tree] |
ancestors tree n returns a sequence of all ancestors of node
n .
|
| any [Bap_primus.Std.Primus.Lisp.Type.Spec] |
any top type which is inhabitated by all Primus values
|
| append [Bap.Std.Term] |
append t ~after:this p c returns the p term with c
appended after this term.
|
| append [Bap.Std.Vector] |
append xs x appends x to the end of xs
|
| apply [Bap_c_attr] |
apply all registered actions
|
| apply [Bare.Rule] |
apply rule fact applies rule to fact and produces a new
rule that contains a partial mathcing state, as well as a list
(possibly empty) of newly produced facts.
|
| apply [Bap_future.Std.Stream] |
apply fs xs apply stream of functions fs to a stream of
values xs, producing a stream of results.
|
| apply [Bap_future.Std.Variadic.S] |
apply args ~f applies function f to arguments args .
|
| apply [Bap_future.Std.Applicable.S] |
apply fs xs apply functions fs to xs
|
| apply_n_times [Monads.Std.Monad.S2.Fn] |
apply_n_times ~n f creates a chaing of computation of
size n made from applications of the same function to its
own result.
|
| apply_n_times [Monads.Std.Monad.S.Fn] |
apply_n_times ~n f creates a chaing of computation of
size n made from applications of the same function to its
own result.
|
| arch [Bap_traces.Std.Meta] |
description of binary architecture.
|
| arch [Bap_primus.Std.Primus.Machine.S] |
|
| arch [Bap.Std.Project.Info] |
occurs once input architecture is known
|
| arch [Bap.Std.Project] |
arch project reveals the architecture of a loaded file
|
| arch [Bap.Std.Image.Scheme] |
arch name a file contains code for the name architecture.
|
| arch [Bap.Std.Image] |
arch image code architecture
|
| architecture [Bap_config] |
|
| arg_intent [Bap_c_abi] |
arg_intent t infers argument intention based on its C type.
|
| arg_t [Bap.Std] |
|
| args [Bap_primus.Std.Primus.Machine.S] |
args program command line arguments
|
| args [Bap_future.Std.Variadic.S] |
args x creates a singleton list of arguments that can be
applied to a function that takes x argument, and returns a value
of type 'b .
|
| argv [Bap_plugins.Std.Plugin] |
|
| argv [Bap.Std.Self] |
args name returns an array of arguments designated for a
plugin with a given name .
|
| array [Bap.Std.Self.Config] |
array sep c splits the argument at each sep (defaults to ',' )
character and converts each substring with c .
|
| array_of_sexp [Bap_c_type] |
|
| arshift [Bap_primus.Std.Primus.Value.Make] |
|
| arshift [Bap.Std.Bil] |
|
| arshift [Bap.Std.Integer.Base] |
arshift x y shift x by y bits to the right and fill with
the sign bit.
|
| asm [Bap.Std.Insn] |
target-specific assembler string representing the instruction
|
| asm [Bap.Std.Disasm_expert.Basic.Insn] |
asm insn returns assembly representation of the instruction
|
| assert_cond [Arm_utils] |
|
| assert_imm [Arm_utils] |
|
| assert_reg [Arm_utils] |
|
| assn [Arm_utils] |
|
| at_least_one [Bap.Std.Table] |
|
| attach [Bap_taint.Std.Taint.Tracker.Make] |
attach v r xs establishes the relation r between the
value v and every object x in the set of objects xs .
|
| attached [Bap_taint.Std.Taint] |
(attached (r,o,v) occurs when the relation r is established
between o and v
|
| attr_of_sexp [Bap_c_type] |
|
| attrs [Bap.Std.Term] |
attrs term attrs returns the set of attributes associated
with a term
|
| autorun [Bap.Std.Project.Pass] |
autorun pass is true if a pass was created with
autorun option
|
| available [Bap_demangle.Std.Demanglers] |
available () lists currently registered demanglers.
|
| available_backends [Bap.Std.Disasm_expert.Basic] |
enumerates names of available disassembler backends.
|
| available_backends [Bap.Std.Image] |
lists all registered backends
|
| available_loaders [Bap.Std.Project.Input] |
available_loaders () returns a list of names of currently known loaders.
|
| available_modes [Text_tags] |
available_modes () lists all currently installed modes.
|
| available_readers [Regular.Std.Data.S] |
available_reader () lists available readers for the data type
|
| available_writers [Regular.Std.Data.S] |
available_writer () lists available writers for the data type
|
B |
| b [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| b0 [Bap_primus.Std.Primus.Value.Make] |
a fresh new false computation
|
| b0 [Bap.Std.Bitvector] |
|
| b1 [Bap_primus.Std.Primus.Value.Make] |
a fresh new true computation
|
| b1 [Bap.Std.Bitvector] |
|
| back [Bap.Std.Disasm_expert.Basic] |
|
| background [Bap.Std] |
print marked entity with specified color.
|
| backward [Graphlib.Std.Isomorphism] |
|
| bad_cast [Bap.Std.Type.Error] |
bad_cast error occurs when parameters to the cast operation
are not valid, or if a store operand is not of a word size
|
| bad_imm [Bap.Std.Type.Error] |
bad_imm error occurs when a value of type imm was expected
|
| bad_mem [Bap.Std.Type.Error] |
bad_mem error occurs when a value of type mem was expected
|
| bad_type [Bap.Std.Type.Error] |
bad_type ~exp ~got error happens when we expect a value of
type exp but got a value of type got .
|
| base [Bap.Std.Var] |
base v returns an original variable.
|
| base_address [Bap.Std.Image.Scheme] |
base_address addr this is the base address of an image,
i.e., an address of a first byte of the image.
|
| base_var [X86_llvm_env] |
base_var mode reg given a reg operand provided by the LLVM
disassembler, base_var returns the variable corresponding to
the physical register for that mode if it exists.
|
| basic_of_sexp [Bap_c_type] |
|
| before [Bap_future.Std.Stream] |
before e xs returns a list that contains elements of
the stream xs that occurred before the event e
|
| before [Bap.Std.Term] |
before t ?rev p tid returns all term that occurs before
defintion with a given tid in blk.
|
| bil [Bap.Std.Insn] |
returns BIL program specifying instruction semantics
|
| bin_aggregate [Bap_c_type] |
|
| bin_array [Bap_c_type] |
|
| bin_attr [Bap_c_type] |
|
| bin_basic [Bap_c_type] |
|
| bin_bits_insn [Arm_types] |
|
| bin_branch_insn [Arm_types] |
|
| bin_ccr_or_nil [Arm_types] |
|
| bin_ccr_reg [Arm_types] |
|
| bin_char [Bap_c_type] |
|
| bin_cint [Bap_c_type] |
|
| bin_complex [Bap_c_type] |
|
| bin_compound [Bap_c_type] |
|
| bin_cond [Arm_types] |
|
| bin_cv [Bap_c_type] |
|
| bin_cvr [Bap_c_type] |
|
| bin_enum [Bap_c_type] |
|
| bin_floating [Bap_c_type] |
|
| bin_gpr_or_nil [Arm_types] |
|
| bin_gpr_reg [Arm_types] |
|
| bin_insn [Arm_types] |
|
| bin_integer [Bap_c_type] |
|
| bin_long [Bap_c_type] |
|
| bin_long_long [Bap_c_type] |
|
| bin_mem_insn [Arm_types] |
|
| bin_mem_multi_insn [Arm_types] |
|
| bin_move_insn [Arm_types] |
|
| bin_mult_insn [Arm_types] |
|
| bin_nil_reg [Arm_types] |
|
| bin_no_qualifier [Bap_c_type] |
|
| bin_non_nil_reg [Arm_types] |
|
| bin_op [Arm_types] |
|
| bin_proto [Bap_c_type] |
|
| bin_qualifier [Bap_c_type] |
|
| bin_read_aggregate [Bap_c_type] |
|
| bin_read_array [Bap_c_type] |
|
| bin_read_attr [Bap_c_type] |
|
| bin_read_basic [Bap_c_type] |
|
| bin_read_bits_insn [Arm_types] |
|
| bin_read_branch_insn [Arm_types] |
|
| bin_read_ccr_or_nil [Arm_types] |
|
| bin_read_ccr_reg [Arm_types] |
|
| bin_read_char [Bap_c_type] |
|
| bin_read_cint [Bap_c_type] |
|
| bin_read_complex [Bap_c_type] |
|
| bin_read_compound [Bap_c_type] |
|
| bin_read_cond [Arm_types] |
|
| bin_read_cv [Bap_c_type] |
|
| bin_read_cvr [Bap_c_type] |
|
| bin_read_enum [Bap_c_type] |
|
| bin_read_floating [Bap_c_type] |
|
| bin_read_gpr_or_nil [Arm_types] |
|
| bin_read_gpr_reg [Arm_types] |
|
| bin_read_insn [Arm_types] |
|
| bin_read_integer [Bap_c_type] |
|
| bin_read_long [Bap_c_type] |
|
| bin_read_long_long [Bap_c_type] |
|
| bin_read_mem_insn [Arm_types] |
|
| bin_read_mem_multi_insn [Arm_types] |
|
| bin_read_move_insn [Arm_types] |
|
| bin_read_mult_insn [Arm_types] |
|
| bin_read_nil_reg [Arm_types] |
|
| bin_read_no_qualifier [Bap_c_type] |
|
| bin_read_non_nil_reg [Arm_types] |
|
| bin_read_op [Arm_types] |
|
| bin_read_proto [Bap_c_type] |
|
| bin_read_qualifier [Bap_c_type] |
|
| bin_read_real [Bap_c_type] |
|
| bin_read_reg [Arm_types] |
|
| bin_read_scalar [Bap_c_type] |
|
| bin_read_short [Bap_c_type] |
|
| bin_read_signed [Bap_c_type] |
|
| bin_read_spec [Bap_c_type] |
|
| bin_read_special_insn [Arm_types] |
|
| bin_read_t [Bap_c_data] |
|
| bin_read_t [Bap_c_type.Array] |
|
| bin_read_t [Bap_c_type.Compound] |
|
| bin_read_t [Bap_c_type.Proto] |
|
| bin_read_t [Bap_c_type.Spec] |
|
| bin_read_t [Bap_c_type.Attr] |
|
| bin_read_t [Bap_c_type.Qualifier] |
|
| bin_read_t [Bap_c_type] |
|
| bin_read_unsigned [Bap_c_type] |
|
| bin_read_value [Bap_c_data] |
|
| bin_reader [Regular.Std.Data] |
bin_reader (module T) returns a reader in binprot format.
|
| bin_reader_aggregate [Bap_c_type] |
|
| bin_reader_array [Bap_c_type] |
|
| bin_reader_attr [Bap_c_type] |
|
| bin_reader_basic [Bap_c_type] |
|
| bin_reader_bits_insn [Arm_types] |
|
| bin_reader_branch_insn [Arm_types] |
|
| bin_reader_ccr_or_nil [Arm_types] |
|
| bin_reader_ccr_reg [Arm_types] |
|
| bin_reader_char [Bap_c_type] |
|
| bin_reader_cint [Bap_c_type] |
|
| bin_reader_complex [Bap_c_type] |
|
| bin_reader_compound [Bap_c_type] |
|
| bin_reader_cond [Arm_types] |
|
| bin_reader_cv [Bap_c_type] |
|
| bin_reader_cvr [Bap_c_type] |
|
| bin_reader_enum [Bap_c_type] |
|
| bin_reader_floating [Bap_c_type] |
|
| bin_reader_gpr_or_nil [Arm_types] |
|
| bin_reader_gpr_reg [Arm_types] |
|
| bin_reader_insn [Arm_types] |
|
| bin_reader_integer [Bap_c_type] |
|
| bin_reader_long [Bap_c_type] |
|
| bin_reader_long_long [Bap_c_type] |
|
| bin_reader_mem_insn [Arm_types] |
|
| bin_reader_mem_multi_insn [Arm_types] |
|
| bin_reader_move_insn [Arm_types] |
|
| bin_reader_mult_insn [Arm_types] |
|
| bin_reader_nil_reg [Arm_types] |
|
| bin_reader_no_qualifier [Bap_c_type] |
|
| bin_reader_non_nil_reg [Arm_types] |
|
| bin_reader_op [Arm_types] |
|
| bin_reader_proto [Bap_c_type] |
|
| bin_reader_qualifier [Bap_c_type] |
|
| bin_reader_real [Bap_c_type] |
|
| bin_reader_reg [Arm_types] |
|
| bin_reader_scalar [Bap_c_type] |
|
| bin_reader_short [Bap_c_type] |
|
| bin_reader_signed [Bap_c_type] |
|
| bin_reader_spec [Bap_c_type] |
|
| bin_reader_special_insn [Arm_types] |
|
| bin_reader_t [Bap_c_data] |
|
| bin_reader_t [Bap_c_type.Array] |
|
| bin_reader_t [Bap_c_type.Compound] |
|
| bin_reader_t [Bap_c_type.Proto] |
|
| bin_reader_t [Bap_c_type.Spec] |
|
| bin_reader_t [Bap_c_type.Attr] |
|
| bin_reader_t [Bap_c_type.Qualifier] |
|
| bin_reader_t [Bap_c_type] |
|
| bin_reader_unsigned [Bap_c_type] |
|
| bin_reader_value [Bap_c_data] |
|
| bin_real [Bap_c_type] |
|
| bin_reg [Arm_types] |
|
| bin_scalar [Bap_c_type] |
|
| bin_shape_aggregate [Bap_c_type] |
|
| bin_shape_attr [Bap_c_type] |
|
| bin_shape_basic [Bap_c_type] |
|
| bin_shape_bits_insn [Arm_types] |
|
| bin_shape_branch_insn [Arm_types] |
|
| bin_shape_ccr_or_nil [Arm_types] |
|
| bin_shape_ccr_reg [Arm_types] |
|
| bin_shape_char [Bap_c_type] |
|
| bin_shape_cint [Bap_c_type] |
|
| bin_shape_complex [Bap_c_type] |
|
| bin_shape_cond [Arm_types] |
|
| bin_shape_cv [Bap_c_type] |
|
| bin_shape_cvr [Bap_c_type] |
|
| bin_shape_enum [Bap_c_type] |
|
| bin_shape_floating [Bap_c_type] |
|
| bin_shape_gpr_or_nil [Arm_types] |
|
| bin_shape_gpr_reg [Arm_types] |
|
| bin_shape_insn [Arm_types] |
|
| bin_shape_integer [Bap_c_type] |
|
| bin_shape_long [Bap_c_type] |
|
| bin_shape_long_long [Bap_c_type] |
|
| bin_shape_mem_insn [Arm_types] |
|
| bin_shape_mem_multi_insn [Arm_types] |
|
| bin_shape_move_insn [Arm_types] |
|
| bin_shape_mult_insn [Arm_types] |
|
| bin_shape_nil_reg [Arm_types] |
|
| bin_shape_no_qualifier [Bap_c_type] |
|
| bin_shape_non_nil_reg [Arm_types] |
|
| bin_shape_op [Arm_types] |
|
| bin_shape_qualifier [Bap_c_type] |
|
| bin_shape_real [Bap_c_type] |
|
| bin_shape_reg [Arm_types] |
|
| bin_shape_scalar [Bap_c_type] |
|
| bin_shape_short [Bap_c_type] |
|
| bin_shape_signed [Bap_c_type] |
|
| bin_shape_spec [Bap_c_type] |
|
| bin_shape_special_insn [Arm_types] |
|
| bin_shape_t [Bap_c_data] |
|
| bin_shape_t [Bap_c_type.Array] |
|
| bin_shape_t [Bap_c_type.Compound] |
|
| bin_shape_t [Bap_c_type.Proto] |
|
| bin_shape_t [Bap_c_type.Spec] |
|
| bin_shape_t [Bap_c_type.Attr] |
|
| bin_shape_t [Bap_c_type.Qualifier] |
|
| bin_shape_unsigned [Bap_c_type] |
|
| bin_shape_value [Bap_c_data] |
|
| bin_short [Bap_c_type] |
|
| bin_signed [Bap_c_type] |
|
| bin_size_aggregate [Bap_c_type] |
|
| bin_size_array [Bap_c_type] |
|
| bin_size_attr [Bap_c_type] |
|
| bin_size_basic [Bap_c_type] |
|
| bin_size_bits_insn [Arm_types] |
|
| bin_size_branch_insn [Arm_types] |
|
| bin_size_ccr_or_nil [Arm_types] |
|
| bin_size_ccr_reg [Arm_types] |
|
| bin_size_char [Bap_c_type] |
|
| bin_size_cint [Bap_c_type] |
|
| bin_size_complex [Bap_c_type] |
|
| bin_size_compound [Bap_c_type] |
|
| bin_size_cond [Arm_types] |
|
| bin_size_cv [Bap_c_type] |
|
| bin_size_cvr [Bap_c_type] |
|
| bin_size_enum [Bap_c_type] |
|
| bin_size_floating [Bap_c_type] |
|
| bin_size_gpr_or_nil [Arm_types] |
|
| bin_size_gpr_reg [Arm_types] |
|
| bin_size_insn [Arm_types] |
|
| bin_size_integer [Bap_c_type] |
|
| bin_size_long [Bap_c_type] |
|
| bin_size_long_long [Bap_c_type] |
|
| bin_size_mem_insn [Arm_types] |
|
| bin_size_mem_multi_insn [Arm_types] |
|
| bin_size_move_insn [Arm_types] |
|
| bin_size_mult_insn [Arm_types] |
|
| bin_size_nil_reg [Arm_types] |
|
| bin_size_no_qualifier [Bap_c_type] |
|
| bin_size_non_nil_reg [Arm_types] |
|
| bin_size_op [Arm_types] |
|
| bin_size_proto [Bap_c_type] |
|
| bin_size_qualifier [Bap_c_type] |
|
| bin_size_real [Bap_c_type] |
|
| bin_size_reg [Arm_types] |
|
| bin_size_scalar [Bap_c_type] |
|
| bin_size_short [Bap_c_type] |
|
| bin_size_signed [Bap_c_type] |
|
| bin_size_spec [Bap_c_type] |
|
| bin_size_special_insn [Arm_types] |
|
| bin_size_t [Bap_c_data] |
|
| bin_size_t [Bap_c_type.Array] |
|
| bin_size_t [Bap_c_type.Compound] |
|
| bin_size_t [Bap_c_type.Proto] |
|
| bin_size_t [Bap_c_type.Spec] |
|
| bin_size_t [Bap_c_type.Attr] |
|
| bin_size_t [Bap_c_type.Qualifier] |
|
| bin_size_t [Bap_c_type] |
|
| bin_size_unsigned [Bap_c_type] |
|
| bin_size_value [Bap_c_data] |
|
| bin_spec [Bap_c_type] |
|
| bin_special_insn [Arm_types] |
|
| bin_t [Bap_c_data] |
|
| bin_t [Bap_c_type.Array] |
|
| bin_t [Bap_c_type.Compound] |
|
| bin_t [Bap_c_type.Proto] |
|
| bin_t [Bap_c_type.Spec] |
|
| bin_t [Bap_c_type.Attr] |
|
| bin_t [Bap_c_type.Qualifier] |
|
| bin_t [Bap_c_type] |
|
| bin_unsigned [Bap_c_type] |
|
| bin_value [Bap_c_data] |
|
| bin_write_aggregate [Bap_c_type] |
|
| bin_write_array [Bap_c_type] |
|
| bin_write_attr [Bap_c_type] |
|
| bin_write_basic [Bap_c_type] |
|
| bin_write_bits_insn [Arm_types] |
|
| bin_write_branch_insn [Arm_types] |
|
| bin_write_ccr_or_nil [Arm_types] |
|
| bin_write_ccr_reg [Arm_types] |
|
| bin_write_char [Bap_c_type] |
|
| bin_write_cint [Bap_c_type] |
|
| bin_write_complex [Bap_c_type] |
|
| bin_write_compound [Bap_c_type] |
|
| bin_write_cond [Arm_types] |
|
| bin_write_cv [Bap_c_type] |
|
| bin_write_cvr [Bap_c_type] |
|
| bin_write_enum [Bap_c_type] |
|
| bin_write_floating [Bap_c_type] |
|
| bin_write_gpr_or_nil [Arm_types] |
|
| bin_write_gpr_reg [Arm_types] |
|
| bin_write_insn [Arm_types] |
|
| bin_write_integer [Bap_c_type] |
|
| bin_write_long [Bap_c_type] |
|
| bin_write_long_long [Bap_c_type] |
|
| bin_write_mem_insn [Arm_types] |
|
| bin_write_mem_multi_insn [Arm_types] |
|
| bin_write_move_insn [Arm_types] |
|
| bin_write_mult_insn [Arm_types] |
|
| bin_write_nil_reg [Arm_types] |
|
| bin_write_no_qualifier [Bap_c_type] |
|
| bin_write_non_nil_reg [Arm_types] |
|
| bin_write_op [Arm_types] |
|
| bin_write_proto [Bap_c_type] |
|
| bin_write_qualifier [Bap_c_type] |
|
| bin_write_real [Bap_c_type] |
|
| bin_write_reg [Arm_types] |
|
| bin_write_scalar [Bap_c_type] |
|
| bin_write_short [Bap_c_type] |
|
| bin_write_signed [Bap_c_type] |
|
| bin_write_spec [Bap_c_type] |
|
| bin_write_special_insn [Arm_types] |
|
| bin_write_t [Bap_c_data] |
|
| bin_write_t [Bap_c_type.Array] |
|
| bin_write_t [Bap_c_type.Compound] |
|
| bin_write_t [Bap_c_type.Proto] |
|
| bin_write_t [Bap_c_type.Spec] |
|
| bin_write_t [Bap_c_type.Attr] |
|
| bin_write_t [Bap_c_type.Qualifier] |
|
| bin_write_t [Bap_c_type] |
|
| bin_write_unsigned [Bap_c_type] |
|
| bin_write_value [Bap_c_data] |
|
| bin_writer [Regular.Std.Data] |
bin_writer (module T) returns a writer in binprot format.
|
| bin_writer_aggregate [Bap_c_type] |
|
| bin_writer_array [Bap_c_type] |
|
| bin_writer_attr [Bap_c_type] |
|
| bin_writer_basic [Bap_c_type] |
|
| bin_writer_bits_insn [Arm_types] |
|
| bin_writer_branch_insn [Arm_types] |
|
| bin_writer_ccr_or_nil [Arm_types] |
|
| bin_writer_ccr_reg [Arm_types] |
|
| bin_writer_char [Bap_c_type] |
|
| bin_writer_cint [Bap_c_type] |
|
| bin_writer_complex [Bap_c_type] |
|
| bin_writer_compound [Bap_c_type] |
|
| bin_writer_cond [Arm_types] |
|
| bin_writer_cv [Bap_c_type] |
|
| bin_writer_cvr [Bap_c_type] |
|
| bin_writer_enum [Bap_c_type] |
|
| bin_writer_floating [Bap_c_type] |
|
| bin_writer_gpr_or_nil [Arm_types] |
|
| bin_writer_gpr_reg [Arm_types] |
|
| bin_writer_insn [Arm_types] |
|
| bin_writer_integer [Bap_c_type] |
|
| bin_writer_long [Bap_c_type] |
|
| bin_writer_long_long [Bap_c_type] |
|
| bin_writer_mem_insn [Arm_types] |
|
| bin_writer_mem_multi_insn [Arm_types] |
|
| bin_writer_move_insn [Arm_types] |
|
| bin_writer_mult_insn [Arm_types] |
|
| bin_writer_nil_reg [Arm_types] |
|
| bin_writer_no_qualifier [Bap_c_type] |
|
| bin_writer_non_nil_reg [Arm_types] |
|
| bin_writer_op [Arm_types] |
|
| bin_writer_proto [Bap_c_type] |
|
| bin_writer_qualifier [Bap_c_type] |
|
| bin_writer_real [Bap_c_type] |
|
| bin_writer_reg [Arm_types] |
|
| bin_writer_scalar [Bap_c_type] |
|
| bin_writer_short [Bap_c_type] |
|
| bin_writer_signed [Bap_c_type] |
|
| bin_writer_spec [Bap_c_type] |
|
| bin_writer_special_insn [Arm_types] |
|
| bin_writer_t [Bap_c_data] |
|
| bin_writer_t [Bap_c_type.Array] |
|
| bin_writer_t [Bap_c_type.Compound] |
|
| bin_writer_t [Bap_c_type.Proto] |
|
| bin_writer_t [Bap_c_type.Spec] |
|
| bin_writer_t [Bap_c_type.Attr] |
|
| bin_writer_t [Bap_c_type.Qualifier] |
|
| bin_writer_t [Bap_c_type] |
|
| bin_writer_unsigned [Bap_c_type] |
|
| bin_writer_value [Bap_c_data] |
|
| binary [Bap_traces.Std.Meta] |
description of a target binary (executable) that was traced.
|
| binary [Monads.Std.Monad.S2.Lift] |
|
| binary [Monads.Std.Monad.S.Lift] |
|
| binary [Bap.Std.Project.Input] |
binary ?base arch ~filename create an input from a binary
file, that is a pure code.
|
| binary_file_stats [Bap_traces.Std.Meta] |
file stats of the traced binary
|
| bind [Monads.Std.Monad.Minimal2] |
|
| bind [Monads.Std.Monad.Minimal] |
|
| bind [Monads.Std.Monad.Basic2] |
bind m f passes the result of computation m to function f
|
| bind [Monads.Std.Monad.Basic] |
bind m f passes the result of computation m to function f
|
| bindir [Bap_config] |
|
| binop [Bap_primus.Std.Primus.Interpreter.Make] |
binop op x y computes a binary operation op on x and y .
|
| binop [Bap_primus.Std.Primus.Interpreter] |
binop ((op,x,y),r) happens after the binary operation op
is applied to values x and y and evaluates to r
|
| binop [Bap.Std.Bil.Apply] |
binop op x y applies the binary operation op to x and
y .
|
| binop [Bap.Std.Bil] |
binop op x y -> BinOp(op,x,y)
|
| bit_and [Bap.Std.Bil] |
|
| bit_extract [Arm_bit] |
|
| bit_field_insert [Arm_bit] |
|
| bit_or [Bap.Std.Bil] |
|
| bit_xor [Bap.Std.Bil] |
|
| bitlen [Arm_utils] |
|
| bits_insn_of_sexp [Arm_types] |
|
| bitwidth [X86_asm_reg] |
bitwidth reg_type returns the width in bits of the
given reg_type
|
| bitwidth [Bap_primus.Std.Primus.Value.Make] |
bitwidth is lift1 Word.bitwidth
|
| bitwidth [Bap.Std.Bitvector] |
bitwidth bv return a bit-width, i.e., the amount of bits
|
| blit [Regular.Std.Bytes.To_string] |
|
| blit_to_bigstring [Regular.Std.Data.Write] |
blit_to_bigstring writeable buf value pos copies a
serialized representation of the value into existing
bigstring buf , starting from the given position.
|
| blit_to_bigstring [Regular.Std.Data.S] |
blit_to_bigstring ?ver ?fmt buffer datum offset copies a
serialized representation of datum into a buffer , starting from
offset .
|
| blit_to_bytes [Regular.Std.Data.Write] |
blit_to_bytes writeable buf value pos copies a serialized
representation of the value into existing buffer buf ,
starting from the given position.
|
| blit_to_bytes [Regular.Std.Data.S] |
blit_to_bytes ?ver ?fmt buffer datum offset copies a
serialized representation of datum into a buffer , starting from
the offset .
|
| blit_to_string [Regular.Std.Data.Write] |
blit_to_string writeable buf value pos copies a serialized
representation of the value into existing string buf ,
starting from the given position.
|
| blito [Regular.Std.Bytes.To_string] |
|
| blk [Bap_primus.Std.Primus.Interpreter.Make] |
blk x interprets the block x .
|
| blk_t [Bap.Std] |
|
| bool [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| bool [Ogre.Query] |
bool x creates a logic constant
|
| bool [Ogre.Type] |
bool is either true or false .
|
| bool [Bap.Std.Self.Config] |
bool converts values with bool_of_string .
|
| bool_t [Bap.Std] |
|
| branch_insn_of_sexp [Arm_types] |
|
| build [Bap_strings_unscrambler.Make] |
build d chars returns a sequence of all words in the
dictionary d that could be built from the sequence of characters chars
|
| bundle [Bap_plugins.Std.Plugin] |
bundle plugin returns a plugin's bundle
|
| by_given_order [Graphlib.Std.Graphlib] |
|
| by_natural_order [Graphlib.Std.Graphlib] |
|
| byte [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| byte [Bap_primus.Std.Primus.Generator.Random.Seeded] |
byte is the same as lcg ~min:0 ~max:255 ()
|
| byte [Bap_primus.Std.Primus.Generator.Random] |
byte seed the same as lcg ~min:0 ~max:255 seed
|
C |
| c [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| call [Bap_traces.Std.Event] |
a control flow transfer from one procedure to another has occured
|
| call [Bap_primus.Std.Primus.Linker.Trace] |
occurs when a subroutine is called.
|
| call [Monads.Std.Monad.Cont.S2] |
|
| call [Monads.Std.Monad.Cont.S] |
call ~f calls f ~cc with the current continuation cc .
|
| call [Bap.Std.Insn] |
the instruction is a call to subroutine.
|
| call_entered [Bap_primus.Std.Primus.Linker.Trace] |
the statement that makes call observations.
|
| call_returned [Bap_primus.Std.Primus.Linker.Trace] |
the statement that makes return observations
|
| capitalize [Regular.Std.Bytes] |
capitalize t returns a copy of t , with the first byte set
to uppercase.
|
| case [Bap.Std.Value.Match] |
case tag action matcher adds an action to matcher that
will be invoked for values with a a given tag
|
| cast [Bap_primus.Std.Primus.Interpreter.Make] |
cast t n x casts n bits of x using a casting type t
|
| cast [Bap_primus.Std.Primus.Interpreter] |
cast ((t,x),r) happens after x is casted to r using
the casting type t
|
| cast [Bap.Std.Bil.Apply] |
cast t s x casts x using the cast type t to the given
size s .
|
| cast [Bap.Std.Bil] |
cast t w x -> Cast (t,w,x)
|
| cast_of_sign [Arm_utils] |
|
| cat [Regular.Std.Bytes] |
cat s1 s2 concatenates s1 and s2 and returns the result
as new byte sequence.
|
| cata [Bap.Std.Term] |
cata cls ~init t ?case performs a pattern matching.
|
| catch [Bap_primus.Std.Primus.Machine.S] |
catch x f creates a computation that is equal to x if
it terminates normally, and to f e if x terminates
abnormally with the exception e .
|
| catch [Monads.Std.Monad.Fail.S2] |
catch m f if m diverges with some bottom value err ,
the f err is a result of the whole computation, otherwise
returns m .
|
| catch [Monads.Std.Monad.Fail.S] |
catch m f if m diverges with some bottom value err ,
the f err is a result of the whole computation, otherwise
returns m .
|
| ccr_or_nil_of_sexp [Arm_types] |
|
| ccr_reg_of_sexp [Arm_types] |
|
| cf [X86_env] |
|
| cf [Arm_env] |
|
| cf [Bap.Std.CPU] |
|
| cfg [Bap.Std.Project.Info] |
occurs everytime a whole program control flow graph is changed
|
| cfg [Bap.Std.Disasm] |
|
| cfg [Bap.Std.Disasm_expert.Recursive] |
cfg t returns a control flow graph, representing the code
in the input region of memory.
|
| chain [Bap.Std.Symbolizer] |
chain ss creates a symbolizer, that will try to resolve
an address using each symbolizer in order.
|
| change [Bap.Std.Label] |
|
| change [Bap.Std.Term] |
change t p id f if p contains subterm with of a given kind
t and identifier id , then apply f to this
subterm.
|
| change [Bap.Std.Table] |
change tab mem ~f function f is applied to a set of all memory
regions that intersects with mem .
|
| change [Bap.Std.Dict] |
change map tag f changes value.
|
| change [Bap.Std.Trie.S] |
change trie key f if trie has data associated with key then
f will be called with Some data , otherwise it will be called
with None .
|
| char [Bap.Std.Self.Config] |
char converts values by ensuring the argument has a single char.
|
| char_of_sexp [Bap_c_type] |
|
| chars [Bap_strings_detector] |
|
| check [Bap_primus.Std.Primus.Lisp.Type] |
check env prog type checks program in the environment
env and returns a list of errors.
|
| check [Bap.Std.Type] |
check bil is Ok () if bil is well-typed, otherwise the
first type error e is returned as Error e .
|
| children [Graphlib.Std.Tree] |
children tree x returns all immediate successors of node
x .
|
| cint_of_sexp [Bap_c_type] |
|
| clear [Ogre.Doc] |
clear doc removes all facts from the document.
|
| clone [Bap.Std.Term] |
clone term creates an object with a fresh new identifier
that has the same contents as term , i.e., that is
syntactically the same.
|
| close [Bap_ida.Std.Ida] |
close ida finish interaction with IDA and clean all resources
|
| close [Bap.Std.Disasm_expert.Basic] |
close d closes a disassembler d .
|
| code [Bap.Std.Project.Info] |
occurs once code segment is discovered
|
| code [Bap.Std.Disasm_expert.Basic.Insn] |
code insn returns an integer code, that is bijective
with instruction opcode.
|
| code [Bap.Std.Reg] |
unique number representing a register
|
| code_exec [Bap_traces.Std.Event] |
CPU loaded this memory chunk for execution.
|
| code_start [Bap.Std.Image.Scheme] |
code_start addr an address starts a code sequence
|
| collect [Ogre.S] |
collect query is the same as foreach query ~f:ident
|
| color [Bap.Std] |
Color something with a color
|
| comment [Bap.Std] |
|
| compare [Bap_strings_index.Key] |
|
| compare [Bap_c_data] |
|
| compare [Bap_c_type.Array] |
|
| compare [Bap_c_type.Compound] |
|
| compare [Bap_c_type.Proto] |
|
| compare [Bap_c_type.Spec] |
|
| compare [Bap_c_type.Attr] |
|
| compare [Bap_c_type.Qualifier] |
|
| compare [Bap_c_type] |
|
| compare [Graphlib.Std.Graphlib] |
compare (module G1) (module G2) g1 g2 compares two graphs,
with different implementation but the same node type.
|
| compare [Regular.Std.Seq] |
|
| compare [Bap.Std.Disasm_expert.Basic.Insn] |
compare i1 i2 compares instruction i1 and i2
|
| compare [Bap.Std.Op.Normalized] |
|
| compare_aggregate [Bap_c_type] |
|
| compare_array [Bap_c_type] |
|
| compare_attr [Bap_c_type] |
|
| compare_basic [Bap_c_type] |
|
| compare_bits_insn [Arm_types] |
|
| compare_branch_insn [Arm_types] |
|
| compare_ccr_or_nil [Arm_types] |
|
| compare_ccr_reg [Arm_types] |
|
| compare_char [Bap_c_type] |
|
| compare_cint [Bap_c_type] |
|
| compare_complex [Bap_c_type] |
|
| compare_compound [Bap_c_type] |
|
| compare_cond [Arm_types] |
|
| compare_cv [Bap_c_type] |
|
| compare_cvr [Bap_c_type] |
|
| compare_enum [Bap_c_type] |
|
| compare_floating [Bap_c_type] |
|
| compare_gpr_or_nil [Arm_types] |
|
| compare_gpr_reg [Arm_types] |
|
| compare_insn [Arm_types] |
|
| compare_integer [Bap_c_type] |
|
| compare_long [Bap_c_type] |
|
| compare_long_long [Bap_c_type] |
|
| compare_mem_insn [Arm_types] |
|
| compare_mem_multi_insn [Arm_types] |
|
| compare_move_insn [Arm_types] |
|
| compare_mult_insn [Arm_types] |
|
| compare_nil_reg [Arm_types] |
|
| compare_no_qualifier [Bap_c_type] |
|
| compare_non_nil_reg [Arm_types] |
|
| compare_op [Arm_types] |
|
| compare_ops [Bap.Std.Op.Normalized] |
|
| compare_proto [Bap_c_type] |
|
| compare_qualifier [Bap_c_type] |
|
| compare_real [Bap_c_type] |
|
| compare_reg [Arm_types] |
|
| compare_scalar [Bap_c_type] |
|
| compare_short [Bap_c_type] |
|
| compare_signed [Bap_c_type] |
|
| compare_spec [Bap_c_type] |
|
| compare_special_insn [Arm_types] |
|
| compare_unsigned [Bap_c_type] |
|
| compare_value [Bap_c_data] |
|
| compare_with [Bap.Std.Memory] |
compare_with mem addr compares memory with addr
|
| complex_of_sexp [Bap_c_type] |
|
| compose [Monads.Std.Monad.S2.Fn] |
compose f g creates a composition f.g of two
function.
|
| compose [Monads.Std.Monad.S.Fn] |
compose f g creates a composition f.g of two
function.
|
| compound_of_sexp [Bap_c_type] |
|
| compute [Bap.Std.Eff] |
|
| concat [Bap_primus.Std.Primus.Interpreter.Make] |
concat x y computes a concatenation of x and y
|
| concat [Bap_primus.Std.Primus.Interpreter] |
extract ((x,y),z) happens after x is concatenated with y
and produces z as a result.
|
| concat [Bap_primus.Std.Primus.Value.Make] |
concat is lift2 Word.concat
|
| concat [Bap_future.Std.Stream] |
concat ss returns a stream that will produce elements from
the input list of streams ss .
|
| concat [Monads.Std.Monoid.S] |
concat xs reduces xs to using plus
|
| concat [Regular.Std.Bytes] |
concat sep sl concatenates the list of byte sequences sl ,
inserting the separator byte sequence sep between each, and
returns the result as a new byte sequence.
|
| concat [Bap.Std.Bil] |
concat x y -> Concat (x,y)
|
| concat [Bap.Std.Bitvector] |
concat b1 b2 concatenates two bitvectors
|
| concat_map [Bap.Std.Term] |
concat_map t p ~f substitute subterm c of type t in
parent term p with f c .
|
| concat_merge [Bap_future.Std.Stream] |
concat_merge xs ~f builds a stream, that will
produce elements from the input list and applies f to all
consecutive elements.
|
| cond [Bap.Std.Jmp] |
cond jmp returns the jump guard condition
|
| cond [Bap.Std.Graphs.Ir.Edge] |
cond e g computes a condition expression that is
asserted to be true if this branch is taken.
|
| cond_of_sexp [Arm_types] |
|
| conditional [Bap.Std.Insn] |
under some dynamic condition the instruction may perform a
non-regular control flow
|
| confdir [Bap_config] |
|
| confdir [Bap.Std.Self.Config] |
A directory for bap specific configuration files
|
| cons [Regular.Std.Seq] |
|
| const [Bap_primus.Std.Primus.Interpreter.Make] |
const x computes the constant expression x
|
| const [Bap_primus.Std.Primus.Interpreter] |
const x happens when a constant x is created
|
| const [Bap.Std.Sub] |
A subroutine doesn't examine any values except its arguments,
and have no effects except the return value.
|
| contains [Regular.Std.Bytes] |
contains s c tests if byte c appears in s .
|
| contains [Bap.Std.Memmap] |
contains map addr true if there exists such memory region mem ,
that Memory.contains mem addr
|
| contains [Bap.Std.Memory] |
contains mem addr returns true if mem contains address addr
|
| contains [Bap.Std.Interval_tree.S] |
contains t p is true if p belongs to at least one
interval in t
|
| contains_from [Regular.Std.Bytes] |
contains_from s start c tests if byte c appears in s after
position start .
|
| context_switch [Bap_traces.Std.Event] |
operating system has performed context switching to a provided
thread (process) id.
|
| converter [Bap.Std.Self.Config] |
|
| copy [Regular.Std.Bytes] |
copy t returns a new byte sequence that contains the same
bytes as t .
|
| count [Monads.Std.Monad.Collection.S] |
count xs ~f returns a computation that results to a
number of elements of xs for which f evaluates to
true .
|
| count [Monads.Std.Monad.Collection.S2] |
count xs ~f returns a computation that results to a
number of elements of xs for which f evaluates to
true .
|
| count [Bap.Std.Table] |
count ~start ~until ~f table returns the number of elements
table that satisfy the predicate p
|
| count [Bap.Std.Memory_iterators] |
count ~word_size ~f t is the number of elements in t
that satisfies the predicate f .
|
| cpsr [Arm_env] |
cpsr Current Processor Status Register
|
| cpuexn [Bap.Std.Bil] |
cpuexn number -> CpuExn number
|
| create [Bap_strings_detector] |
create alphabet creates a detector.
|
| create [Bap_traces.Std.Trace.Monitor] |
create filter creates a user defined monitor from function
filter that is applied to a sequence of events or errors, and
returns a sequence of events.
|
| create [Bap_traces.Std.Trace] |
create tool next creates a new trace from the observer
next .
|
| create [Bap_ida.Std.Command] |
create lang ~script ~parser create a command that will
execute a script , written in a given language, at then
parse the output using the specified parser function.
|
| create [Bap_ida.Std.Ida] |
create target create an IDA instance that will work with
target executable.
|
| create [Bap_dwarf.Std.Dwarf.Fbi] |
create data tries to create a DWARF reader, from
supplied data .
|
| create [Bap_dwarf.Std.Dwarf.Data] |
create endian sections creates data representation from a assoc list
of sections.
|
| create [Bap_dwarf.Std.Dwarf.Buffer] |
|
| create [Bap_demangle.Std.Demangler] |
|
| create [Bap_byteweight.S] |
create () creates an empty instance of the byteweigth decider.
|
| create [Bap_c_abi.Stack] |
stack = create ?growsup arch is a function that returns
n 'th stack slot
|
| create [Arm_reg] |
lifts basic register to a ARM one
|
| create [Arm_cond] |
decodes condition value from a word
|
| create [Arm_op] |
create op projects bap generic operand into arm specific.
|
| create [Arm_insn] |
create insn translate from BAP insn
|
| create [Bap_primus.Std.Primus.Lisp.Primitive] |
|
| create [Bap_primus.Std.Primus.Generator.Random.Seeded] |
create init creates a self-seeded generator from a
regular generator.
|
| create [Bap_primus.Std.Primus.Generator] |
create (module Iterator) seed creates a integer generator
from the provided Iterator , and initializes it with the
given seed.
|
| create [Bap_taint.Std.Taint.Object.Make] |
create kind creates a fresh new object identifier with
the specified kind .
|
| create [Bap_taint.Std.Taint.Kind.Make] |
create name creates a kind with the given name.
|
| create [Graphlib.Std.Edge] |
create x y l creates an edge connecting nodes x and y
labeled with a a given label l
|
| create [Graphlib.Std.Node] |
create label creates a new node, and associates it with a
a given label .
|
| create [Graphlib.Std.Graphlib] |
create (module G) ~nodes ~edges () creates a graph using
implementation provided by module G .
|
| create [Graphlib.Std.Solution] |
create constraints default creates an initial approximation of a
solution.
|
| create [Bap_future.Std.Stream] |
create () retuns a stream and a signal handler that is used
to feed the stream.
|
| create [Bap_future.Std.Future] |
create () creates a new future.
|
| create [Regular.Std.Bytes] |
create n returns a new byte sequence of length n .
|
| create [Regular.Std.Data.Cache.Digest] |
create ~namespace create a digest initialized with the
given namespace .
|
| create [Regular.Std.Data.Cache] |
create ~load ~save creates a cache provider.
|
| create [Regular.Std.Data.Write] |
create <minimal-implementation> creates a writable
instance from a provided minimal implementation.
|
| create [Regular.Std.Data.Read] |
A minimal complete definition is any method except
of_channel (that is not sufficient).
|
| create [Bap_bundle.Std.Bundle.Builder] |
create () creates a builder.
|
| create [Bap_bundle.Std.Manifest] |
create name create a bundle for a program with a given name
|
| create [Bap.Std.Project.Input] |
create arch filename ~code ~data creates an input from a
file, using two memory maps.
|
| create [Bap.Std.Project] |
from_file filename creates a project from a provided input
source.
|
| create [Bap.Std.Reconstructor] |
create f creates a reconstructor from a given function f
|
| create [Bap.Std.Brancher] |
create resolve creates a brancher from resolve function,
that accepts a memory region, occupied by an instruction, the
instruction itself and returns a list of destination.
|
| create [Bap.Std.Rooter] |
create seq creates a rooter from a given sequence of addresses
|
| create [Bap.Std.Symbolizer] |
create fn creates a symbolizer for a given function
|
| create [Bap.Std.Label] |
create () creates a new label with a freshly generated
identifier.
|
| create [Bap.Std.Call] |
create ?return ~target () creates a call to the target
subroutine.
|
| create [Bap.Std.Arg] |
create ?intent var exp creates an argument.
|
| create [Bap.Std.Phi] |
create var label exp creates a phi-node that associates a
variable var with an expression exp .
|
| create [Bap.Std.Jmp] |
create ?cond kind creates a jump of a given kind
|
| create [Bap.Std.Def] |
create ?tid x exp creates definition x := exp
|
| create [Bap.Std.Blk.Builder] |
create ~tid ~phis ~defs ~jmp () creates a block builder.
|
| create [Bap.Std.Blk] |
create () creates a new empty block.
|
| create [Bap.Std.Sub.Builder] |
initializes empty subroutine builder.
|
| create [Bap.Std.Sub] |
create ?name () creates an empty subroutine with an optional
name.
|
| create [Bap.Std.Program.Builder] |
|
| create [Bap.Std.Program] |
create ?tid () creates an empty program.
|
| create [Bap.Std.Tid] |
create () creates a fresh newly term identifier
|
| create [Bap.Std.Disasm] |
|
| create [Bap.Std.Block] |
create mem insn creates a block
Preconditions: insns <> []
|
| create [Bap.Std.Disasm_expert.Basic] |
create ?debug_level ?cpu ~backend target creates a
disassembler for the specified target .
|
| create [Bap.Std.Image] |
create ?backend filename creates an image of the file specified
specified by the filename .
|
| create [Bap.Std.Memory] |
create ?pos ?len endian start data creates a memory region.
|
| create [Bap.Std.Vector] |
create ?capacity default creates an empty vector with a a given
capacity .
|
| create [Bap.Std.Value] |
create cons x creates a value using constructor cons and
argument x
|
| create [Bap.Std.Var] |
create ?register ?fresh name typ creates a variable with
a given name and typ e.
|
| create [Bap.Std.Trie.S] |
create () creates new empty trie
|
| create_api_processor [Bap_c_abi] |
create_api_processor size t packs an api processor.
|
| create_call [Bap.Std.Jmp] |
create_call ?cond target transfer control to subroutine
target
|
| create_goto [Bap.Std.Jmp] |
create_goto ?cond label local jump
|
| create_int [Bap.Std.Jmp] |
create_int ?cond int_number return call interrupt subroutine
|
| create_ret [Bap.Std.Jmp] |
create_ret ?cond label return from a procedure
|
| create_scheme [Graphlib.Std.Graphlib] |
create_scheme ~next init create a name generator, that will
start with init and apply next on it infinitly.
|
| cs [X86_env] |
|
| current [Monads.Std.Monad.State.Multi.S2] |
current id returns an identifier of current state.
|
| current [Monads.Std.Monad.State.Multi.S] |
current id returns an identifier of current state.
|
| cv_of_sexp [Bap_c_type] |
|
| cvr_of_sexp [Bap_c_type] |
|
D |
| d [Bap_primus.Std.Primus.Lisp.Type.Spec] |
|
| data [Bap_strings_detector] |
|
| data [Bap_dwarf.Std.Dwarf.Buffer] |
|
| data [Bap_c_abi] |
data size t creates an abstraction of data that is represented
by type t .
|
| data [Bap_c_term_attributes] |
Abstraction of a data representation of C value.
|
| data [Bap_primus.Std.Primus.Observation.Provider] |
a data stream from this observation
|
| data [Bap.Std.Project.Info] |
occurs once input memory is loaded
|
| data [Bap.Std.Image] |
data image returns image data.
|
| data [Bap.Std.Dict] |
data dict is a sequence of all dict elements
|
| datadir [Bap_config] |
|
| datadir [Bap.Std.Self.Config] |
A directory for bap specific read-only architecture
independent data files.
|
| datarootdir [Bap_config] |
|
| dead [Bap.Std.Term] |
a term is identified as dead
|
| debug [Bap_config] |
|
| debug [Bap.Std.Self] |
debug fmt ... send a debug message
|
| debug_formatter [Bap.Std.Self] |
formatter that sends debug messages
|
| decision [Bap_strings_detector] |
|
| declarations [Ogre.Doc] |
declarations doc returns a number of declarations in the
document
|
| declare [Bap_primus.Std.Primus.Machine.State] |
declare ~inspect ~uuid ~name make declares a state with
the given uuid and name .
|
| declare [Ogre] |
let attr () = declare ~name scheme declares an attribute named
with name , and having a type described by the scheme .
|
| decode [X86_asm_reg] |
decode reg decodes the given reg provided by the
disassembler as an x86 register if that is feasible.
|
| def [Ogre.Type] |
def name t defines a field with the give name and type t .
|
| def_t [Bap.Std] |
|
| default [Graphlib.Std.Solution] |
default s return the default value assigned to all variables
not in the internal finite mapping.
|
| default [Bap.Std.Reconstructor] |
default name roots builds a reconstructor from a given
function, that maps addresses to function names (see
Std.Symbolizer ) and a list of known function starts.
|
| default [Bap.Std.Value.Match] |
default def creates an empty matcher with default handler def .
|
| default_path [Bap_byteweight_signatures] |
default path for the signatures database
|
| default_printer [Regular.Std.Data.S] |
default_writer optionally returns an information about
default printer
|
| default_reader [Regular.Std.Data.S] |
default_reader returns information about default reader
|
| default_writer [Regular.Std.Data.S] |
default_writer returns information about the default writer
|
| define [Bap_primus.Std.Primus.Lisp.Make] |
define ?docs name code defines a lisp primitive with
the given name and an optional documentation string
doscs .
|
| defines_var [Bap.Std.Blk] |
defines_var blk x true if there exists such phi term or def
term with left hand side equal to x
|
| definitions [Ogre.Doc] |
definitions doc returns a number of facts, defined in the
document.
|
| defs [Bap_primus.Std.Primus.Lisp.Primitives] |
|
| degree [Graphlib.Std.Node] |
degree ?dir n when in_or_out is `In then returns
the amount of incomming edges, otherwise returns the amount of
outcomming edges.
|
| del [Bap.Std.Project] |
del project attr removes an attribute from a project
|
| del_attr [Bap.Std.Term] |
del_attr term attr deletes attribute attr from term
|
| deprecated [Bap.Std.Self.Config] |
Default deprecation warning message, for easy deprecation of
parameters.
|
| depth_first_search [Graphlib.Std.Graphlib] |
depth_first_search (module G) ~init g .
|
| depth_first_visit [Graphlib.Std.Graphlib] |
depth_first_visit (module G) ~init visitor g allows to
specify visiting functions using object.
|
| derive [Graphlib.Std.Solution] |
derive s ~f default creates a new solution from an old one
with a new default and where for each node n in s 's finite
map, if f n (get s n) = Some v then n maps to v .
|
| desc [Bap_plugins.Std.Plugin] |
desc plugin returns plugin description
|
| descendants [Graphlib.Std.Tree] |
descendants tree n returns a set of all descendants of a given
node n .
|
| detach [Bap_taint.Std.Taint.Tracker.Make] |
detach v r xs removes all relations of type r between
the value v and elements of the set of objects
xs .
|
| determined [Bap.Std.Self.Config] |
Provides a future determined on when the config can be read
|
| df [X86_env] |
|
| digest [Regular.Std.Data.Cache] |
digest ~namespace fmt x y z ... a variadic function to
create data digests.
|
| dir [Bap.Std.Self.Config] |
dir converts a value with the identity function and checks
with Sys.file_exists and Sys.is_directory
that a directory with that name exists.
|
| direct [Bap_taint.Std.Taint.Rel] |
|
| direct [Bap.Std.Label] |
direct label creates a direct label with a given identifier.
|
| disasm [Bap.Std.Project] |
disasm project returns results of disassembling
|
| discrete [Graphlib.Std.Partition] |
discrete s returns the partition with one class per element of s
|
| div [Bap_primus.Std.Primus.Value.Make] |
|
| div [Bap.Std.Integer.Base] |
|
| divide [Bap.Std.Bil] |
|
| division_by_zero [Bap_primus.Std.Primus.Interpreter] |
division_by_zero occurs just before the division by zero trap
is signaled.
|
| division_by_zero_handler [Bap_primus.Std.Primus.Interpreter] |
division_by_zero_hanlder is a trap handler for
the Division_by_zero exception.
|
| doc [Bap.Std.Self] |
A short, one-line description
|
| doc_enum [Bap.Std.Self.Config] |
doc_enum l documents the possible string names in the l
map according to the number of alternatives.
|
| docdir [Bap_config] |
|
| dom_frontier [Graphlib.Std.Graphlib] |
dom_frontier (module G) g dom_tree calculates dominance
frontiers for all nodes in a graph g .
|
| dominates [Bap.Std.Memmap] |
dominates map mem if there is a non empty set of dominators
|
| dominates [Bap.Std.Interval_tree.S] |
dominates t k is true iff all intervals in t are
included in k .
|
| dominators [Graphlib.Std.Graphlib] |
dominators (module G) g entry builds a dominators tree for
a given graph.
|
| dominators [Bap.Std.Symtab] |
dominators syms mem returns a list of functions that
dominates over provided memory region mem
|
| dominators [Bap.Std.Memmap] |
dominators map mem an ordered sequence of all memory regions,
containing mem .
|
| dominators [Bap.Std.Interval_tree.S] |
dominators t k returns all intervals and their associated
values that include k .
|
| ds [X86_env] |
|
| dst [Graphlib.Std.Edge] |
dst e returns a destination of an edge e
|
| dump [Regular.Std.Data.S.Io] |
dump ?ver ?fmt chan stream dumps a stream (represented
by a next function) into channel.
|
| dvidir [Bap_config] |
|
E |
| edge [Graphlib.Std.Predicate] |
|
| edge [Graphlib.Std.Node] |
edge x y g if graph g has an edge between nodes x and
y then it is returned.
|
| edges [Graphlib.Std.Graph] |
edges g returns all edges of graph g in an unspecified order
|
| edges [Graphlib.Std.Path] |
edges p a sequence of edges from start to finish
|
| edges [Bap.Std.Graphs.Ir.Edge] |
edges dir e g enumerates all edges occurring before of
after an edge e in graph g
|
| edges_rev [Graphlib.Std.Path] |
edges_rev p a reversed sequence from finish to start
|
| either [Bap_future.Std.Stream] |
either xs ys is a discriminated union of two streams.
|
| elements [Bap.Std.Table] |
elements table returns in an ascending order of addresses all
elements mapped in a table
|
| elts [Bap.Std.Blk] |
elts ~rev blk return all elements of the blk .
|
| embed_manifest [Bap_bundle.Std.Bundle.Builder] |
embed_manifest builder manifest embeds a manifest.
|
| empty [Bap_strings_unscrambler.Make] |
an empty unscrambler that doesn't know any words
|
| empty [Bap_strings_index.Persistent.S] |
|
| empty [Graphlib.Std.Graph] |
|
| empty [Ogre.Doc] |
empty creates an empty document
|
| empty [Regular.Std.Bytes] |
empty a byte sequence of size 0.
|
| empty [Bap.Std.Symbolizer] |
empty is a symbolizer that knows nothing.
|
| empty [Bap.Std.Symtab] |
|
| empty [Bap.Std.Memmap] |
|
| empty [Bap.Std.Table] |
|
| empty [Bap.Std.Dict] |
|
| empty [Bap.Std.Interval_tree.S] |
empty x an empty interval tree
|
| endian [Bap_dwarf.Std.Dwarf.Data] |
endian data the endianness of data
|
| endian [Bap.Std.Image] |
endian image same as Arch.endian (Image.arch image)
|
| endian [Bap.Std.Memory] |
returns the order of bytes in a word
|
| endian [Bap.Std.Arch] |
endian arch returns a word endianness of the arch
|
| enter_arg [Bap_primus.Std.Primus.Interpreter] |
a subroutine argument is entered
|
| enter_blk [Bap_primus.Std.Primus.Interpreter] |
|
| enter_def [Bap_primus.Std.Primus.Interpreter] |
|
| enter_exp [Bap_primus.Std.Primus.Interpreter] |
an expression was entered
|
| enter_jmp [Bap_primus.Std.Primus.Interpreter] |
|
| enter_phi [Bap_primus.Std.Primus.Interpreter] |
|
| enter_pos [Bap_primus.Std.Primus.Interpreter] |
new program locatio entered
|
| enter_sub [Bap_primus.Std.Primus.Interpreter] |
|
| enter_term [Bap_primus.Std.Primus.Interpreter] |
an identifier of a term that will be executed next.
|
| entry_point [Bap.Std.Sub] |
a subroutine is the binary entry point
|
| entry_point [Bap.Std.Image.Scheme] |
entry_point addr an address is a program entry point
|
| entry_point [Bap.Std.Image] |
entry_point addr is an address from which a kernel should start
|
| enum [Bap_traces.Std.Traces] |
enum () enumerates all currently loaded traces
|
| enum [Graphlib.Std.Group] |
enum group enumerates all elements of a group, including the
designated one.
|
| enum [Graphlib.Std.Frontier] |
enum f x enumerates frontier of x
|
| enum [Core_printers] |
|
| enum [Bap.Std.Self.Config] |
enum l converts values such that unambiguous prefixes of
string names in l map to the corresponding value of type 'a .
|
| enum [Bap.Std.Term] |
enum ?rev t p enumerate all subterms of type t of the
a given term p
|
| enum_bits [Bap.Std.Bitvector] |
enum_bits x order returns bits of x in a specified order .
|
| enum_bytes [Bap.Std.Bitvector] |
enum_bytes x order returns a sequence of bytes of x in a
specified order .
|
| enum_chars [Bap.Std.Bitvector] |
enum_bytes x order returns bytes of x in a specified order ,
with bytes represented by char type
|
| enum_of_sexp [Bap_c_type] |
|
| envp [Bap_primus.Std.Primus.Machine.S] |
envp program environment variables.
|
| eq [Bap.Std.Bil] |
|
| equiv [Graphlib.Std.Partition] |
equiv p x y is true of x and y belongs to the same
equivalence class (i.e., to the same group).
|
| error [Bap.Std.Self] |
error fmt ... send an error message
|
| error_formatter [Bap.Std.Self] |
formatter that sends error messages
|
| errors [Bap.Std.Disasm_expert.Recursive] |
errors disasm returns a list of non-critical errors, that
happened during the disassembly (e.g., unknown opcodes and
unlifted instructions.
|
| es [X86_env] |
|
| escaped [Regular.Std.Bytes] |
escaped t returns a copy of t , with special characters
represented by escape sequences, following the lexical
conventions of OCaml.
|
| eval [Ogre.S] |
eval property document makes an inference of a property based
on facts stored in a document .
|
| eval [Monads.Std.Monad.State] |
eval m is the same as run m >>| fst , i.e., it runs the
computation and returns the computed value.
|
| eval [Bap.Std.Stmt] |
eval prog eval BIL program under given context.
|
| eval [Bap.Std.Exp] |
eval x evaluate expression x to a value.
|
| eval_cond [Bap_primus.Std.Primus.Interpreter] |
eval_cond v occurs every time the cond part of a jump is
evaluated.
|
| eval_fun [Bap_primus.Std.Primus.Lisp.Make] |
eval_fun name args calls a lisp function with the given
name , that is the most specific to the current context
and is applicable to the specified list of arguments.
|
| eval_method [Bap_primus.Std.Primus.Lisp.Make] |
eval_method name args invokes all methods with the given
name that are applicable in the current context to the
specified list of arguments.
|
| events [Bap_plugins.Std.Plugins] |
plugin subsystem event stream.
|
| exec [Bap_ida.Std.Ida] |
exec ida command execute the given command .
|
| exec [Arm_utils] |
|
| exec [Bap_primus.Std.Primus.Linker.Code] |
|
| exec [Bap_primus.Std.Primus.Linker.Make] |
exec name executes a code fragment associated with the
given name.
|
| exec [Bap_primus.Std.Primus.Linker] |
occurs before a piece of code is executed
|
| exec [Ogre.S] |
exec op doc executes an operation op that, presumabely,
updates the document doc , returns an updated version.
|
| exec [Monads.Std.Monad.State] |
exec m is the same as run m >>| snd , i.e., it runs the
computation and returns the final state.
|
| exec [Monads.Std.Monad.Writer.S] |
exec m executes computation m and reads the state
|
| exec_prefix [Bap_config] |
|
| executable [Bap.Std.Image.Scheme] |
|
| exists [Monads.Std.Monad.Collection.S] |
exists xs ~f returns a computation that results in
true iff there exists an element x in xs such that
f x evaluates to true
|
| exists [Monads.Std.Monad.Collection.S2] |
exists xs ~f returns a computation that results in
true iff there exists an element x in xs such that
f x evaluates to true
|
| exists [Bap.Std.Table] |
exists ~start ~until ~f table checks if at least one
element of table satisfies the predicate f .
|
| exists [Bap.Std.Memory_iterators] |
exists ~word_size ~f t checks if at least one element of t
satisfies the predicate f
|
| exists [Bap.Std.Stmt] |
exists finder stmt is true iff find finder stmt <> None .
|
| exists [Bap.Std.Exp] |
exists finder exp is true if finder finds
something.
|
| existsi [Bap.Std.Table] |
existsi ~start ~until ~f table is like Std.Table.exists , but
also passes the memory as an argument.
|
| exn [Bap_traces.Std.Event] |
a software exception has occured.
|
| exn_raised [Bap_primus.Std.Primus.Machine] |
exn_raised exn occurs every time an abnormal control flow
is initiated
|
| exp [Bap_primus.Std.Primus.Interpreter.Make] |
exp x returns a value of x .
|
| exp_of_op [Arm_utils] |
|
| exp_of_reg [Arm_utils] |
|
| expect [Monads.Std.Monad.S2.Exn] |
expect ?finally ~f ~catch evaluates f () , if an
exception e is raised during the evaluation (or call)
then the result of whole computation will be catch e .
|
| expect [Monads.Std.Monad.S.Exn] |
expect ?finally ~f ~catch evaluates f () , if an
exception e is raised during the evaluation (or call)
then the result of whole computation will be catch e .
|
| expect [Bap.Std.Type.Error] |
expect t ~got:u raises T (bap_type ~exp:t ~got:t)
|
| expect_imm [Bap.Std.Type.Error] |
expect_imm () raises T bad_imm
|
| expect_mem [Bap.Std.Type.Error] |
expect_mem () raises T bad_mem
|
| exps [Bap.Std.Jmp] |
exps jmp returns a sequence of expressions occurring in
different positions of a jump jmp , e.g., in cond ,
target , etc.
|
| extend [Arm_bit] |
|
| extend [Regular.Std.Bytes] |
extend s left right returns a new byte sequence that contains
the bytes of s , with left uninitialized bytes prepended and
right uninitialized bytes appended to it.
|
| extern [Bap.Std.Sub] |
A subroutine is visible outside of the compilation unit
|
| external_reference [Bap.Std.Image.Scheme] |
extrenal_reference addr name a piece of code at the
specified address addr references an external symbol with
the given name .
|
| extract [Bap_primus.Std.Primus.Interpreter.Make] |
extract ~hi ~lo x extracts bits from lo to hi from
x .
|
| extract [Bap_primus.Std.Primus.Interpreter] |
extract ((hi,lo,x),r) happens after r is extracted from x
|
| extract [Bap_primus.Std.Primus.Value.Make] |
extracts ?hi ?lo is lift1 (Word.extract ?hi ?lo)
|
| extract [Bap.Std.Bil] |
extract ~hi ~lo x -> Extract (hi,lo,x)
|
| extract [Bap.Std.Bitvector] |
extract bv ~hi ~lo extracts a subvector from bv , starting
from bit hi and ending with lo .
|
| extract_exn [Bap.Std.Bitvector] |
extract_exn bv ~hi ~lo is the same as extract , but will raise
an exception on error.
|
F |
| fail [Arm_utils] |
|
| fail [Ogre.S] |
fail error aborts an inference process with the specified
error .
|
| fail [Monads.Std.Monad.Fail.S2] |
fail err diverges the computation, possibly providing an
extra information in a value of type 'e error .
|
| fail [Monads.Std.Monad.Fail.S] |
fail err diverges the computation, possibly providing an
extra information in a value of type _ error .
|
| fail_on_error [Bap_traces.Std.Trace.Monitor] |
fail_on_error will fail with an error Error.raise error
|
| failf [Bap_primus.Std.Primus.Lisp.Make] |
failf msg a1 ... am () terminates a lisp machine, and
correspondingly the Primus machine with the
Runtime_error .
|
| failf [Ogre.S] |
failf fmt args... () constructs an error based on the
specified format fmt and arguments, terminated by the unit value
() .
|
| failf [Monads.Std.Monad.Result.Error.S] |
failf "<fmt>" <args> () constructs an error message
using the specified format descripton and returns a
computation that will result in the constructed
error.
|
| field [Ogre.Query] |
field name creates an unqualified join variable.
|
| file [Bap.Std.Self.Config] |
file converts a value with the identity function and
checks with Sys.file_exists that a file with that name exists.
|
| file [Bap.Std.Project.Input] |
file ?loader ~filename input data from a file, using the
specified loader.
|
| file [Bap.Std.Project.Info] |
occurs everytime a new file is opened.
|
| filename [Bap.Std.Image] |
|
| filename [Bap.Std] |
|
| fill [Regular.Std.Bytes] |
fill s start len c modifies s in place, replacing len
characters with c , starting at start .
|
| filter [Bap_future.Std.Stream] |
filter s f produce a stream that contains the elements of
stream s , for which f evaluates to true.
|
| filter [Monads.Std.Monad.Collection.S] |
filter xs ~f returns a computation that contains all
the elements of xs for which f evaluated to true .
|
| filter [Monads.Std.Monad.Collection.S2] |
filter xs ~f returns a computation that contains all
the elements of xs for which f evaluated to true .
|
| filter [Regular.Std.Seq] |
for compatibility with Core <= 111.28
|
| filter [Bap.Std.Term] |
filter t p ~f returns a term p with subterms c for which
f c = false removed.
|
| filter [Bap.Std.Memmap] |
filter map f returns a map that contains only those elements
for which f evaluated to true
|
| filter [Bap.Std.Table] |
filter ~start ~until ~f table removes all mappings from
table that doesn't satisfies the predicate f
|
| filter [Bap.Std.Dict] |
filter dict ~f returns a new dict, filtered with f
|
| filter [Bap.Std.Interval_tree.S] |
filter t ~f returns a tree where all elements for which
f returned false are removed.
|
| filter_map [Bap_traces.Std.Trace] |
filter_map t ~f will return a trace where all events a
filter-mapped with the provided function f
|
| filter_map [Bap_future.Std.Stream] |
filter_map s ~f for each value x in stream s , produce
y if f x is Some y , otherwise ignore x
|
| filter_map [Monads.Std.Monad.Collection.S] |
filter_map xs ~f is a partial mapping from xs to a
collection ys , such that all the elements of xs for which
f returned Some value are mapped, while the rest are
omitted.
|
| filter_map [Monads.Std.Monad.Collection.S2] |
filter_map xs ~f is a partial mapping from xs to a
collection ys , such that all the elements of xs for which
f returned Some value are mapped, while the rest are
omitted.
|
| filter_map [Bap.Std.Term] |
filter_map t p ~f returns term p with all subterms of type
t filter_mapped with function f , i.e., all terms for which
function f returned Some thing are substituted by the
thing , otherwise they're removed from the parent term
|
| filter_map [Bap.Std.Memmap] |
filter_map m f creates a new map by applying a function f to
each tag.
|
| filter_map [Bap.Std.Table] |
filter_map ~start ~until ~f table return a subtable of
table containing only elements for which f returns
Some
|
| filter_map [Bap.Std.Interval_tree.S] |
filter t ~f returns a tree where all elements for which
f returned None are removed and all others are mapped.
|
| filter_mapi [Bap.Std.Memmap] |
filter_mapi is like filter_map but use function also accepts
would assosiated memory region
|
| filter_mapi [Bap.Std.Table] |
filter_mapi ~start ~until ~f table is like Std.Table.filter_map , but
also passes the memory as an argument.
|
| filter_mapi [Bap.Std.Interval_tree.S] |
filter t ~f returns a tree where all elements for which
f returned None are removed and all others are mapped.
|
| filtered [Graphlib.Std.Graphlib] |
let module G' = filtered (module G) ?skip_node ?skip_edge ()
creates a new module G' that can be used at any place
instead of G , but that will hide nodes and edges, for which
functions skip_node and skip_edge return true.
|
| filteri [Bap.Std.Table] |
filteri ~start ~until ~f table is like Std.Table.filter , but
also passes the memory as an argument.
|
| find [Bap_byteweight.Bytes] |
find mem ~length ~threshold corpus extract addresses of all
memory chunks of the specified length , that were classified
positively under given threshold .
|
| find [Bap_bml.Registry] |
find name find a value associated with the given value
|
| find [Bap_future.Std.Stream] |
find xs f returns a future that will be fulfilled with a
first value for which a function f is true .
|
| find [Monads.Std.Monad.Collection.S] |
find xs ~f returns the first element x of xs for
wich f x evaluates to true .
|
| find [Monads.Std.Monad.Collection.S2] |
find xs ~f returns the first element x of xs for
wich f x evaluates to true .
|
| find [Bap.Std.Source.Factory.S] |
create name args finds a source provider with the
given name and creates it
|
| find [Bap.Std.Term] |
find t p id is Some c if term p has a subterm of type t
such that tid c = id .
|
| find [Bap.Std.Table] |
find table mem finds an element mapped to the memory region mem
|
| find [Bap.Std.Dict] |
find map tag lookups value
|
| find [Bap.Std.Stmt] |
find finder stmt performs a lookup into the Bil statement.
|
| find [Bap.Std.Exp] |
find finder exp returns Some thing if finder finds some
thing .
|
| find [Bap.Std.Trie.S] |
find trie key finds data associated with key
|
| find_addr [Bap.Std.Table] |
find_addr tab addr finds a memory region that contains a
specified addr
|
| find_by_name [Bap.Std.Symtab] |
find_by_name symbols name finds a symbol with a given namem
|
| find_by_start [Bap.Std.Symtab] |
find_by_start symbols addr finds a symbol that starts from
a given address
|
| find_exn [Bap.Std.Term] |
find_exn t p id like Std.Term.find but raises Not_found if nothing
is found.
|
| find_if [Bap.Std.Table] |
find_if ~start ~until ~f table returns the first element of
table that satisfies the predicate p or None if no elements
satisfied
|
| find_if [Bap.Std.Memory_iterators] |
find_if ~word_size ~f t returns the first element of
t that satisfies the predicate p or None if no elements
satisfied
|
| find_map [Bap_future.Std.Stream] |
find_map xs f returns a future that will be fulfilled by a
result of a first invocation of f to an element of the stream,
that evaluated to Some value
|
| find_map [Monads.Std.Monad.Collection.S] |
find_map xs ~f returns the first computation f x for
x in xs which will result in non None .
|
| find_map [Monads.Std.Monad.Collection.S2] |
find_map xs ~f returns the first computation f x for
x in xs which will result in non None .
|
| find_map [Bap.Std.Table] |
find_map ~start ~until ~f table returns the first evaluation
of f that returns Some or None if f always returns None
|
| find_map [Bap.Std.Memory_iterators] |
find_map ~word_size ~f t returns the first evaluation
of f that returns Some or None if f always returns None
|
| find_mapi [Bap.Std.Table] |
find_mapi ~start ~until ~f table is like Std.Table.find_map , but
also passes the memory as an argument.
|
| find_pass [Bap.Std.Project] |
find_pass name returns a pass with the given name.
|
| find_reader [Regular.Std.Data.S] |
find_reader ?ver name lookups a reader with a given name.
|
| find_var [Bap.Std.Blk] |
find_var blk var finds a last definition of a variable var
in a block blk .
|
| find_writer [Regular.Std.Data.S] |
find_writer ?ver name lookups a writer with a given name.
|
| findi [Bap.Std.Vector] |
findi xs ~f retuns an index i and a value x of the first
element of xs , for which f i x is true .
|
| finish [Graphlib.Std.Path] |
finish p the last edge of a path p
|
| finished [Bap_c_type_mapper.Search] |
finished needle is called when a search is finished, it will
terminate the search with the needle as a result.
|
| finished [Bap_primus.Std.Primus.Machine] |
The finished event occurs when the machine terminates.
|
| first [Bap.Std.Term] |
first t p returns the first subterm of type t of a given
parent p
|
| first_byte [Bap.Std.Memory] |
first_byte m returns first byte of m as a memory
|
| fixpoint [Graphlib.Std.Graphlib] |
fixpoint ~equal ~init ~merge ~f g computes a solution for a
system of equations denoted by graph g , using the inital
approximation init (obtained either with Solution.create or
from the previous calls to fixpoint ).
|
| fixpoint [Bap.Std.Stmt] |
fixpoint f x applies transformation f until it reaches
fixpoint.
|
| fixpoint [Bap.Std.Exp] |
fixpoint f applies transformation f to t until it
reaches a fixpoint, i.e., such point x that
f x = f (f x) .
|
| fixpoint [Bap.Std.Bil] |
fixpoint f applies transformation f until fixpoint is
reached.
|
| fixup [Bap.Std.Image.Scheme] |
|
| flag [Bap.Std.Self.Config] |
Create a boolean parameter that is set to true if user
mentions it in the command line arguments
|
| flags [X86_cpu.IA32] |
flags is a set of flag registers
|
| float [Ogre.Query] |
float x creates a real number constant.
|
| float [Ogre.Type] |
|
| float [Bap.Std.Self.Config] |
float converts values with float_of_string .
|
| floating_of_sexp [Bap_c_type] |
|
| flush [Bap_bundle.Std.Bundle.Builder] |
flush builder output finish the building and output the
resulting bundle into the file output .
|
| fold [Monads.Std.Monad.Collection.S] |
|
| fold [Monads.Std.Monad.Collection.S2] |
fold xs ~init:s0 ~f folds f over xs in the given monad.
|
| fold [Monads.Std.Monad.Collection.Delay] |
fold xs ~init:s ~f a delayed fold implementation.
|
| fold [Monads.Std.Monad.Collection.Eager] |
|
| fold [Bap.Std.Table] |
fold ~start ~until ~init ~f table returns a fold over
table in form f elt_n ( ... (f elt_2 (f (elt_1 acc))) ... )
|
| fold [Bap.Std.Memory_iterators] |
fold ~word_size ~init ~f t folds over elements of t ,
so a result is f (... (f (f a elt_1) elt_2) ...) elt_n
|
| fold [Bap.Std.Stmt] |
fold ~init visitor stmt folds a stmt with a visitor.
|
| fold [Bap.Std.Exp] |
fold visitor ~init exp traverse the exp tree with
provided visitor .
|
| fold_consts [Bap.Std.Exp] |
fold_consts x performs constant folding of the expression x .
|
| fold_consts [Bap.Std.Bil] |
fold_consts evaluates constant expressions and statements.
|
| fold_intersections [Bap.Std.Table] |
fold_intersections table mem folds over all regions
intersecting with mem
|
| fold_left [Monads.Std.Monad.Collection.S] |
fold_left is a synonym for fold .
|
| fold_left [Monads.Std.Monad.Collection.S2] |
fold_left is a synonym for fold .
|
| fold_reachable [Graphlib.Std.Graphlib] |
fold_reachable (module G) ?rev ~init ~f g n applies function
f to all nodes reachable from node g in graph g .
|
| fold_right [Monads.Std.Monad.Collection.S] |
fold_right xs ~f ~init:s0 folds f over xs from right to
left in the given monad.
|
| fold_right [Monads.Std.Monad.Collection.S2] |
fold_right xs ~f ~init:s0 folds f over xs from right to
left in the given monad.
|
| foldi [Bap.Std.Table] |
foldi ~start ~until ~f table is like Std.Table.fold , but
also passes the memory as an argument.
|
| foldi [Bap.Std.Memory_iterators] |
|
| foldi [Bap.Std.Vector] |
foldi xs ~init:s_0 ~f computes f n s_n x_n , where s_n = f
(n-1) s_[n-1] x_[n-1] and n is the number of elements in
xs
|
| foldw [Bap_future.Std.Stream] |
foldw ss n ~init ~f performs a windowed fold of the stream.
|
| for_all [Monads.Std.Monad.Collection.S] |
for_all xs ~f returns a computation that results in
true iff for all x in xs f x evaluates to true .
|
| for_all [Monads.Std.Monad.Collection.S2] |
for_all xs ~f returns a computation that results in
true iff for all x in xs f x evaluates to true .
|
| for_all [Bap.Std.Table] |
for_all ~start ~until ~f table checks if all elements
of table satisfies the predicate f .
|
| for_all [Bap.Std.Memory_iterators] |
for_all ~word_size ~f t checks if all elements of t
satisfies the predicate f
|
| for_alli [Bap.Std.Table] |
for_alli ~start ~until ~f table is like Std.Table.for_all , but
also passes the memory as an argument.
|
| foreach [Ogre.S] |
foreach query ~f:action applies an action for each value of
an attributes specified in the query.
|
| foreground [Bap.Std] |
print marked entity with the specified color.
|
| forever [Monads.Std.Monad.S2] |
forever xs creates a computationt that never returns.
|
| forever [Monads.Std.Monad.S] |
forever xs creates a computationt that never returns.
|
| fork [Monads.Std.Monad.State.Multi.S2] |
fork () forks the current state.
|
| fork [Monads.Std.Monad.State.Multi.S] |
fork () forks the current state.
|
| forks [Monads.Std.Monad.State.Multi.S2] |
forks xs returns a sequence of all alive states
|
| forks [Monads.Std.Monad.State.Multi.S] |
forks xs returns a sequence of all alive states
|
| format [Bap.Std.Arg] |
format(DSL) the specified argument of a subroutine is
actually a format string written in a corresponding DSL.
|
| forward [Graphlib.Std.Isomorphism] |
|
| fpu_ctrl [X86_env] |
|
| frame [Bap_future.Std.Stream] |
frame ~clk s ~init ~f will gather elements of s into frames,
where the start of the new frame is signaled by a stream clk .
|
| free_vars [Bap.Std.Phi] |
free_vars t returns a set of variables that occur free on
the right hand side of the phi-node.
|
| free_vars [Bap.Std.Jmp] |
free_vars jmp returns a set of all variables that are free
in some expression in the jump jmp .
|
| free_vars [Bap.Std.Def] |
free_vars def returns a set of free variables, that occurs
on the right hand side of definition def .
|
| free_vars [Bap.Std.Blk] |
free_vars blk returns a set of variables that occurs free
in block blk .
|
| free_vars [Bap.Std.Sub] |
free_vars sub computes a set of variables that are free in
a given subroutine sub .
|
| free_vars [Bap.Std.Stmt] |
free_vars stmt returns a set of all unbound variables, that
occurs in stmt .
|
| free_vars [Bap.Std.Exp] |
free_vars exp returns a set of all unbound variables, that
occurs in the expression exp .
|
| free_vars [Bap.Std.Bil] |
free_vars bil returns a set of free variables in program
bil .
|
| from [Bap_future.Std.Stream] |
from f returns a stream that is generated from successive
applications of a function f .
|
| from [Ogre.Query] |
from attr adds an attribute attr to the query.
|
| from_data [Bap.Std.Image.Loader] |
from_data data loads image from the specified array of bytes.
|
| from_file [Bare.Rule] |
from_file name parses a file that contains zero or more rule
specifications.
|
| from_file [Ogre.Doc] |
from_file name reads a document from a file with the given
name , returns an error, if a document is not well-formed, raises
an exception if a system error has occured.
|
| from_file [Bap.Std.Image.Loader] |
from_file name loads a file with the given name .
|
| from_insn [Bap.Std.Blk] |
from_insn insn creates an IR representation of a single
machine instruction insn .
|
| from_string [Bare.Rule] |
|
| from_string [Ogre.Doc] |
from_string data parses document from data .
|
| from_string [Bap.Std.Tid] |
from_string s parses tid from string.
|
| from_string_exn [Bap.Std.Tid] |
from_string_exn s same as from_string_exn but throws
exception on error.
|
| fs [X86_env] |
|
| fs_base [X86_env.ModeVars] |
segment registers let bases
|
| fst [Monads.Std.Monad.S2.Triple] |
|
| fst [Monads.Std.Monad.S2.Pair] |
|
| fst [Monads.Std.Monad.S.Triple] |
|
| fst [Monads.Std.Monad.S.Pair] |
|
| fulfill [Bap_future.Std.Promise] |
fulfill promise will fill a future value associated with a
promise and evaluate to unit if promise is not yet
fulfilled.
|
| functions [Bap_dwarf.Std.Dwarf.Fbi] |
functions searcher enumerates functions
|
G |
| gcd [Bap.Std.Bitvector] |
gcd x y is the greatest common divisor of x and y
in the integers.
|
| gcd_exn [Bap.Std.Bitvector] |
gcd_exn x y is the same as gcd , but will raise
an exception on error.
|
| gcdext [Bap.Std.Bitvector] |
gcdext x y returns (g, s, t) where g = gcd x y and
g = s*x + t*y .
|
| gcdext_exn [Bap.Std.Bitvector] |
gcdext_exn x y is the same as gcdext , but will raise
an exception on error.
|
| gdt [X86_env.ModeVars] |
|
| ge [Arm_env] |
ge array of general registers
|
| generate_index [Bap_primus.Std.Primus.Lisp.Doc.Make] |
|
| get [Bap_primus.Std.Primus.Memory.Make] |
get a loads a byte from the address a .
|
| get [Bap_primus.Std.Primus.Env.Make] |
get var returns a value associated with the variable.
|
| get [Bap_primus.Std.Primus.Interpreter.Make] |
|
| get [Bap_primus.Std.Primus.Machine.State] |
get state extracts the state.
|
| get [Bap_primus.Std.Primus.Pos] |
get a p get a value of the attribute a associated with
the given position p .
|
| get [Graphlib.Std.Solution] |
get s x returns a value of x .
|
| get [Ogre.Query.String] |
filed.(n) creates a field variable that ranges over values
of field that belongs to the n'th attribute of a selection.
|
| get [Ogre.Query.Array] |
attr.(field) creates a field variable that ranges over
values of field that belongs to the attribute attr .
|
| get [Monads.Std.Monad.State.S2] |
get s gets the current state
|
| get [Monads.Std.Monad.State.S] |
get s gets the current state
|
| get [Regular.Std.Bytes] |
get s n returns the byte at index n in s .
|
| get [Bap.Std.Project] |
get project field returns the value of the field if it
exists
|
| get [Bap.Std.Memory] |
get word_size mem addr reads memory value from the specified
address.
|
| get [Bap.Std.Vector] |
get vec n like nth but raises exception if index is out of
bounds
|
| get [Bap.Std.Value] |
get cons extracts a value associated with a constructor cons
(Essentially, performs a pattern match on the specified variant
branch)
|
| get_attr [Bap_traces.Std.Trace] |
get_attr trace attr retrieves a value of a given attribute
attr
|
| get_attr [Bap.Std.Term] |
get_attr term attr returns a value of the a given attr in
term
|
| get_data [Bap_bundle.Std.Bundle] |
get_data bundle path extracts data specified by a path as
a string.
|
| get_exn [Bap.Std.Value] |
get_exn t v extracts value created with t from the
variant.
|
| get_file [Bap_bundle.Std.Bundle] |
get_file ?name bundle uri extracts a file.
|
| gets [Monads.Std.Monad.State.S2] |
|
| gets [Monads.Std.Monad.State.S] |
gets p projects the current state with the function p
|
| global [Monads.Std.Monad.State.Multi.S2] |
the identifier of the global (initial) state.
|
| global [Monads.Std.Monad.State.Multi.S] |
the identifier of the global (initial) state.
|
| gpr [Bap.Std.CPU] |
A set of general purpose registers
|
| gpr_of_sexp [X86_asm_reg_types] |
|
| gpr_or_nil_of_sexp [Arm_types] |
|
| gpr_reg_of_sexp [Arm_types] |
|
| greatest [Bap.Std.Interval_tree.S] |
greatest t returns the greatest bound of the tree t .
|
| group [Graphlib.Std.Partition] |
group p x returns a group of an element x .
|
| groups [Graphlib.Std.Partition] |
groups p returns all partition cells of a partitioning p
|
| gs [X86_env] |
|
| gs_base [X86_env.ModeVars] |
|
| guard [Monads.Std.Monad.Choice.S2] |
guard cond ensures cond is true in the rest of
computation.
|
| guard [Monads.Std.Monad.Choice.S] |
guard cond ensures cond is true in the rest of
computation.
|
H |
| halt [Bap_primus.Std.Primus.Interpreter.Make] |
halt halts the machine by raise the Halt exception.
|
| halting [Bap_primus.Std.Primus.Interpreter] |
|
| has [Bap.Std.Project] |
has project field checks whether field exists or not.
|
| has_attr [Bap_traces.Std.Trace] |
has_attr trace attr evaluates to true if trace has a given
attribute attr
|
| has_attr [Bap.Std.Term] |
has_attr term attr is true if term has attribute attr
|
| has_coeffects [Bap.Std.Eff] |
has_coeffects eff if loads eff || reads eff
|
| has_edge [Graphlib.Std.Node] |
has_edge x y g is true iff (x,y) ∈ E.
|
| has_effects [Bap.Std.Eff] |
has_effects eff if stores eff || raises eff
|
| has_intersections [Bap.Std.Table] |
has_intersections tab mem is true iff some portion of mem is
is already mapped in tab .
|
| has_subscribers [Bap_future.Std.Stream] |
has_subscribers s is true if someone is watching for the stream
|
| hash [Regular.Std.Regular.Minimal] |
|
| hash [Bap.Std.Op.Normalized] |
|
| hash [Bap.Std.Trie.Token] |
|
| hd [Bap_future.Std.Stream] |
hd s returns a future that will occur as soon, as stream
s will produce a value.
|
| hexdump [Bap.Std.Memory] |
hexdump t out outputs hexdump (as per hexdump -C ) of the
memory to formatter out
|
| hide [Text_tags.Attr] |
hide name disable attribute with the name .
|
| high [Bap.Std.Bil] |
|
| hint_bnt [X86_env] |
|
| hint_bt [X86_env] |
|
| htmldir [Bap_config] |
|
I |
| i1 [Bap.Std.Bitvector.Int_err] |
i1 x is Ok x iff bitwidth x = 1
|
| i16 [Bap.Std.Bitvector.Int_err] |
i16 x is Ok x iff bitwidth x = 16
|
| i32 [Bap.Std.Bitvector.Int_err] |
i32 x is Ok x iff bitwidth x = 32
|
| i4 [Bap.Std.Bitvector.Int_err] |
i4 x is Ok x iff bitwidth x = 4
|
| i64 [Bap.Std.Bitvector.Int_err] |
i64 x is Ok x iff bitwidth x = 64
|
| i8 [Bap.Std.Bitvector.Int_err] |
i8 x is Ok x iff bitwidth x = 8
|
| id [Bap_traces.Std.Trace] |
Trace global unique identifier.
|
| id [Bap_primus.Std.Primus.Value.Make] |
id x is a unique identifier of a value.
|
| id [Bap_primus.Std.Primus.Value] |
id value returns the value identifier
|
| id [Monads.Std.Monad.S2.Fn] |
id x a monadic identity function
|
| id [Monads.Std.Monad.S.Fn] |
id x a monadic identity function
|
| id [Bap.Std.Bil.Result] |
returns result's identifier
|
| if_ [Bap.Std.Bil] |
if_ cond s1 s2 -> If(cond,s1,s2)
|
| ignore [Monads.Std.Monad.S2.Fn] |
ignore m computes m and discards the result.
|
| ignore [Monads.Std.Monad.S.Fn] |
ignore m computes m and discards the result.
|
| ignore_errors [Bap_traces.Std.Trace.Monitor] |
ignore_errors filters good events and silently drops error events
|
| imm [Bap.Std.Type] |
imm n denotes a type of bitvectors of the given bitwidth
|
| in_bits [Bap.Std.Size] |
in_bits size returns size in bits.
|
| in_bytes [Bap.Std.Size] |
in_bytes sz returns size in bytes
|
| index [Bap_strings_unscrambler.Alphabet] |
index x maps x to the n 'th symbol of an alphabet, if x
is a representation of that symbols, returns a number that is
outside of [0,len-1] interval if it is not.
|
| index [Regular.Std.Bytes] |
index s c returns the index of the first occurrence of byte c
in s .
|
| index [Bap.Std.Vector] |
index ?equal xs x returns an index of the first element p of
xs for which equal p x is true .
|
| index [Bap.Std.Var] |
|
| index_exn [Bap.Std.Vector] |
index_exn ?equal xs x is the same as index ?equal xs x but
an exception is thrown instead of None
|
| index_from [Regular.Std.Bytes] |
index_from s i c returns the index of the first occurrence of
byte c in s after position i .
|
| index_with [Bap.Std.Vector] |
index_with ?equal ~default xs x same as index but returns
the default value instead of None .
|
| indirect [Bap_taint.Std.Taint.Rel] |
Denotes the indirect relation between a value and the object
that we track, e.g., a value is a pointer that points to a
value that has the direct relation with the object.
|
| indirect [Bap.Std.Label] |
indirect exp creates a label that is resolved to an
expression exp
|
| indirect [Bap.Std.Insn] |
the instruction is jump with a target that is not a constant
|
| infer [Bap.Std.Type] |
infer exp is Ok t if exp is well-typed and has type t
otherwise Error e .
|
| infer_exn [Bap.Std.Type] |
infer_exn t is the same as ok_exn @@ infer_exn t .
|
| info [Bap.Std.Self] |
info fmt ... send an info message
|
| info_formatter [Bap.Std.Self] |
formatter that sends info messages
|
| infodir [Bap_config] |
|
| init [Bap_llvm_loader] |
|
| init [Bap_primus.Std.Primus.Lisp] |
|
| init [Bap_primus.Std.Primus.Machine] |
init event occurs just after all components have been
initialized, and before the execution starts
|
| init [Bap_primus.Std.Primus.Machine.Component] |
init () component initialization function.
|
| init [Regular.Std.Bytes] |
init n ~f returns a fresh byte sequence of length n , with
character i initialized to the result of f i (in increasing
index order).
|
| init [Bap.Std.Blk.Builder] |
init blk creates a builder based on an existing
block.
|
| init_disassembler [Bap_llvm.Std] |
init_disassembler () initializes and registers the LLVM based disassembler.
|
| init_loader [Bap_llvm.Std] |
init-loader () initializes and registers the LLVM based
loader.
|
| inputs [Graphlib.Std.Node] |
inputs node graph is incomming edges of a node in graph
|
| insert [Graphlib.Std.Edge] |
insert e g returns a graph g' with a set of edges extended
with edge e .
|
| insert [Graphlib.Std.Node] |
insert n g returns new graph g' that has a set of nodes
N extended with node n .
|
| insert_data [Bap_bundle.Std.Bundle] |
insert_data bundle ~name ~data insert data at path name .
|
| insert_file [Bap_bundle.Std.Bundle] |
insert_file ?name bundle uri insert a file specified by the
uri .
|
| insert_files [Bap_bundle.Std.Bundle] |
insert_files bundle spec bundle files.
|
| insn [Bap.Std.Disasm] |
|
| insn_of_mem [Bap.Std.Disasm_expert.Basic] |
insn_of_mem dis mem performes a disassembly of one instruction
from the a given memory region mem .
|
| insn_of_sexp [Arm_types] |
|
| insns [Bap.Std.Disasm] |
returns all instructions that was successfully decoded in an
ascending order of their addresses.
|
| insns [Bap.Std.Block] |
insns blk returns a list of block instructions.
|
| insns [Bap.Std.Disasm_expert.Basic] |
a queue of instructions disassembled in this step
|
| inspect [Bap_primus.Std.Primus.Machine.State] |
inspect state value introspects given value of the state.
|
| inspect [Bap_primus.Std.Primus.Observation] |
inspect observation value returns a sexp representation of
an observed value
|
| install [Text_tags] |
install ppf mode switch formatter ppf into a mode .
|
| install [Bap_build.Std.Plugin_rules] |
install () installs bap specific rules.
|
| install [Core_printers] |
|
| int [Bap_primus.Std.Primus.Lisp.Type.Spec] |
a machine integer - a word that has the same width as
Arch.addr_size
|
| int [Ogre.Query] |
int x creates an integer constant
|
| int [Ogre.Type] |
int is represented with OCaml's int64, and has a
corresponding representation
|
| int [Bap.Std.Self.Config] |
int converts values with int_of_string .
|
| int [Bap.Std.Bil] |
|
| int [Bap.Std.Bitvector.Int_err] |
int w v will be Ok if v has width w
|
| int16 [Bap.Std.Memory.Input] |
int16 a signed 16-bit word reader
|
| int32 [Bap.Std.Self.Config] |
int32 converts values with Int32.of_string .
|
| int32 [Bap.Std.Memory.Input] |
int32 a 32-bit word reader
|
| int64 [Bap.Std.Self.Config] |
int64 converts values with Int64.of_string .
|
| int64 [Bap.Std.Memory.Input] |
int64 a 64-bit word reader
|
| int8 [Bap.Std.Memory.Input] |
int8 a signed byte reader
|
| integer_of_sexp [Bap_c_type] |
|
| intent [Bap.Std.Arg] |
intent arg returns the argument intent.
|
| inter [Graphlib.Std.Graphlib] |
inter (module G) g1 g2 returns a graph g that is an
intersection of graphs g1 and g2 , i.e., it contain
and edges from this graphs.
|
| interrupt [Bap_primus.Std.Primus.Interpreter.Make] |
interrupt n interrupts the computation with cpuexn n
|
| interrupt [Bap_primus.Std.Primus.Interpreter] |
interrupt n occurs on the machine interrupt n (aka CPU
exception)
|
| intersecting [Bap.Std.Symtab] |
intersecting_mem syms mem returns a list of functions, that
resides in memory region mem
|
| intersections [Bap.Std.Memmap] |
intersections map mem an ordered sequence of all memory regions,
that intersects with mem .
|
| intersections [Bap.Std.Table] |
intersections table mem returns all mappings in a table that
have intersections with mem
|
| intersections [Bap.Std.Interval_tree.S] |
intersections t k returns all intervals and their associated
values that intersects with k
|
| intersects [Bap.Std.Memmap] |
intersects map mem is true if intersections map mem is not empty
|
| intersects [Bap.Std.Interval_tree.S] |
intersects t k is true iff t contains an interval
that intersects with k
|
| invariant [Bap.Std.Term] |
invariant must be always true while the term is evaluated
|
| ip_of_sexp [X86_asm_reg_types] |
|
| is [Bap.Std.Insn] |
is property insn is true if insn has property
|
| is [Bap.Std.Disasm_expert.Basic.Insn] |
is insn kind checks whether instruction insn belongs
to the semantic kind
|
| is [Bap.Std.Value] |
is cons v true if value v was constructed with constructor
cons , i.e., it is true only when is_cons t (create t x)
|
| is_ancestor_of [Graphlib.Std.Tree] |
is_ancestor_of tree child x returns true, if x is one of
the ancestors of a child node.
|
| is_assigned [Bap.Std.Bil] |
is_assigned x p is true if there exists such Move
statement, that x occures on the left side of it.
|
| is_bp [Bap.Std.CPU] |
is_bp x is true if x can be possibly used as a base
pointer register.
|
| is_buildable [Bap_strings_unscrambler.Make] |
is_buildable d chars returns true if in the dictionary d
exists a word that can be built from the given characters.
|
| is_cf [Bap.Std.CPU] |
|
| is_child_of [Graphlib.Std.Tree] |
is_child_of tree parent child returns true if child is one
of children tree root
|
| is_debug [Bap.Std.Image.Symbol] |
is_debug sym is true if sym is a debug symbol.
|
| is_decided [Bap_future.Std.Future] |
is_decided f is true if a future f is already decided.
|
| is_descendant_of [Graphlib.Std.Tree] |
is_descendant_of ~parent tree x is true for all x that
are descendants of a parent node.
|
| is_directed [Graphlib.Std.Graph] |
is_directed is true if graph is a directed graph.
|
| is_empty [Regular.Std.Seq] |
|
| is_empty [Bap.Std.Dict] |
is_empty map true if is empty.
|
| is_executable [Bap.Std.Image.Segment] |
|
| is_fixpoint [Graphlib.Std.Solution] |
is_fixpoint s is true if the solution is a fixed point
solution, i.e., is a solution that stabilizes the system of
equations.
|
| is_flag [Bap.Std.CPU] |
is_flag reg is true if reg is a flag register
|
| is_fulfilled [Bap_future.Std.Promise] |
is_fulfilled promise is true if associated promise is
already fulfilled
|
| is_function [Bap.Std.Image.Symbol] |
is_function sym is true if sym is a function.
|
| is_linked [Bap_primus.Std.Primus.Linker.Make] |
is_linked name computes to true if the name is
associated with some code.
|
| is_mapped [Bap_primus.Std.Primus.Memory.Make] |
is_mapped addr a computation that evaluates to true,
when the value is mapped, i.e., it is readable.
|
| is_mem [Bap.Std.CPU] |
is_mem x = Var.same x mem
|
| is_negative [Bap_primus.Std.Primus.Value.Make] |
is_negative is lift1 Word.is_negative
|
| is_negative [Bap.Std.Bitvector] |
is_negative x is true if x is strictly less than zero.
|
| is_nf [Bap.Std.CPU] |
|
| is_non_negative [Bap_primus.Std.Primus.Value.Make] |
is_non_negative is lift1 Word.is_non_negative
|
| is_non_negative [Bap.Std.Bitvector] |
is_non_negative x is true if x is greater than or equal to
zero.
|
| is_non_positive [Bap_primus.Std.Primus.Value.Make] |
is_non_positive is lift1 Word.is_non_positive
|
| is_non_positive [Bap.Std.Bitvector] |
is_non_positive x is true if x is less than zero.
|
| is_one [Bap_primus.Std.Primus.Value.Make] |
is_one is lift1 Word.is_one
|
| is_one [Bap.Std.Bitvector] |
is_ones bv is true if the least significant bit is equal to one
|
| is_physical [Bap.Std.Var] |
is_physical v is true if v represents a contents of a
physical register.
|
| is_positive [Bap_primus.Std.Primus.Value.Make] |
is_positive is lift1 Word.is_positive
|
| is_positive [Bap.Std.Bitvector] |
is_positive x is true if x is greater than zero.
|
| is_reachable [Graphlib.Std.Graphlib] |
is_reachable (module G) ?rev g u v is true if node v is
reachable from node u in graph g .
|
| is_readable [Bap.Std.Image.Segment] |
|
| is_referenced [Bap.Std.Stmt] |
is_referenced x stmt is true is x is used in the stmt
in any place other then right hand side of the assignment.
|
| is_referenced [Bap.Std.Exp] |
is_referenced x exp true if exp contains Var x on one of
its leafs.
|
| is_referenced [Bap.Std.Bil] |
is_referenced x p is true if x is referenced in some
expression or statement in program p , before it is
assigned.
|
| is_reg [Bap.Std.CPU] |
is_reg var true if var is a processor register
|
| is_sp [Bap.Std.CPU] |
|
| is_ssa [Bap.Std.Sub] |
is_ssa sub is true if sub was transformed into an SSA
form.
|
| is_vf [Bap.Std.CPU] |
|
| is_virtual [Bap.Std.Var] |
is_virtual v is true if v is not physical
|
| is_writable [Bap_primus.Std.Primus.Memory.Make] |
is_writable addr is a computation that evaluates to
true if addr is writable.
|
| is_writable [Bap.Std.Image.Segment] |
|
| is_zero [Bap_primus.Std.Primus.Value.Make] |
is_zero is lift1 Word.is_zero
|
| is_zero [Bap.Std.Bitvector] |
is_zero bv is true iff all bits are set to zero.
|
| is_zf [Bap.Std.CPU] |
|
| ite [Bap_primus.Std.Primus.Interpreter] |
ite ((cond, yes, no), res) happens after the ite expression
that corresponds to ite(cond , yes , no ) is evaluated
to res .
|
| ite [Bap.Std.Bil] |
ite ~if_:cond ~then_:e1 ~else_:e2 -> Ite (cond,e1,e2)
|
| iter [Monads.Std.Monad.Collection.S] |
fold xs ~init:s0 ~f folds f over xs in the given monad.
|
| iter [Monads.Std.Monad.Collection.S2] |
iter xs ~f performs f x for each x in xs in the
left to right order.
|
| iter [Bap.Std.Table] |
iter ~start ~until ~f table applies function f in turn to
elements of table
|
| iter [Bap.Std.Memory_iterators] |
iter ~word_size ~f t applies f to elements of t
|
| iter [Bap.Std.Stmt] |
iter visitor stmt iters over a stmt with a visitor.
|
| iter [Bap.Std.Exp] |
iter visitor exp iterates over all terms of the exp using
provided visitor.
|
| iterations [Graphlib.Std.Solution] |
iterations s returns the total number of iterations that was
made to obtain the current solution.
|
| iteri [Regular.Std.Bytes] |
iteri t ~f same as iter , but the function is
applied to the index of the byte as first argument and the
byte itself as second argument.
|
| iteri [Bap.Std.Table] |
ieri ~start ~until ~f table is like Std.Table.iter , but
also passes the memory as an argument.
|
| iteri [Bap.Std.Memory_iterators] |
|
| iteri [Bap.Std.Vector] |
iter xs ~f applies f i x for each x_i in xs
|
| itstate [Arm_env] |
|
J |
| jmp [Bap.Std.Graphs.Ir.Edge] |
jmp e returns a jmp term associated with edge e
|
| jmp [Bap.Std.Bil] |
|
| jmp_t [Bap.Std] |
|
| jmps [Bap.Std.Graphs.Ir.Edge] |
jmps dir e g enumerates all jumps (including calls,
interrupts, indirects, etc), that occurs before if
dir = `before or after if dir = `after an edge e
|
| jump [Bap.Std.Insn] |
the instruction performs a non-regular control flow
|
| jump [Bap.Std.Disasm_expert.Basic] |
jump to the specified memory and continue disassembly in it.
|
| jumping [Bap_primus.Std.Primus.Interpreter] |
jumping (cond,dest) happens just before a jump to dest
is taken under the specified condition cond .
|
K |
| key [Bap_strings_index.Persistent.S] |
key idx data returns the key associated with data , if no
key is associated then Key.null is returned
|
| key_of_first_insns [Bap.Std.Disasm_expert.Basic.Trie] |
key_of_first_insns state ~len:n creates a key from first n
instructions stored in the state if state contains such
amount of instructions
|
| key_of_insns [Bap.Std.Insn.Trie] |
key_of_insns insns takes a list of instructions and transforms
it to key
|
| key_width [Bap_primus.Std.Primus.Value.Index] |
the width of keys in the index.
|
| kill [Monads.Std.Monad.State.Multi.S2] |
kill id kills a state with the specified id .
|
| kill [Monads.Std.Monad.State.Multi.S] |
kill id kills a state with the specified id .
|
| kind [Bap_taint.Std.Taint.Object.Make] |
kind obj returns the kind of the object.
|
| kind [Bap.Std.Jmp] |
kind jmp evaluates to a kind of jump
|
| kinds [Bap.Std.Disasm_expert.Basic.Insn] |
kinds insn returns a high-level semantic information
about the instruction.
|
L |
| label [Graphlib.Std.Edge] |
label e returns a label of an edge e
|
| label [Graphlib.Std.Node] |
label n returns a value associated with a node n .
|
| language [Bap_ida.Std.Command] |
language command is a script language
|
| language [Bap_api.S] |
language a name of a language, e.g., "C"
|
| last [Bap.Std.Term] |
last t p returns a last subterm of type t of a given
parent p
|
| last [Bap.Std.Disasm_expert.Basic] |
last s n returns last n instructions disassembled in this
step.
|
| last_before [Bap_future.Std.Stream] |
last_before e xs n returns a list of length up to n , that
contains last elements of the stream xs that occurred before the
event e
|
| last_byte [Bap.Std.Memory] |
last_byte m returns last byte of m as a memory
|
| lcg [Bap_primus.Std.Primus.Generator.Random.Seeded] |
lcg ~min ~max () a linear congruential generator.
|
| lcg [Bap_primus.Std.Primus.Generator.Random] |
lcg ~min ~max seed a linear congruential generator, that
produces a sequence of pseudorandom values that lies in the
range between min and max (all inclusive).
|
| lcm [Bap.Std.Bitvector] |
lcm x y is the least common multiple of x and y
in the integers.
|
| lcm_exn [Bap.Std.Bitvector] |
lcm_exn x y is the same as lcm , but will raise
an exception on error.
|
| ldt [X86_env.ModeVars] |
|
| le [Bap.Std.Bil] |
|
| leader [Bap.Std.Block] |
leader blk the first instruction
|
| leaf [Bap.Std.Sub] |
a subroutine doesn't contain any calls in any disguise, i.e.,
no longjmps, indirect calls, exceptions, etc.
|
| least [Bap.Std.Interval_tree.S] |
least t returns the least bound of the tree t .
|
| leave_arg [Bap_primus.Std.Primus.Interpreter] |
a subroutine argument was left
|
| leave_blk [Bap_primus.Std.Primus.Interpreter] |
|
| leave_def [Bap_primus.Std.Primus.Interpreter] |
|
| leave_exp [Bap_primus.Std.Primus.Interpreter] |
|
| leave_jmp [Bap_primus.Std.Primus.Interpreter] |
|
| leave_phi [Bap_primus.Std.Primus.Interpreter] |
|
| leave_pos [Bap_primus.Std.Primus.Interpreter] |
|
| leave_sub [Bap_primus.Std.Primus.Interpreter] |
|
| leave_term [Bap_primus.Std.Primus.Interpreter] |
an identifier of a term that just finished the execution.
|
| length [Bap_strings_unscrambler.Alphabet] |
total number of symbols in the alphabet
|
| length [Bap_byteweight.S] |
length decider total amount of different substrings known to a
decider.
|
| length [Graphlib.Std.Path] |
amount of edges in a path
|
| length [Regular.Std.Bytes] |
length t returns the length (number of bytes) of t .
|
| length [Bap.Std.Term] |
length t p returns an amount of terms of t class in a
parent term p
|
| length [Bap.Std.Table] |
length table returns a number of entries in the table
|
| length [Bap.Std.Memory] |
length m returns a number of bytes in m
|
| length [Bap.Std.Trie.Key] |
length key return the amount of tokens in a key
|
| length [Bap.Std.Trie.S] |
length trie returns the number of values in trie
|
| let_ [Bap.Std.Bil] |
let_ var value expr -> Let(var,value,expr)
|
| lhs [Bare.Rule] |
lhs rule is the left hand side of the rule.
|
| lhs [Bap.Std.Arg] |
lhs arg returns a variable associated with the argument.
|
| lhs [Bap.Std.Phi] |
lhs phi returns a variable associated with a phi node
|
| lhs [Bap.Std.Def] |
returns the left hand side of a definition
|
| libdir [Bap_config] |
|
| libdir [Bap.Std.Self.Config] |
A directory for bap specific object files, libraries, and
internal binaries that are not intended to be executed directly
by users or shell scripts
|
| libexecdir [Bap_config] |
|
| lift [Arm_lifter] |
lift mem insn lifts instruction.
|
| lift [Arm_mov] |
|
| lift [Arm_branch] |
|
| lift [Monads.Std.Monad.Trans.S2] |
lifts inner monad into the resulting monad
|
| lift [Monads.Std.Monad.Trans.S1] |
lifts inner monad into the resulting monad
|
| lift [Monads.Std.Monad.Trans.S] |
lifts inner monad into the resulting monad
|
| lift [Bap.Std.Target] |
lift mem insn lifts provided instruction to BIL.
|
| lift [Bap.Std.Blk] |
lift block takes a basic block of assembly instructions and
lifts it to a list of blk terms.
|
| lift [Bap.Std.Sub] |
lift entry takes an basic block of assembler instructions,
as an entry and lifts it to the subroutine term.
|
| lift [Bap.Std.Program] |
lift symbols takes a table of functions and return a whole
program lifted into IR
|
| lift_c [Arm_shift] |
Need the operand and the carry flag value src - the source, if you
intend to use the carry bit, this must not be the destination of the
shift expression.
|
| lift_i [Arm_shift] |
decodes an immediate shifted operand
* src - the operand to be shifted, cannot be the destination
* in practice this means it must be a temp variable.
|
| lift_m [Arm_mem] |
|
| lift_m [Arm_mem_shift] |
|
| lift_mem [Arm_shift] |
decodes a shifted operand for a memory operation
* src - the operand to be shifted
* shift - an int64,
* bits 11 through 0 represent the shift amount
* bits 12 represents whether the expression is added or subtracted
* bits 15 through 13 represent the shift type, valid shift types
* are number 1 through 5
* typ - the type
*
|
| lift_mull [Arm_mul] |
|
| lift_r [Arm_shift] |
|
| lift_r [Arm_mem] |
|
| lift_r_exp [Arm_mem_shift] |
|
| lift_r_op [Arm_mem_shift] |
|
| lift_smul [Arm_mul] |
|
| link [Bap_primus.Std.Primus.Linker.Make] |
link ~addr ~name ~tid code links the given code
fragment into the Machine.
|
| link [Bap.Std.Table] |
|
| link_primitives [Bap_primus.Std.Primus.Lisp.Make] |
link_primitives prims provides the primitives prims
|
| link_program [Bap_primus.Std.Primus.Lisp.Make] |
link_program p links the program p into the Lisp
Machine.
|
| list [Bap_bml.Registry] |
list () list all bindings
|
| list [Bap_plugins.Std.Plugins] |
list ?env ~provides:features ?library () scans a list of directories, provided by a
library parameter, and, finally, Config.libdir for files with
a plugin extension.
|
| list [Bap_bundle.Std.Bundle] |
list bundle returns a list of paths, that are accessible in
the bundle .
|
| list [Bap.Std.Self.Config] |
list sep c splits the argument at each sep (defaults to ',' )
character and converts each substrings with c .
|
| list [Bap.Std.Source.Factory.S] |
list source is a list of names of source providers
|
| list_loaded_units [Bap_plugins.Std] |
list_loaded_units () evaluates to a list of compilation unit
names currently loaded into the system.
|
| list_providers [Bap_primus.Std.Primus.Observation] |
enumerate all currently available observation providers
|
| listen [Monads.Std.Monad.Writer.S] |
listen m reads both the computation result and the
current state.
|
| live [Bap.Std.Term] |
a term is identified as always non dead
|
| llvm_version [Bap_llvm.Std] |
|
| lnot [Bap_primus.Std.Primus.Value.Make] |
|
| lnot [Bap.Std.Bil.Infix] |
|
| lnot [Bap.Std.Integer.Base] |
lnot x is a logical negation of x (1-complement)
|
| load [Bap_traces.Std.Trace] |
load ~monitor uri fetches trace from a provided uri .
|
| load [Bap_byteweight_signatures] |
load ?comp ?path ~mode arch finds a signature for the specified
arch-comp-path tripple.
|
| load [Bap_primus.Std.Primus.Memory.Make] |
load a loads a byte from the given address a .
|
| load [Bap_primus.Std.Primus.Interpreter.Make] |
load a d s computes a load operation, that loads a word
of size s using an order specified by the endianness d
from address a .
|
| load [Ogre.Doc] |
load chan loads a document from a channel, returns an error if
a document is not well-formed, raises an exception if a system error
has occured.
|
| load [Regular.Std.Data.Cache] |
load cls digest loads entry with a given digest from the
cache.
|
| load [Regular.Std.Data.S.Cache] |
load id load data previously stored under give id
|
| load [Regular.Std.Data.S.Io] |
load ?ver ?fmt channel loads datum from the input channel
|
| load [Bap_plugins.Std.Plugins] |
load ?env ?provides ?library ?exclude is like run , but will not setup
handlers, and will return a result of loading.
|
| load [Bap_plugins.Std.Plugin] |
load plugin load all unsatisfied dependencies of a plugin ,
and then load the plugin itself.
|
| load [Bap.Std.Insn] |
the instruction may load from memory
|
| load [Bap.Std.Eff] |
an expression loads a value from a memory
|
| load [Bap.Std.Bil] |
load ~mem ~addr endian size -> Load (mem,addr,endian,size)
|
| load_all [Regular.Std.Data.S.Io] |
read_all ?ver ?fmt ?rev channel reads a sequence of datums
stored in the storage accessed via channel and returns it as a
list.
|
| loaded [Bap_primus.Std.Primus.Interpreter] |
loaded (addr,value) happens after the value is loaded
from the address addr .
|
| loaded [Bap_plugins.Std.Plugins] |
loaded occurs when all plugins are loaded
|
| loaded [Bap_plugins.Std.Plugin] |
loaded event happens when a pass is succesfully loaded
|
| loading [Bap_primus.Std.Primus.Interpreter] |
loading x happens before a value from the address x is loaded
by the interpreter from the memory.
|
| loads [Bap.Std.Eff] |
|
| localedir [Bap_config] |
|
| localstatedir [Bap_config] |
|
| logand [Bap_primus.Std.Primus.Value.Make] |
|
| logand [Bap.Std.Integer.Base] |
|
| logor [Bap_primus.Std.Primus.Value.Make] |
|
| logor [Bap.Std.Integer.Base] |
logor x y is a disjunction of x and y
|
| logxor [Bap_primus.Std.Primus.Value.Make] |
|
| logxor [Bap.Std.Integer.Base] |
logxor x y is exclusive or between x and y
|
| long_long_of_sexp [Bap_c_type] |
|
| long_of_sexp [Bap_c_type] |
|
| longest_match [Bap.Std.Trie.S] |
longest_match trie key find a value associated with a
longest substring of key .
|
| look [Bap_byteweight.Corpus] |
look data ~length offset extract data of specified length at
the given offset .
|
| lookup [Bap_primus.Std.Primus.Linker.Make] |
lookup name returns code linked with the given name .
|
| lookup [Bap_taint.Std.Taint.Tracker.Make] |
lookup v r returns a set xs of objects that are related
with the value v by the relation r .
|
| lookup [Bap.Std.Program] |
lookup t program id is like find but performs deep
lookup in the whole program for a term with a given id .
|
| lookup [Bap.Std.Memmap] |
lookup map addr returns an ordered sequence of all memory
containing the addr
|
| lookup [Bap.Std.Interval_tree.S] |
lookup t p returns bindings of all intervals that
contain the given point
|
| low [Bap.Std.Bil] |
|
| lower [Bap.Std.Interval_tree.Interval] |
the lower bound of an interval
|
| lowercase [Regular.Std.Bytes] |
lowercase t returns a copy of t , with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
| lr [Arm_env] |
|
| lshift [Bap_primus.Std.Primus.Value.Make] |
|
| lshift [Bap.Std.Bil] |
|
| lshift [Bap.Std.Integer.Base] |
lshift x y shift x by y bits left
|
| lt [Bap.Std.Bil] |
|
M |
| main_bundle [Bap_bundle.Std] |
main_bundle () returns a program's bundle if the program is
bundled, otherwise creates a fresh new bundle in current working
directory.
|
| make [Bap_primus.Std.Primus.Machine.S.Observation] |
make observation event make an observation of the
given event .
|
| make [Regular.Std.Bytes] |
make n c returns a new byte sequence of length n , filled with
the byte c .
|
| malloc [Bap.Std.Sub] |
A subroutine is malloc-like, i.e., the pointer P returned
by the subroutine cannot alias any other pointer valid when the
function returns, and moreover no pointers to valid objects occur
in any storage addressed by P.
|
| mandir [Bap_config] |
|
| manifest [Bap_bundle.Std.Bundle] |
manifest bundle extracts program manifest from the bundle
|
| manpage [Bap.Std.Self.Config] |
Create a manpage for the plugin
|
| many [Bap.Std.Table] |
|
| map [Bap_primus.Std.Primus.Memory.Make] |
map mem maps a memory chunk mem to a segment with the
given permissions.
|
| map [Bap_future.Std.Stream] |
map ss ~f returns new stream, that is build by application
of a function f to each element of the stream ss
|
| map [Bap_future.Std.Applicable.S] |
map xs ~f transform xs with f
|
| map [Monads.Std.Monad.Basic2] |
map function can be derived from bind or provided explicitly
|
| map [Monads.Std.Monad.Basic] |
map function can be derived from bind or provided explicitly
|
| map [Monads.Std.Monad.Collection.S] |
map xs ~f returns a container where n 'th element is a
result of computation f x_n , where x_n is the n 'th
element of the input container.
|
| map [Monads.Std.Monad.Collection.S2] |
map xs ~f returns a container where n 'th element is a
result of computation f x_n , where x_n is the n 'th
element of the input container.
|
| map [Regular.Std.Bytes] |
map s ~f applies function f in turn to all the bytes of s
(in increasing index order) and stores the resulting bytes in
a new sequence that is returned as the result.
|
| map [Bap.Std.Term] |
map t p ~f returns term p with all subterms of type t
mapped with function f
|
| map [Bap.Std.Memmap] |
map m f returns a new map with each tag mapped
with function f
|
| map [Bap.Std.Table] |
map ~start ~until ~f table applies f to elements of
table and builds new table with results returned by f
|
| map [Bap.Std.Stmt] |
map mapper bil applies mapper to the program bil
|
| map [Bap.Std.Exp] |
map mapper exp maps exp tree using provided mapper .
|
| map [Bap.Std.Interval_tree.S] |
map k ~f maps all data values with the function f
|
| map' [Bap_future.Std.Stream] |
s' = map' s ~f apply function f for each value of a
stream s and push values from a resulting queue into the
stream s' .
|
| map_elts [Bap.Std.Blk] |
map_elt ?phi ?def ?jmp blk applies provided functions to the
terms of corresponding classes.
|
| map_exp [Bap.Std.Phi] |
map_exp t ~f applies f to all expressions on the right
hand side of a phi-node t
|
| map_exp [Bap.Std.Jmp] |
map_exp jmp ~f applies f to each expression in a jmp ,
e.g., conditions and indirect labels.
|
| map_exp [Bap.Std.Def] |
map_exp def f applies f to a rhs of def and returns
an updated definition.
|
| map_exp [Bap.Std.Blk] |
map_exp b ~f applies function f for each expression in
block b .
|
| map_lhs [Bap.Std.Blk] |
map_lhs blk ~f applies f to every left hand side variable
in def and phi subterms of blk .
|
| map_reduce [Monads.Std.Monad.Collection.S] |
map_reduce (module Monoid) xs ~f a composition of map
and reduce .
|
| map_reduce [Monads.Std.Monad.Collection.S2] |
map_reduce (module Monoid) xs ~f a composition of map
and reduce .
|
| map_to_array [Bap.Std.Vector] |
map_to_array xs ~f copies data from xs to an array applying
f to each element.
|
| mapi [Regular.Std.Bytes] |
mapi s ~f calls f with each character of s and its
index (in increasing index order) and stores the resulting bytes
in a new sequence that is returned as the result.
|
| mapi [Bap.Std.Memmap] |
mapi m f the same as map , but f is called with two
arguments: mem and tag , where mem is a memory region,
and tag is a tag assosiated with that region.
|
| mapi [Bap.Std.Table] |
mapi ~start ~until ~f table is like Std.Table.map , but
also passes the memory as an argument.
|
| mapi [Bap.Std.Interval_tree.S] |
mapi k ~f maps all bindings with the function f
|
| mapped [Bap.Std.Image.Scheme] |
mapped addr size off sequence of bytes in a file starting at
offset off and has the given size is mapped into memory at the
given address addr
|
| mapper [Bap_api.S] |
|
| mark [Bap.Std] |
|
| marshal_reader [Regular.Std.Data] |
marshal_reader (module T) returns a reader in OCaml
Marshal format.
|
| marshal_writer [Regular.Std.Data] |
marshal_writer (module T) returns a writer in OCaml
Marshal format.
|
| max [Bap_primus.Std.Primus.Iterator.Base] |
maximum value in the iterator domain
|
| max [Bap.Std.Table] |
max tab return the highest binding
|
| max_addr [Bap.Std.Memmap] |
max_addr map is a maximum addr mapped in map
|
| max_addr [Bap.Std.Memory] |
max_addr m is an address of the last byte of m
|
| max_binding [Bap.Std.Memmap] |
max_binding map is a maximum binding mapped in map
|
| max_binding [Bap.Std.Interval_tree.S] |
max_binding t returns the greatest binding in the tree
|
| may [Bap.Std.Insn] |
may propery insn is true if insn has property
|
| maybe_one [Bap.Std.Table] |
|
| mem [X86_env.ModeVars] |
|
| mem [Arm_env] |
mem BIL variable that denotes the system memory.
|
| mem [Graphlib.Std.Edge] |
mem e g is true if e ∈ E.
|
| mem [Graphlib.Std.Node] |
mem n g is true if n is a member of nodes N of graph
g .
|
| mem [Graphlib.Std.Group] |
mem group x checks membership of x in a given group .
|
| mem [Graphlib.Std.Frontier] |
mem f x y is true if y is in a frontier of x
|
| mem [Bap.Std.CPU] |
|
| mem [Bap.Std.Table] |
mem table mem is true if table contains mem region mem
|
| mem [Bap.Std.Dict] |
mem map tag checks membership
|
| mem [Bap.Std.Type] |
mem n m denotes a type of memory storages with
the element type imm m and the index type imm n
|
| mem32_t [Bap.Std] |
mem32_t size creates a type for memory with 32 -bit addresses
and elements of the given size .
|
| mem64_t [Bap.Std] |
mem64_t size creates a type for memory with 64 -bit addresses
and elements of the given size .
|
| mem_insn_of_sexp [Arm_types] |
|
| mem_multi_insn_of_sexp [Arm_types] |
|
| mem_offset_reg_or_imm_neg [Arm_mem_shift] |
|
| mem_offset_reg_or_imm_pos [Arm_mem_shift] |
|
| memory [Bap.Std.Project] |
memory t returns the memory as an interval tree marked with
arbitrary values.
|
| memory [Bap.Std.Block] |
memory blk a memory region, occupied by a block
|
| memory [Bap.Std.Disasm_expert.Basic] |
the memory region we're currently working on
|
| memory [Bap.Std.Image] |
returns memory, annotated with tags
|
| memory_load [Bap_traces.Std.Event] |
an read access to a memory cell
|
| memory_of_segment [Bap.Std.Image] |
memory_of_segment img seg returns a memory region occupied
by the segment seg .
|
| memory_of_symbol [Bap.Std.Image] |
memory_of_symbol sym returns a sequence of memory regions
that belong to the sym symbol.
|
| memory_store [Bap_traces.Std.Event] |
a write access to a memory cell
|
| memref [Bap.Std.Addr] |
memref ?disp ?index ?scale base mimics a memory reference syntax
in gas assembler, dis(base,index,scale)
assembler operation.
|
| merge [Bap_future.Std.Stream] |
merge xs ys f merges streams xs and ys using function
f .
|
| merge [Ogre.Doc] |
merge d1 d2 merges two documents in one.
|
| merge [Bap.Std.Taint] |
merge t1 t2 merge taint maps
|
| merge [Bap.Std.Disasm] |
merge d1 d2 is a union of control flow graphs and erros of
the two disassemblers.
|
| merge [Bap.Std.Memory] |
merge m1 m2 takes two memory regions, that either intersects or
share edges (i.e., difference between min_addr of one of the
blocks and max_addr of another is less then or equal to one, and
returns memory blocks that spans memory starting from the address
min (min_addr m1) (min_addr m2)
and ending with address
max (max_addr m1) (max_addr m2)
.
|
| message [Bap_primus.Std.Primus.Lisp] |
message observation occurs every time a message is sent
from the Primus Machine.
|
| message [Bap.Std.Event.Log] |
message level ~section fmt ... send a message of the
specified level and section .
|
| meta [Bap_traces.Std.Trace] |
meta trace returns all trace attributes as a dictionary
|
| min [Bap_primus.Std.Primus.Iterator.Base] |
minimum value in the iterator domain
|
| min [Bap.Std.Table] |
min tab return the lowest binding
|
| min_addr [Bap.Std.Memmap] |
min_addr map is a minimum addr mapped in map
|
| min_addr [Bap.Std.Memory] |
min_addr m is an address of the first byte of m
|
| min_binding [Bap.Std.Memmap] |
min_binding map is a minimum binding mapped in map
|
| min_binding [Bap.Std.Interval_tree.S] |
min_bining t returns the least binding in the tree
|
| minus [Bap.Std.Bil] |
|
| modload [Bap_traces.Std.Event] |
a module (shared library) is dynamically linked into a host program.
|
| module_name [Regular.Std.Regular.Minimal] |
|
| modulo [Bap_primus.Std.Primus.Value.Make] |
|
| modulo [Bap.Std.Bil] |
|
| modulo [Bap.Std.Integer.Base] |
|
| move [Bap.Std.Bil] |
|
| move_insn_of_sexp [Arm_types] |
|
| msb [Arm_utils] |
|
| mul [Bap_primus.Std.Primus.Value.Make] |
|
| mul [Bap.Std.Integer.Base] |
|
| mult_insn_of_sexp [Arm_types] |
|
| must [Bap.Std.Insn] |
must property insn postulate that insn must have the property
|
| mustn't [Bap.Std.Insn] |
must property insn postulate that insn must not have the property
|
| mxcsr [X86_env] |
mx status control register
|
N |
| name [Bap_traces.Std.Trace.S] |
|
| name [Bap_demangle.Std.Demangler] |
name demangler returns a demangler 's name.
|
| name [Bap_abi] |
|
| name [Bap_primus.Std.Primus.Machine.State] |
name state a state name that was given during the construction.
|
| name [Bap_primus.Std.Primus.Observation.Provider] |
unique name of a provider
|
| name [Bap_primus.Std.Primus.Observation] |
name observation is a name of the observed attribute.
|
| name [Bap_taint.Std.Taint.Kind.Make] |
name k returns the symbolic name of the kind k
|
| name [Bap_plugins.Std.Plugin] |
name plugin is a plugin's name
|
| name [Bap_config] |
|
| name [Bap.Std.Self] |
|
| name [Bap.Std.Project.Pass] |
|
| name [Bap.Std.Sub] |
name sub returns a subroutine name
|
| name [Bap.Std.Term] |
name t returns a string representation of a term t identity
|
| name [Bap.Std.Tid] |
name tid returns a term name: either a string name
with at-prefix, or number identifier.
|
| name [Bap.Std.Insn] |
returns backend specific name of instruction
|
| name [Bap.Std.Disasm_expert.Basic.Insn] |
name insn returns a textual representation of the
instruction name.
|
| name [Bap.Std.Reg] |
|
| name [Bap.Std.Image.Scheme] |
|
| name [Bap.Std.Image.Symbol] |
|
| name [Bap.Std.Image.Segment] |
name segment a name associated with the segment (usually
meaningless).
|
| name [Bap.Std.Value.Tag] |
name cons returns a name of a constructor.
|
| name [Bap.Std.Var] |
name var returns a name assosiated with variable
|
| name [Bap.Std.Bil.Pass] |
name p returns the name of the given pass.
|
| named_region [Bap.Std.Image.Scheme] |
named_region addr size name a region of memory has a name
|
| named_symbol [Bap.Std.Image.Scheme] |
named_symbol addr name a symbol that starts at this addr
has this name .
|
| nativeint [Bap.Std.Self.Config] |
nativeint converts values with Nativeint.of_string .
|
| neg [Bap_primus.Std.Primus.Value.Make] |
|
| neg [Bap.Std.Bil] |
|
| neg [Bap.Std.Integer.Base] |
|
| neq [Bap.Std.Bil] |
|
| new_direct [Bap_taint.Std.Taint.Tracker.Make] |
new_direct v k introduces a new direct relation between the
value v and a freshly created object of the given kind
k .
|