TODO
A statement, in GCC’s Gimple representation.
The __str__ method is implemented using GCC’s own pretty-printer for gimple, so e.g.:
str(stmt)
might return:
'D.3259 = (long unsigned int) i;'
Source code location of this statement, as a gcc.Location (or None)
The lexical block holding this statement, as a gcc.Tree
The type of the main expression computed by this statement, as a gcc.Tree (which might be gcc.VoidType)
A string representation of this statement, like str(), but without including any internal UIDs.
This is intended for use in selftests that compare output against some expected value, to avoid embedding values that change into the expected output.
For example, given an assignment to a temporary, the str(stmt) for the gcc.GimpleAssign might be:
'D.3259 = (long unsigned int) i;'
where the UID “3259” is liable to change from compile to compile, whereas the stmt.str_no_uid has value:
'D.xxxx = (long unsigned int) i;'
which won’t arbitrarily change each time.
Visit all gcc.Tree nodes associated with this statement, potentially more than once each. This will visit both the left-hand-side and right-hand-side operands of the statement (if any), and recursively visit any of their child nodes.
For each node, the callback is invoked, supplying the node, and any extra positional and keyword arguments passed to walk_tree:
callback(node, *args, **kwargs)
If the callback returns a true value, the traversal stops, and that gcc.Tree is the result of the call to walk_tree. Otherwise, the traversal continues, and walk_tree eventually returns None.
Subclass of gcc.Gimple: an assignment of an expression to an l-value
Left-hand-side of the assignment, as a gcc.Tree
The operands on the right-hand-side of the expression, as a list of gcc.Tree instances
The kind of the expression, as an gcc.Tree subclass (the type itself, not an instance)
Subclass of gcc.Gimple: an invocation of a function, assigning the result to an l-value
Left-hand-side of the assignment, as a gcc.Tree
The operands on the right-hand-side of the expression, as a list of gcc.Tree instances
The function being called, as a gcc.Tree
The declaration of the function being called (if any), as a gcc.Tree
The arguments for the call, as a list of gcc.Tree
(boolean) Has this call been marked as not returning? (e.g. a call to exit)
Subclass of gcc.Gimple: a “return” statement, signifying the end of a gcc.BasicBlock
The return value, as a gcc.Tree
Subclass of gcc.Gimple: a conditional jump, of the form:
if (LHS EXPRCODE RHS) goto TRUE_LABEL else goto FALSE_LABEL
Left-hand-side of the comparison, as a gcc.Tree
The comparison predicate, as a gcc.Comparison subclass (the type itself, not an instance). For example, the gcc.GimpleCond statement for this fragment of C code:
if (a == b)
would have stmt.exprcode == gcc.EqExpr
The right-hand-side of the comparison, as a gcc.Tree
The gcc.LabelDecl node used as the jump target for when the comparison is true
The gcc.LabelDecl node used as the jump target for when the comparison is false
Note that a C conditional of the form:
if (some_int) {suiteA} else {suiteB}
is implicitly expanded to:
if (some_int != 0) {suiteA} else {suiteB}
and this becomes a gcc.GimpleCond with lhs as the integer, exprcode as <type ‘gcc.NeExpr’>, and rhs as gcc.IntegerCst(0).
Subclass of gcc.Gimple used in the SSA passes: a “PHI” or “phoney” function, for merging the various possible values a variable can have based on the edge that we entered this gcc.BasicBlock on.
Left-hand-side of the assignment, as a gcc.Tree (generally a gcc.SsaName, I believe)
Subclass of gcc.Gimple: a switch statement, signifying the end of a gcc.BasicBlock
- labels¶
The labels of the switch statement, as a list of gcc.CaseLabelExpr.
The initial label in the list is always the default.