Module DataFlowPrivate

A module for calculating the number of stars (i.e., *s) needed for various dataflow node toString predicates.

Extra data-flow steps needed for lambda flow analysis.

Holds if flow is allowed to pass from parameter p and back to itself as a side-effect, resulting in a summary from p to itself.

Holds if values stored inside content c are cleared at node n.

Holds if t1 and t2 are compatible, that is, whether data can flow from a node of type t1 to a node of type t2.

Holds if the value that is being tracked is expected to be stored inside content c at node n.

Holds if access paths with c at their head always should be tracked at high precision. This disables adaptive access path precision for such access paths.

Gets a use of the instruction instr that is not ignored for dataflow purposes.

Gets a node that can read the value returned from call with return kind kind.

Gets an approximated value for content c.

Gets the type of the instruction instr.

Gets the maximum number of indirections to use for ElementContent.

Returns the smallest indirection for the type t.

Gets the type of n used for type pruning.

Gets the type of the operand op.

Gets the second-level scope containing the node n, if any.

Gets the instruction that represents the first use of the value of call following a sequence of conversion-like instructions.

Holds if arg is an ArgumentNode of c with position pos.

Holds if p is a ParameterNode of c with position pos.

Holds if data can flow from node1 to node2 in a way that loses the calling context. For example, this would happen with flow through a global or static variable.

Holds if call is a lambda call of kind kind where receiver is the lambda expression.

Holds if creation is an expression that creates a lambda of kind kind for c.

Gets the callable in which this node occurs.

Holds if n should be hidden from path explanations.

Gets the operand that represents the use of the value of call following a sequence of conversion-like instructions, if a unique operand exists.

Gets a string representation of a type returned by getNodeType.

Holds if data can flow from node1 to node2 via a read of f. Thus, node1 references an object with a field f whose value ends up in node2.

Holds if node represents the output node for call.

Holds if data can flow from node1 to node2 via an assignment to f. Thus, node2 references an object with a field f that contains the value of node1.

Holds if data can flow from node1 to node2 via an assignment to f. Thus, node2 references an object with a field f that contains the value of node1.

Holds if the data-flow step from node1 to node2 can be used to determine where side-effects may return from a callable. For C/C++, this means that the step from node1 to node2 not only preserves the value, but also preserves the identity of the value. For example, the assignment to x that reads the value of *p in cpp int* p = ... int x = *p; does not preserve the identity of *p.

A data flow node that occurs as the argument of a call and is passed as-is to the callable. Instance arguments (this pointer) and read side effects on parameters are also included.

A node that performs a type cast.

An approximated Content.

A function call relevant for data flow. This includes calls from source code and calls inside library callables with a flow summary.

A callable, which may be: - a function (that may contain code) - a summarized function (that may contain only FlowSummaryNodes) - a variable (this is used as context for global initialization, and also for the mid-point in interprocedural data flow between a write and read of a global variable in different functions). When flow crosses from one enclosing callable to another, the interprocedural data-flow library discards call contexts and inserts a node in the big-step relation used for human-readable path explanations.

A second-level control-flow scope in a switch or a chained if statement.

A variable that behaves like a global variable.

An instruction, viewed as a node in a data flow graph.

A cut-down DataFlow::Node class that does not depend on the output of SSA. This can thus be safely used in the SSA computations themselves, as well as in construction of other node classes (TIRDataFlowNode).

A value returned from a callable using a return statement, that is, a “normal” return.

An operand, viewed as a node in a data flow graph.

A data flow node that represents the output of a call (for example, a return value) at the call site.

A return kind. A return kind describes how a value can be returned from a callable. For C++, this is simply a function return.

A data flow node that occurs as the result of a ReturnStmt.

A source callable, conceptually, a function in the source code for the purpose of computing data flow. In practice this excludes functions that are summarized using models-as-data (as we don’t want to create unmodeled flows or duplicate paths), and includes variables (for reasons explained in DataFlowCallable).

A summarized callable, that is, a function synthesized from one or more models-as-data models as a place to contain the corresponding FlowSummaryNodes.

An argument node that is part of a summary. These only occur when the summary contains a synthesized call.

A synthesized call inside a callable with a flow summary.

Module that defines flow through iterators. For example, cpp auto it = v.begin(); *it = source(); ... sink(v[0]);

A module for calculating the number of stars (i.e., *s) needed for various dataflow node toString predicates.

An argument position represented by an integer.

A C/C++ expression.

A C/C++ type.

The trivial type with a single element.

A parameter position represented by an integer.