package bap-std

  1. Overview
  2. Docs
package bap-std
Legend:
Library
Module
Module type
Parameter
Class
Class type

Assembly instruction.

On a high level, the instruction is a pair of the opcode and operands. A BIL code, that describes semantics of the instruction may be attached to it. Also, semantic tags (or flags) may add further information about the instruction.

The instruction are usually created by a low level machinery, and analyzed on the later stages. So, usually, there is no need to create one manually.

For example, each block is a sequence of instructions (see Block.insns), also with each non-synthetic term there is an an Disasm.insn field, that stores an instruction from which the term was born.

type t = Bap_core_theory.Theory.Program.Semantics.t
include Core_kernel.Bin_prot.Binable.S with type t := t
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
module Slot : sig ... end

Instruction properties.

val of_basic : ?bil:bil -> Disasm_expert.Basic.full_insn -> t

of_basic ?bil insn derives semantics from the machine code instruction.

val with_basic : t -> Disasm_expert.Basic.full_insn -> t

with_basic mc stores properties of the machine code instruction.

  • since 2.2.0
val empty : t

empty is an instruction with no known semantics

val name : t -> string

returns backend specific name of instruction

val asm : t -> string

target-specific assembler string representing the instruction

val bil : t -> bil

returns BIL program specifying instruction semantics

val ops : t -> op array

instruction operands

Instruction properties

A property or a semantic tag is some kind of attribute associated with an instruction. Usually a property is a boolean, it either holds or not. In our case we employ modular logic, and a property can have an intermediate state between true and false. That means, that we have two kinds of relations, strong "must" and weaker "may". The must property is known to be a property associated with the instruction. It is a strong knowledge. For example, if an instruction has jump property, then it is guaranteed to be a jump instruction. On the other hand, the may property represent some uncertain knowledge. For example, the load property is may as it designates that an instruction may access the main memory, or may not access, as it depends on some information, that cannot be deduced statically.

type must =
  1. | Must
type may =
  1. | May
type 'a property
val new_property : 'a -> string -> 'a property

new_property must_or_may name creates a new instruction property with the specified name.

val jump : must property

the instruction performs a non-regular control flow

val conditional : must property

under some dynamic condition the instruction may perform a non-regular control flow

val indirect : must property

the instruction is jump with a target that is not a constant

val call : must property

the instruction is a call to subroutine.

val return : must property

instruction is a return from a call

val barrier : must property

the instruction has no fall-through

val affect_control_flow : may property

the instruction may perform a non-regular control flow

val load : may property

the instruction may load from memory

val store : may property

the instruction may store to memory

val is : must property -> t -> bool

is property insn is true if insn has property

val may : may property -> t -> bool

may property insn is true if insn has property

val must : must property -> t -> t

must property insn postulate that insn must have the property

val mustn't : must property -> t -> t

must property insn postulate that insn must not have the property

val should : may property -> t -> t

must property insn postulate that insn may have the property

val shouldn't : may property -> t -> t

must property insn postulate that insn shouldn't have the property

val pp_adt : Stdlib.Format.formatter -> t -> unit

pp_adt prints instruction in ADT format, suitable for reading by evaluating in many languages, e.g. Python, Js, etc

module Trie : sig ... end
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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct