package bap-std

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Printing

Package contains no libraries

BIL variable.

A variable is a symbolic name, that may have different values during program evaluation. A variable may be virtual, in the sense that it doesn't correspond to some physical location, or it can be physical if a variable is a some physical location, e.g., a register. All variables have types that designate a set of values over which a variable ranges.

BIL variables are regular values. Variables can have indices. Usually the index is used to represent the same variable but at different time or space (control flow path). This is particularly useful for representing variables in SSA form.

By default, comparison function takes indices into account. In order to compare two variables regardless their index use same function, or compare with base x.

Printing

A default pretty printer doesn't print zero indices and never prints types.

type t = var

val reify : 'a Bap_core_theory.Theory.var -> t

reify v reifies a core theory variable into the Bil variable.

val ident : t -> Bap_core_theory.Theory.Var.ident

ident v is the identifier of the variable v

val sort : t -> Bap_core_theory.Theory.Value.Sort.Top.t

sort v returns a core theory sort of the variable v.

val create : ?is_virtual:bool -> ?fresh:bool -> string -> typ -> t

create ?register ?fresh name typ creates a variable with a given name and type.

A newly created variable has version equal to 0.

If fresh is true (defaults to false), then a unique salt is mixed to the name of variable, making it unique.

If is_virtual is true (defaults to false), then a variable is virtual, i.e., it doesn't correspond to some physical register or memory location and was added to a program artificially.

val name : t -> string

name var returns a name associated with variable

val typ : t -> typ

typ var returns a type associated with variable

val is_physical : t -> bool

is_physical v is true if v represents a contents of a physical register.

val is_virtual : t -> bool

is_virtual v is true if v is not physical

val with_index : t -> int -> t

with_index v i returns a variable, that is identical to v, but with the index i

val index : t -> int

index v is an index of v

val base : t -> t

base v returns an original variable. Essentially, identical to with_index v 0.

val same : t -> t -> bool

same x y compares variables ignoring indices, i.e., for variables x and y the same x y is true iff equal (base x) (base y)

implements Regular interface

include Regular.Std.Regular.S
  with type t := t
   and type comparator_witness = Bil.var_compare

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 = Bil.var_compare

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