package bap-std

Package contains no libraries

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

val sexp_of_t : t -> Ppx_sexp_conv_lib.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

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 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

module Map : sig ... end

module Set : sig ... end

val compare : t -> t -> Core_kernel__.Import.int

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

all the printing stuff, including to_string function

include Regular.Std.Printable.S with type t := 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