|
ESBMC
Efficient SMT-based Context-Bounded Model Checker
|
Public Member Functions | |
| __init__ (self, module, analysis, roots) | |
| check_uses (self) | |
| check_param_holders (self) | |
Public Attributes | |
| module = module | |
| parents = _parents(module) | |
| dict | functions = {} |
| list | groups = [] |
| dict | holders = {} |
| dict | param_holders = {} |
| local_fns = set() | |
| defs = defs | |
| callable_names = set(self.functions) | set(self.param_holders) | |
| dict | kinds = {} |
| dict | values = {} |
Protected Member Functions | |
| _add_holders (self, analysis, root, group, defs) | |
| _add_param_holder (self, analysis, fn, param, group) | |
| _collect_bindings (self) | |
| _bind (self, target, value) | |
| _kind (self, name, seen) | |
| _value_kind (self, expr, seen) | |
| _literal_kind (self, literal, seen) | |
| _is_element (cls, expr) | |
| _element_kind (self, expr) | |
| _nested (self, node) | |
| _check_use (self, node) | |
| _is_returned_read (self, node) | |
| _is_flat (self, fn, name) | |
| _is_returned_callee (self, top, call, node) | |
| _enclosing_def (self, node) | |
| _check_variable (self, var, is_param, group, nodes) | |
| _check_variable_use (self, use, group, is_param) | |
| _check_dispatched_arguments (self, call) | |
| _is_function_value (self, expr, site) | |
| _variables_at (self, node) | |
| _check_returned_call (self, use, group) | |
| _check_store (self, node) | |
| _check_function_holder (self, node, parent) | |
| _check_container_holder (self, node, parent) | |
| _check_element (self, element) | |
| _check_element_store (self, element, assign) | |
| _is_membership (self, parent, node) | |
| _is_update (self, attribute, node) | |
| _assign_target (self, node) | |
| _plain_targets (self, assign) | |
| _plain_target (self, target) | |
| _check_value (self, expr) | |
| _is_dispatched_argument (self, parent, expr) | |
| _is_plain_value (self, parent, expr) | |
| _check_identity (self, compare) | |
| _check_value_list (self, literal) | |
| _is_update_value (self, call, literal) | |
| _is_code (self, expr) | |
| _check_site (self, call) | |
| _check_arguments (self, call, group) | |
| _site_holder (self, call) | |
| _check_always_evaluated (self, call) | |
Static Protected Member Functions | |
| _is_dict_value (parent, expr) | |
Check that every use of the groups' names can be rewritten, and mark them.
| preprocessor.function_value_dispatch._Plan.__init__ | ( | self, | |
| module, | |||
| analysis, | |||
| roots ) |
|
protected |
Record the module names and parameters in `root`'s group; refuse any other value.
|
protected |
Record a parameter or local of a module-level def, which the def may dispatch on.
|
protected |
Whether `node` is bound by an assignment whose value for it can be read off.
|
protected |
|
protected |
Only a call evaluated whenever its statement is may be dispatched before it.
|
protected |
Every function of `group` takes exactly the positional arguments of `call`.
|
protected |
|
protected |
Every parameter of the callee that is dispatched on gets a function positionally.
|
protected |
The outermost element `xs[i]...` is a store target, a callee or a value.
|
protected |
`xs[i] = value` stores a value as deep as the elements of `xs`.
|
protected |
|
protected |
`compare` tests two codes for identity or equality.
|
protected |
`use` is the callee of a call that is a whole `return`; mark that return.
|
protected |
A call through a holder: every function of its group must take its arguments.
|
protected |
|
protected |
|
protected |
`expr`, a function or an element, flows only where a code can stand for it.
|
protected |
|
protected |
|
protected |
A load is a returned call or an argument to dispatch on; a store assigns a function.
|
protected |
|
protected |
How deep the value of the element `expr` nests functions, or None.
|
protected |
The module-level def that contains `node` with no scope in between, or None.
|
protected |
|
staticprotected |
|
protected |
Whether `expr` is passed positionally to a parameter that the callee dispatches on.
|
protected |
`xs[i]`, possibly nested, with a name or literal index, whose evaluation has no effects.
|
protected |
Whether `fn` has no nested scope and does not bind `name`.
|
protected |
Whether `expr`, evaluated at `site`, is a function or a dispatched variable of its def.
|
protected |
|
protected |
Whether `expr` is the whole value of an assignment to names.
|
protected |
|
protected |
A module holder read in a flat module-level def only as the callee of its `return`.
|
protected |
`xs.update(literal)` or `xs.setdefault(key, value)` as a statement, deep as `xs`.
|
protected |
Whether `literal` is stored by a call that `_is_update` accepts.
|
protected |
How deep `name` nests functions: 0 for a function, 1 for a list or dict of them.
|
protected |
|
protected |
|
protected |
|
protected |
Whether every target of `assign` is a name, an element or a tuple of them.
|
protected |
The holder `call` goes through, refusing an index another scope may rebind.
|
protected |
|
protected |
The dispatched variables of the module-level def that contains `node`.
| preprocessor.function_value_dispatch._Plan.check_param_holders | ( | self | ) |
Each def with a dispatched parameter or local uses it only where it can be a code.
| preprocessor.function_value_dispatch._Plan.check_uses | ( | self | ) |
| preprocessor.function_value_dispatch._Plan.callable_names = set(self.functions) | set(self.param_holders) |
| preprocessor.function_value_dispatch._Plan.defs = defs |
| dict preprocessor.function_value_dispatch._Plan.functions = {} |
| list preprocessor.function_value_dispatch._Plan.groups = [] |
| dict preprocessor.function_value_dispatch._Plan.holders = {} |
| dict preprocessor.function_value_dispatch._Plan.kinds = {} |
| preprocessor.function_value_dispatch._Plan.local_fns = set() |
| preprocessor.function_value_dispatch._Plan.module = module |
| dict preprocessor.function_value_dispatch._Plan.param_holders = {} |
| dict preprocessor.function_value_dispatch._Plan.values = {} |