| call_id | |
| FileIdentifier | |
| Identifier | |
| il::_namespace_context | |
| il::addressof_expression | &exp |
| il::array_ref_expression | Represents a reference to any non-pointer array |
| il::array_type | Abstract class representing a non-pointer array type |
| il::assembly | Inline assembly |
| il::base_type | Represents base types like integer and float |
| il::binop_expression | An expression of the form exp1 binop exp2 |
| il::block | Represents a block statement {decls; S1; ... ; S_k} |
| il::block_expression | This is used to model a gcc extension where you can write code like a = ({args[1]+1;args[2];}); ({args[1]+1;args[2];}) evaluates to the result of the last statement in the block |
| il::break_statement | Represents a break construct |
| il::builtin_expression | Used to model "built-in" gcc expressions such as va_arg() |
| il::case_label | A case label |
| il::cast_expression | Represents a cast (t) exp |
| il::complex_const_exp | Complex number representation |
| il::complex_type | Type of a complex number |
| il::conditional_expression | Conditional expression of the form exp ? a :b |
| il::const_expression | An abstract class representing integer, real or string constants |
| il::constarray_type | The size of a const_array is known at compile time |
| il::continue_statement | A continue construct inside a loop |
| il::control_statement | An abstract class representing any control statement |
| il::declaration | An abstract class representing variable and function decalarations |
| il::deref_expression | A pointer dereference expression of the form *exp |
| il::do_while_loop | A do while loop construct |
| il::enum_info | |
| il::enum_type | Represents an enum type |
| il::expr_list_expression | An expression list expression consists of comma separated expressions as in i++, j++ in a for loop |
| il::expression | An abstract class that all different expressions inherit from |
| il::expression_instruction | Expression used as an instruction such as i++; |
| il::field_ref_expression | A field reference expression of the form exp.field The field is represented as a record_info |
| il::file | File representation |
| il::fixed_const_exp | Decimal constant representation |
| il::for_loop | A for loop construct |
| il::function_address_expression | Result of taking the address of a function |
| il::function_call_expression | A function call |
| il::function_declaration | Represents a function declaration |
| il::function_pointer_call_expression | Represents a function pointer invocation |
| il::function_type | Represents a function type |
| il::goto_statement | A goto statement |
| il::if_statement | The representation of an if statement |
| il::initializer_list_expression | An initializer list expression such as struct point {int x; int y;} p = {1, 2}; |
| il::instruction | |
| il::integer_const_exp | Representation of an integer constant |
| il::label | A label |
| il::location | A location in the source file is identified by its starting and ending lines and byte offsets for the start and end lines |
| il::modify_expression | Used to model C feature where set statements can be used as expressions, e.g., c = (a=b) |
| il::namespace_context | |
| il::node | Represents a generic AST node, such as a statement, expression, declaration etc |
| il::noop_instruction | A noop instruction |
| il::pointer_type | Pointer to type elem_type |
| il::real_const_exp | A real constant expression |
| il::record_info | Represents struct fields (name,offset etc.) |
| il::record_type | Struct, class, union |
| il::return_statement | Return exp; |
| il::set_instruction | Lhs = rhs; |
| il::statement | |
| il::string_const_exp | A string constant |
| il::switch_statement | The switch construct |
| il::ta_data | |
| il::throw_expression | &exp |
| il::translation_unit | A translation unit consists of one or more files |
| il::try_catch_statement | The representation of an try-catch statement |
| il::try_finally_statement | The representation of a try-finally statement |
| il::type | Parent class of all the concrete types |
| il::type::type_eq | |
| il::type::type_hash | |
| il::unop_expression | An expression of the form (unop exp) |
| il::vararray_type | Size of a vararray may not be known at compile time |
| il::variable | Representation of a program variable |
| il::variable_declaration | Represents a variable declaration, possibly containing an initialization expression |
| il::variable_expression | A variable expression |
| il::vector_const_exp | A vector constant expression |
| il::vector_type | GCC vector type |
| il::while_loop | A while loop construct |
| sail::AddressLabel | V = &label. This is used for modeling a GNU C extension that allows taking address of labels |
| sail::AddressString | V = &str_constant |
| sail::AddressVar | V = &s. Note that the left hand side is a symbol rather than a variable because taking the address of constants is legal in C |
| sail::ArrayRefRead | V1 = v2[index].(f1 ... .fk); field selectors are optional -- this instruction includes field selectors only if ALLOW_OFFSETS is enabled |
| sail::ArrayRefWrite | V1[index].(f1...fk) = s. Field selectors are optional and appear only if ALLOW_OFFSETS is enabled |
| sail::Assembly | Represents inline assembly |
| sail::Assignment | V = s |
| sail::Assume | Assume(predicate) serves as an annotation for static analysis |
| sail::AssumeSize | A convenience instruction for annotating buffer sizes. assume_size(b, s) indicates size of buffer b is s (in bytes) |
| sail::BasicBlock | Represents a basic block in the CFG |
| sail::Binop | An instruction of the form v = s1 binop s2 |
| sail::Block | An abstract class that BasicBlock and SuperBlock inherit from |
| sail::Branch | A branch instruction is of the form s1!=0 : l1, s2!=0 : l_2 , ... s_k!=0:l_k |
| sail::Cast | A cast instruction of the form v = (T) s |
| sail::Cfg | Representation of a control flow graph |
| sail::CfgEdge | Represents an edge from a source block to a target block possibly labeled with some condition |
| sail::Compare | |
| sail::CompareBlock | |
| sail::CompareEdge | |
| sail::Constant | Represents a constant |
| sail::DropVariable | This instruction is optional and marks the last use of temporaries introduced by SAIL |
| sail::FieldRefRead | Represents a field read instruction of the form v1 = v2.f1. ... .fk |
| sail::FieldRefWrite | Represents a field write of the form v.f1...fk = s |
| sail::Function | Representation of a function in the low-level language. Most of the work of translating the high-level language to the low-level language is done here |
| sail::FunctionCall | Represents a function call instruction of the form ret = f(s1, ... ,sn) |
| sail::FunctionPointerCall | A function pointer call instruction is of the form ret = (*fn_ptr)(s1, ... sk) |
| sail::Instruction | All low-level instructions defined by SAIL inherit from Instruction |
| sail::Jump | Jump instruction to some label |
| sail::Label | A label represented by the string label_name |
| sail::Load | A load instruction of of the form v1 = *s.(f1...f_k) The field selectors are optional and only generated if ALLOW_OFFSETS enabled |
| sail::Loop | |
| sail::LoopCompare | |
| sail::LoopInvocationInstruction | In SAIL loops can be treated as tail-recursive functions; this instruction represents a tail-recursive invocation of the loop body and corresponds to a back-edge |
| sail::SaveInstruction | |
| sail::Serializer | This class can be used to serialize a translation unit |
| sail::StaticAssert | A static assert instruction of the form static_assert(predicate) tells the static analysis to check whether this predicate holds |
| sail::Store | A store instruction is of the form *s1.f1...fn = s2. Field selectors are optional and only appear if ALLOW_OFFSETS is enabled |
| sail::SummaryUnit | A summary unit is either a function or a super block, i.e. any piece of code for which an analysis generates a summary |
| sail::SuperBlock | This is the structured representation of a loop with a single exit point |
| sail::Symbol | Represents either a variable or a constant |
| sail::T1T2Block | |
| sail::ToposortBlock | |
| sail::TranslationUnit | Represents a single translation unit |
| sail::Unop | An instruction of the form v = (unop) s |
| sail::Variable | Represents a variable, which can be either an actual program variable or a temporary introduced by SAIL |
| Serializable | |
