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.insnsDisasm.insn
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 of_basic ?bil insn derives semantics from the machine code instruction.
with_basic mc stores properties of the machine code instruction.
empty is an instruction with no known semantics
returns backend specific name of instruction
target-specific assembler string representing the instruction
returns BIL program specifying instruction semantics
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.
val new_property : 'a -> string -> 'a property new_property must_or_may name creates a new instruction property with the specified name.
the instruction performs a non-regular control flow
under some dynamic condition the instruction may perform a non-regular control flow
the instruction is jump with a target that is not a constant
the instruction is a call to subroutine.
instruction is a return from a call
the instruction has no fall-through
the instruction may perform a non-regular control flow
the instruction may load from memory
the instruction may store to memory
is property insn is true if insn has property
may property insn is true if insn has property
must property insn postulate that insn must have the property
must property insn postulate that insn must not have the property
must property insn postulate that insn may have the property
must property insn postulate that insn shouldn't have the property
val pp_adt : Stdlib .Format.formatter -> t -> 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.sizerval bin_write_t : t Bin_prot .Write.writerval bin_read_t : t Bin_prot .Read.readerval __bin_read_t__ : (int -> t ) Bin_prot .Read.readerval bin_shape_t : Bin_prot .Shape.tval bin_writer_t : t Bin_prot .Type_class.writerval bin_reader_t : t Bin_prot .Type_class.readerval bin_t : t Bin_prot .Type_class.tval t_of_sexp : Sexplib0__ .Sexp.t -> t val sexp_of_t : t -> Sexplib0__ .Sexp.tval to_string : t -> val str : unit -> t -> val pps : unit -> t -> val ppo : Core_kernel .Out_channel.t -> t -> val pp_seq : Stdlib .Format.formatter -> t Core_kernel .Sequence.t-> val pp : Base__ .Formatter.t -> t -> val (>=) : t -> t -> val (<=) : t -> t -> val (<>) : t -> t -> val equal : t -> t -> val compare : t -> t -> val ascending : t -> t -> val descending : t -> t -> val between : t -> low :t -> high :t -> val clamp_exn : t -> min :t -> max :t -> t val clamp : t -> min :t -> max :t -> t Base__ .Or_error.tval validate_lbound : min :t Base__ .Maybe_bound.t-> t Base__ .Validate.checkval validate_ubound : max :t Base__ .Maybe_bound.t-> t Base__ .Validate.checkval validate_bound :
min :t Base__ .Maybe_bound.t-> max :t Base__ .Maybe_bound.t-> t Base__ .Validate.checkval hash_fold_t :
Ppx_hash_lib .Std.Hash.state -> t -> Ppx_hash_lib .Std.Hash.stateval hash : t -> Ppx_hash_lib .Std.Hash.hash_valueval hashable : t Core_kernel__ .Hashtbl.Hashable.tmodule Table : sig ... end type info = string * [ `Ver of string ] * string option val size_in_bytes : ?ver :string -> ?fmt :string -> t -> val of_bytes : ?ver :string -> ?fmt :string -> Regular .Std.bytes -> t val to_bytes : ?ver :string -> ?fmt :string -> t -> Regular .Std.bytesval blit_to_bytes :
?ver :string -> ?fmt :string -> Regular .Std.bytes -> t -> int ->
unitval of_bigstring : ?ver :string -> ?fmt :string -> Core_kernel .bigstring -> t val to_bigstring : ?ver :string -> ?fmt :string -> t -> Core_kernel .bigstringval blit_to_bigstring :
?ver :string -> ?fmt :string -> Core_kernel .bigstring -> t -> int ->
unitmodule Cache : sig ... end val add_reader :
?desc :string -> ver :string -> string ->
t Regular .Std.reader-> val add_writer :
?desc :string -> ver :string -> string ->
t Regular .Std.writer-> val available_readers : unit -> info listval default_reader : unit -> info val set_default_reader : ?ver :string -> string -> unitval with_reader : ?ver :string -> string -> (unit -> 'a ) -> 'a val available_writers : unit -> info listval default_writer : unit -> info val set_default_writer : ?ver :string -> string -> unitval with_writer : ?ver :string -> string -> (unit -> 'a ) -> 'a val default_printer : unit -> info optionval set_default_printer : ?ver :string -> string -> unitval with_printer : ?ver :string -> string -> (unit -> 'a ) -> 'a val find_reader : ?ver :string -> string -> t Regular .Std.readerval find_writer : ?ver :string -> string -> t Regular .Std.writer