package bap-std

You can search for identifiers within the package.

in-package search v0.2.0

The Binary Analysis Platform Standard Library

Install

Dune Dependency

github.com Edit opam file Versions (5)

Authors

B

BAP Team

Maintainers

I

Ivan Gotovchits <ivg@ieee.org>

Sources

v2.5.0.tar.gz

sha256=9c126781385d2fa9b8edab22e62b25c70bf2f99f6ec78abb7e5e36d63cfa4174

md5=5abd9b3628b43f797326034f31ca574f

doc/bap/Bap/Std/Block/index.html

Module `Std.Block`

Basic block.

Basic block is piece of code, that has single entry and single exit. It can be seen as a container for instructions. Also, basic blocks are nodes of control flow graphs.

The following invariants must be preserved:

there is no known jump in the program, that points to an instruction that is not a leader of a basic block;
any jump instruction is a terminator of some basic block;
each basic block consists of at least one instruction.

type t = block

include Ppx_compare_lib.Comparable.S with type t := t

val sexp_of_t : t -> Sexplib0.Sexp.t

val create : mem -> (mem * insn) list -> t

create mem insn creates a block Preconditions:

insns <> []

val addr : t -> addr

addr block = Memory.min_addr (memory block) address of the first instruction

val memory : t -> mem

memory blk a memory region, occupied by a block

val leader : t -> insn

leader blk the first instruction

val terminator : t -> insn

terminator blk last instruction of the block

val insns : t -> (mem * insn) list

insns blk returns a list of block instructions.

Since block contains a region of memory, that is not regular, the block itself is also non-regular. But it is, at least, printable.

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

include Core_kernel.Comparable.S with type t := t

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 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 comparator : (t, comparator_witness) Base__.Comparator.comparator

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

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

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

module Replace_polymorphic_compare : sig ... end

module Map : sig ... end

module Set : sig ... end

include Core_kernel.Hashable.S with type t := t

val compare : t Base__Ppx_compare_lib.compare

val hash_fold_t : t Base__Ppx_hash_lib.hash_fold

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

val hashable : t Core__.Hashtbl.Hashable.t

module Table : sig ... end

module Hash_set : sig ... end

module Hash_queue : sig ... end

all the printing stuff, including to_string function

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

val to_string : t -> string

to_string x returns a human-readable representation of x

val str : unit -> t -> string

str () t is formatted output function that matches "%a" conversion format specifier in functions, that prints to string, e.g., sprintf, failwithf, errorf and, surprisingly all Lwt printing function, including Lwt_io.printf and logging (or any other function with type ('a,unit,string,...) formatN`. Example:

Or_error.errorf "type %a is not valid for %a"
    Type.str ty Exp.str exp

val pps : unit -> t -> string

synonym for str

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

will print to a standard output_channel, useful for using in printf, fprintf, etc.

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

prints a sequence of values of type t

this will include pp function from Core that has type t printer, and can be used in Format.printf family of functions

include Core_kernel.Pretty_printer.S with type t := t

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