package bap-core-theory

  1. Overview
  2. Docs

A unit of code.

A unit of code is a generic piece of code, i.e., a set of instructions that share some common properties, such as the instruction set architecture. The whole set of instructions in the knowledge base is partitioned into units, so that each instruction belongs to at most one code unit, see the Label.unit property.

  • since 2.2.0
type cls

the class of all code units

type t = cls KB.Object.t

the meta type of the unit object

val cls : (cls, unit) KB.Class.t

the base class for all units.

Right now we have only one sort of units, indexed with the unit type. But later we may introduce more unit sorts.

val for_file : string -> t Bap_knowledge.knowledge

for_file name creates a new unit denoting a file with the given name.

This function creates a symbol that interns name in the file package and sets the path property to name.

val for_region : lower:word -> upper:word -> t Bap_knowledge.knowledge

for_region ~lower ~upper creates a new unit denoting an anonymous memory region.

The lower and upper labels are interned in the current package and the symbol, built from their concatenation, is interned in the region package. That enables distinguishing between anonymous memory regions that belong to different projects/files but having intersecting set of addresses, provided that every project is setting the current package to some unique name.

val path : (cls, string option) KB.slot

path is the path of the file from which the unit originates.

val bias : (cls, Bitvec.t option) KB.slot

bias is the bias of all addresses in the unit.

If a unit is biased, then all addresses in this unit have Some bias with respect to the real addresses in the unit representation. To obtain the real address the bias shall be subtracted from the address that is stored in the knowledge base. To get the biased address the bias shall be added to the real address.

Any knowledge provider that also operates with the real view on the program must take bias into account.

val target : (cls, Target.t) KB.slot

target the target on which this unit should be executed.

val source : (cls, Source.t) KB.slot

source the source of this unit.

val compiler : (cls, compiler option) KB.slot

compiler the program that translated the unit from the source.

include Bap_knowledge.Knowledge.Object.S with type t := t
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix 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 compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

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

between t ~low ~high means low <= t <= high

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

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness
include Core_kernel.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions 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

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

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

Innovation. Community. Security.