bap-std 2.3.0 · OCaml Package

A control transfer operation.

Jmp is the only way to transfer control from block to block. Jumps are guarded with conditions. The jump should be taken only if its condition is evaluated to true. When control flow reaches the end of block it should take the first jump with true condition. If there is no such jump, then program stops.

Jumps are further subdivided into categories:

goto - is a local control transfer instruction. The label can be only local to subroutine;
call - transfer a control to another subroutine. A call contains a continuation, i.e., a label to which we're hoping to return after subroutine returns the control to us. Of course, called subroutine can in general return to another position, or not to return at all.
ret - performs a return from subroutine
int - calls to interrupt subroutine. If interrupt returns, then continue with the provided label.

type t = jmp term

type dst

val reify : 
  ?tid:tid ->
  ?cnd:Bap_core_theory.Theory.Bool.t Bap_core_theory.Theory.value ->
  ?alt:dst ->
  ?dst:dst ->
  unit ->
  t

reify () reifies inputs into a jump term.

Calls and interrupt subroutines invocations are represented with two edges: the normal edge (denoted dst) is the intra-procedural edge which connects the callsite with the fall-through destination (if such exists) and an alternative destination (denoted with alt) which represents an inter-procedural destination between the callsite and the call destination.

parameter cnd
is a core theory term that denotes the guard condition of a conditional jump.

parameter alt
is the alternative control flow destination.

parameter dst
is the direct control flow destination
@tid is the jump identifier, if not specified a fresh new identifier is created.

val guard : 
  t ->
  Bap_core_theory.Theory.Bool.t Bap_core_theory.Theory.value option

guard jmp if jmp is conditional, returns its condition.

val with_guard : 
  t ->
  Bap_core_theory.Theory.Bool.t Bap_core_theory.Theory.value option ->
  t

with_guard jmp cnd updates the jump condition of jmp.

val dst : t -> dst option

dst jmp returns the intra-procedural destination of jmp.

val alt : t -> dst option

alt jmp returns the inter-procedural destination of jmp.

val resolved : tid -> dst

resolved dst creates a resolved destination.

val indirect : 
  'a Bap_core_theory.Theory.Bitv.t Bap_core_theory.Theory.value ->
  dst

indirect v creates an indirect jump destination.

The destination (or a set of destinations) is encoded with the Core Theory term v.

val resolve : 
  dst ->
  (tid, 'a Bap_core_theory.Theory.Bitv.t Bap_core_theory.Theory.value)
    Core_kernel.Either.t

resolve dst resolves destination.

val create : ?tid:tid -> ?cond:exp -> jmp_kind -> t

create ?cond kind creates a jump of a given kind

val create_call : ?tid:tid -> ?cond:exp -> call -> t

create_call ?cond target transfer control to subroutine target

val create_goto : ?tid:tid -> ?cond:exp -> label -> t

create_goto ?cond label local jump

val create_ret : ?tid:tid -> ?cond:exp -> label -> t

create_ret ?cond label return from a procedure

val create_int : ?tid:tid -> ?cond:exp -> int -> tid -> t

create_int ?cond int_number return call interrupt subroutine

val kind : t -> jmp_kind

kind jmp evaluates to a kind of jump

val cond : t -> exp

cond jmp returns the jump guard condition

val exps : t -> exp seq

exps jmp returns a sequence of expressions occurring in different positions of a jump jmp, e.g., in cond, target, etc.

val free_vars : t -> Var.Set.t

free_vars jmp returns a set of all variables that are free in some expression in the jump jmp.

val map_exp : t -> f:(exp -> exp) -> t

map_exp jmp ~f applies f to each expression in a jmp, e.g., conditions and indirect labels.

val substitute : t -> exp -> exp -> t

substitute jmp x y substitutes x by y in all expressions that occur in jump jmp expressions.

val with_cond : t -> exp -> t

with_cond jmp c updates jump's guard condition

since 2.0.0

val with_kind : t -> jmp_kind -> t

with_kind jmp k updates jump's kind

since 2.0.0

val with_alt : t -> dst option -> t

with_alt jmp d updates jump's inter-procedural destination

since 2.1.0

val with_dst : t -> dst option -> t

with_dst jmp d updates jump's intra-procedural destination

since 2.1.0

val pp_slots : string list -> Stdlib.Format.formatter -> t -> unit

pp_slots names prints slots that are in names.

include Regular.Std.Regular.S with type t := t

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

val bin_shape_t : Bin_prot.Shape.t

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_t : t Bin_prot.Type_class.t

val t_of_sexp : Sexplib0__.Sexp.t -> t

val sexp_of_t : t -> Sexplib0__.Sexp.t

val to_string : t -> string

val str : unit -> t -> string

val pps : unit -> t -> string

val ppo : Core_kernel.Out_channel.t -> t -> unit

val pp_seq : Stdlib.Format.formatter -> t Core_kernel.Sequence.t -> unit

val pp : Base__.Formatter.t -> t -> unit

val (>=) : t -> t -> bool

val (<=) : t -> t -> bool

val (=) : t -> t -> bool

val (>) : t -> t -> bool

val (<) : t -> t -> bool

val (<>) : t -> t -> bool

val equal : t -> t -> bool

val compare : t -> t -> int

val min : t -> t -> t

val max : t -> t -> t

val ascending : t -> t -> int

val descending : t -> t -> int

val between : t -> low:t -> high:t -> bool

val clamp_exn : t -> min:t -> max:t -> t

val clamp : t -> min:t -> max:t -> t Base__.Or_error.t

type comparator_witness

val validate_lbound : min:t Base__.Maybe_bound.t -> t Base__.Validate.check

val validate_ubound : max:t Base__.Maybe_bound.t -> t Base__.Validate.check

val validate_bound : 
  min:t Base__.Maybe_bound.t ->
  max:t Base__.Maybe_bound.t ->
  t Base__.Validate.check

module Replace_polymorphic_compare : sig ... end

val comparator : (t, comparator_witness) Core_kernel__Comparator.comparator

module Map : sig ... end

module Set : sig ... end

val hash_fold_t : 
  Ppx_hash_lib.Std.Hash.state ->
  t ->
  Ppx_hash_lib.Std.Hash.state

val hash : t -> Ppx_hash_lib.Std.Hash.hash_value

val hashable : t Core_kernel__.Hashtbl.Hashable.t

module Table : sig ... end

module Hash_set : sig ... end

module Hash_queue : sig ... end

type info = string * [ `Ver of string ] * string option

val version : string

val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int

val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t

val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes

val blit_to_bytes : 
  ?ver:string ->
  ?fmt:string ->
  Regular.Std.bytes ->
  t ->
  int ->
  unit

val of_bigstring : ?ver:string -> ?fmt:string -> Core_kernel.bigstring -> t

val to_bigstring : ?ver:string -> ?fmt:string -> t -> Core_kernel.bigstring

val blit_to_bigstring : 
  ?ver:string ->
  ?fmt:string ->
  Core_kernel.bigstring ->
  t ->
  int ->
  unit

module Io : sig ... end

module Cache : sig ... end

val add_reader : 
  ?desc:string ->
  ver:string ->
  string ->
  t Regular.Std.reader ->
  unit

val add_writer : 
  ?desc:string ->
  ver:string ->
  string ->
  t Regular.Std.writer ->
  unit

val available_readers : unit -> info list

val default_reader : unit -> info

val set_default_reader : ?ver:string -> string -> unit

val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a

val available_writers : unit -> info list

val default_writer : unit -> info

val set_default_writer : ?ver:string -> string -> unit

val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a

val default_printer : unit -> info option

val set_default_printer : ?ver:string -> string -> unit

val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a

val find_reader : ?ver:string -> string -> t Regular.Std.reader option

val find_writer : ?ver:string -> string -> t Regular.Std.writer option

package bap-std