Module InferIR__Exp

The Smallfoot Intermediate Language: Expressions

module F = Format
type closure = {
name : InferIR.Typ.Procname.t;
captured_vars : (t * InferIR.Pvar.t * InferIR.Typ.t) list;
}
type sizeof_data = {
typ : InferIR.Typ.t;
nbytes : int option;
dynamic_length : t option;
subtype : InferIR.Subtype.t;
}

This records information about a sizeof(typ) expression.

nbytes represents the result of the evaluation of sizeof(typ) if it is statically known.

If typ is of the form Tarray elt (Some static_length), then dynamic_length is the number of elements of type elt in the array. The dynamic_length, tracked by symbolic execution, may differ from the static_length obtained from the type definition, e.g. when an array is over-allocated.

If typ is a struct type, the dynamic_length is that of the final extensible array, if any.

type t =
| Var of InferIR.Ident.t

(** Pure variable: it is not an lvalue *)

| UnOp of InferIR.Unop.t * t * InferIR.Typ.t option

(** Unary operator with type of the result if known *)

| BinOp of InferIR.Binop.t * t * t

(** Binary operator *)

| Exn of t

(** Exception *)

| Closure of closure

(** Anonymous function *)

| Const of InferIR.Const.t

(** Constants *)

| Cast of InferIR.Typ.t * t

(** Type cast *)

| Lvar of InferIR.Pvar.t

(** The address of a program variable *)

| Lfield of t * InferIR.Typ.Fieldname.t * InferIR.Typ.t

(** A field offset, the type is the surrounding struct type *)

| Lindex of t * t

(** An array index offset: exp1[exp2] *)

| Sizeof of sizeof_data

Program expressions.

include sig ... end
val compare_closure : closure ‑> closure ‑> int
val compare_sizeof_data : sizeof_data ‑> sizeof_data ‑> int
val compare : t ‑> t ‑> int
val equal : t ‑> t ‑> bool

Equality for expressions.

module Set : InferStdlib.IStd.Caml.Set.S with type Set.elt = t

Set of expressions.

module Map : InferStdlib.IStd.Caml.Map.S with type Map.key = t

Map with expression keys.

module Hash : InferStdlib.IStd.Caml.Hashtbl.S with type Hash.key = t

Hashtable with expression keys.

val is_null_literal : t ‑> bool
val is_this : t ‑> bool

return true if exp is the special this/self expression

val is_zero : t ‑> bool

Utility Functions for Expressions

val texp_to_typ : InferIR.Typ.t option ‑> t ‑> InferIR.Typ.t

Turn an expression representing a type into the type it represents If not a sizeof, return the default type if given, otherwise raise an exception

val root_of_lexp : t ‑> t

Return the root of lexp.

val get_undefined : bool ‑> t

Get an expression "undefined", the boolean indicates whether the undefined value goest into the footprint

val pointer_arith : t ‑> bool

Checks whether an expression denotes a location using pointer arithmetic. Currently, catches array - indexing expressions such as ai only.

val has_local_addr : t ‑> bool

returns true if the expression operates on address of local variable

val zero : t

Integer constant 0

val null : t

Null constant

val one : t

Integer constant 1

val minus_one : t

Integer constant -1

val int : InferIR.IntLit.t ‑> t

Create integer constant

val float : float ‑> t

Create float constant

val bool : bool ‑> t

Create integer constant corresponding to the boolean value

val eq : t ‑> t ‑> t

Create expression e1 == e2

val ne : t ‑> t ‑> t

Create expression e1 != e2

val le : t ‑> t ‑> t

Create expression e1 <= e2

val lt : t ‑> t ‑> t

Create expression e1 < e2

val free_vars : t ‑> InferIR.Ident.t InferStdlib.IStd.Sequence.t

all the idents appearing in the expression

val gen_free_vars : t ‑> (unit, InferIR.Ident.t) InferStdlib.IStd.Sequence.Generator.t
val ident_mem : t ‑> InferIR.Ident.t ‑> bool

true if the identifier appears in the expression

val program_vars : t ‑> InferIR.Pvar.t InferStdlib.IStd.Sequence.t

all the program variables appearing in the expression

val fold_captured : f:('a ‑> t ‑> 'a) ‑> t ‑> 'a ‑> 'a

Fold over the expressions captured by this expression.

val pp_printenv : InferStdlib.Pp.env ‑> (InferStdlib.Pp.env ‑> F.formatter ‑> InferIR.Typ.t ‑> unit) ‑> F.formatter ‑> t ‑> unit
val pp : F.formatter ‑> t ‑> unit
val to_string : t ‑> string
val is_objc_block_closure : t ‑> bool
val zero_of_type : InferIR.Typ.t ‑> t option

Returns the zero value of a type, for int, float and ptr types

val zero_of_type_exn : InferIR.Typ.t ‑> t