You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
161 lines
3.9 KiB
161 lines
3.9 KiB
/*
|
|
* Copyright (c) 2009 - 2013 Monoidics ltd.
|
|
* Copyright (c) 2013 - present Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
open! IStd;
|
|
|
|
|
|
/** The Smallfoot Intermediate Language: Expressions */
|
|
module L = Logging;
|
|
|
|
module F = Format;
|
|
|
|
type closure = {name: Typ.Procname.t, captured_vars: list (t, Pvar.t, Typ.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.*/
|
|
and sizeof_data = {typ: Typ.t, nbytes: option int, dynamic_length: option t, subtype: Subtype.t}
|
|
/** Program expressions. */
|
|
and t =
|
|
/** Pure variable: it is not an lvalue */
|
|
| Var Ident.t
|
|
/** Unary operator with type of the result if known */
|
|
| UnOp Unop.t t (option Typ.t)
|
|
/** Binary operator */
|
|
| BinOp Binop.t t t
|
|
/** Exception */
|
|
| Exn t
|
|
/** Anonymous function */
|
|
| Closure closure
|
|
/** Constants */
|
|
| Const Const.t
|
|
/** Type cast */
|
|
| Cast Typ.t t
|
|
/** The address of a program variable */
|
|
| Lvar Pvar.t
|
|
/** A field offset, the type is the surrounding struct type */
|
|
| Lfield t Fieldname.t Typ.t
|
|
/** An array index offset: [exp1\[exp2\]] */
|
|
| Lindex t t
|
|
| Sizeof sizeof_data
|
|
[@@deriving compare];
|
|
|
|
|
|
/** Equality for expressions. */
|
|
let equal: t => t => bool;
|
|
|
|
|
|
/** Hash function for expressions. */
|
|
let hash: t => int;
|
|
|
|
|
|
/** Set of expressions. */
|
|
module Set: Caml.Set.S with type elt = t;
|
|
|
|
|
|
/** Map with expression keys. */
|
|
module Map: Caml.Map.S with type key = t;
|
|
|
|
|
|
/** Hashtable with expression keys. */
|
|
module Hash: Caml.Hashtbl.S with type key = t;
|
|
|
|
|
|
/** returns true is index is an array index of arr. */
|
|
let is_array_index_of: t => t => bool;
|
|
|
|
let is_null_literal: t => bool;
|
|
|
|
|
|
/** return true if [exp] is the special this/self expression */
|
|
let is_this: t => bool;
|
|
|
|
let is_zero: t => bool;
|
|
|
|
|
|
/** {2 Utility Functions for Expressions} */
|
|
|
|
/** 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 */
|
|
let texp_to_typ: option Typ.t => t => Typ.t;
|
|
|
|
|
|
/** Return the root of [lexp]. */
|
|
let root_of_lexp: t => t;
|
|
|
|
|
|
/** Get an expression "undefined", the boolean indicates
|
|
whether the undefined value goest into the footprint */
|
|
let get_undefined: bool => t;
|
|
|
|
|
|
/** Checks whether an expression denotes a location using pointer arithmetic.
|
|
Currently, catches array - indexing expressions such as a[i] only. */
|
|
let pointer_arith: t => bool;
|
|
|
|
|
|
/** Integer constant 0 */
|
|
let zero: t;
|
|
|
|
|
|
/** Null constant */
|
|
let null: t;
|
|
|
|
|
|
/** Integer constant 1 */
|
|
let one: t;
|
|
|
|
|
|
/** Integer constant -1 */
|
|
let minus_one: t;
|
|
|
|
|
|
/** Create integer constant */
|
|
let int: IntLit.t => t;
|
|
|
|
|
|
/** Create float constant */
|
|
let float: float => t;
|
|
|
|
|
|
/** Create integer constant corresponding to the boolean value */
|
|
let bool: bool => t;
|
|
|
|
|
|
/** Create expresstion [e1 == e2] */
|
|
let eq: t => t => t;
|
|
|
|
|
|
/** Create expresstion [e1 != e2] */
|
|
let ne: t => t => t;
|
|
|
|
|
|
/** Create expresstion [e1 <= e2] */
|
|
let le: t => t => t;
|
|
|
|
|
|
/** Create expression [e1 < e2] */
|
|
let lt: t => t => t;
|
|
|
|
|
|
/** Extract the ids and pvars from an expression */
|
|
let get_vars: t => (list Ident.t, list Pvar.t);
|
|
|
|
let pp_printenv: Pp.env => (Pp.env => F.formatter => Typ.t => unit) => F.formatter => t => unit;
|
|
|
|
let pp: F.formatter => t => unit;
|
|
|
|
let to_string: t => string;
|