gcc.Tree and its subclasses

The various language front-ends for GCC emit “tree” structures (which I believe are actually graphs), used throughout the rest of the internal representation of the code passing through GCC.

class gcc.Tree

A gcc.Tree is a wrapper around GCC’s tree type

debug()

Dump the tree to stderr, using GCC’s own diagnostic routines

type

Instance of gcc.Tree giving the type of the node

addr

(long) The address of the underlying GCC object in memory

The __str__ method is implemented using GCC’s own pretty-printer for trees, so e.g.:

str(t)

might return:

'int <T531> (int, char * *)'

for a gcc.FunctionDecl

str_no_uid

A string representation of this object, 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 the type declaration above, where str(t) might return:

'int <T531> (int, char * *)'

where the UID “531” is liable to change from compile to compile, whereas t.str_no_uid has value:

'int <Txxx> (int, char * *)'

which won’t arbitrarily change each time.

There are numerous subclasses of gcc.Tree, some with numerous subclasses of their own. Some important parts of the class hierarchy include:

Subclass Meaning
gcc.Binary A binary arithmetic expression, with numerous subclasses
gcc.Block A symbol-binding block
gcc.Comparison A relational operators (with various subclasses)
gcc.Constant Subclasses for constants
gcc.Constructor An aggregate value (e.g. in C, a structure or array initializer)
gcc.Declaration Subclasses relating to declarations (variables, functions, etc)
gcc.Expression Subclasses relating to expressions
gcc.IdentifierNode A name
gcc.Reference Subclasses for relating to reference to storage (e.g. pointer values)
gcc.SsaName A variable reference for SSA analysis
gcc.Statement Subclasses for statement expressions, which have side-effects
gcc.Type Subclasses for describing the types of variables
gcc.Unary Subclasses for unary arithmetic expressions

Note

Each subclass of gcc.Tree is typically named after either one of the enum tree_code_class or enum tree_code values, with the names converted to Camel Case:

For example a gcc.Binary is a wrapper around a tree of type tcc_binary, and a gcc.PlusExpr is a wrapper around a tree of type PLUS_EXPR.

As of this writing, only a small subset of the various fields of the different subclasses have been wrapped yet, but it’s generally easy to add new ones. To add new fields, I’ve found it easiest to look at gcc/tree.h and gcc/print-tree.c within the GCC source tree and use the print_node function to figure out what the valid fields are. With that information, you should then look at generate-tree-c.py, which is the code that generates the Python wrapper classes (it’s used when building the plugin to create autogenerated-tree.c). Ideally when exposing a field to Python you should also add it to the API documentation, and add a test case.

gccutils.pformat(tree)

This function attempts to generate a debug dump of a gcc.Tree and all of its “interesting” attributes, recursively. It’s loosely modelled on Python’s pprint module and GCC’s own debug_tree diagnostic routine using indentation to try to show the structure.

It returns a string.

It differs from gcc.Tree.debug() in that it shows the Python wrapper objects, rather than the underlying GCC data structures themselves. For example, it can’t show attributes that haven’t been wrapped yet.

Objects that have already been reported within this call are abbreviated to “…” to try to keep the output readable.

Example output:

<FunctionDecl
  repr() = gcc.FunctionDecl('main')
  superclasses = (<type 'gcc.Declaration'>, <type 'gcc.Tree'>)
  .function = gcc.Function('main')
  .location = /home/david/coding/gcc-python/test.c:15
  .name = 'main'
  .type = <FunctionType
            repr() = <gcc.FunctionType object at 0x2f62a60>
            str() = 'int <T531> (int, char * *)'
            superclasses = (<type 'gcc.Type'>, <type 'gcc.Tree'>)
            .name = None
            .type = <IntegerType
                      repr() = <gcc.IntegerType object at 0x2f629d0>
                      str() = 'int'
                      superclasses = (<type 'gcc.Type'>, <type 'gcc.Tree'>)
                      .const = False
                      .name = <TypeDecl
                                repr() = gcc.TypeDecl('int')
                                superclasses = (<type 'gcc.Declaration'>, <type 'gcc.Tree'>)
                                .location = None
                                .name = 'int'
                                .pointer = <PointerType
                                             repr() = <gcc.PointerType object at 0x2f62b80>
                                             str() = ' *'
                                             superclasses = (<type 'gcc.Type'>, <type 'gcc.Tree'>)
                                             .dereference = ... ("gcc.TypeDecl('int')")
                                             .name = None
                                             .type = ... ("gcc.TypeDecl('int')")
                                           >
                                .type = ... ('<gcc.IntegerType object at 0x2f629d0>')
                              >
                      .precision = 32
                      .restrict = False
                      .type = None
                      .unsigned = False
                      .volatile = False
                    >
          >
>
gccutils.pprint(tree)

Similar to gccutils.pformat(), but prints the output to stdout.

(should this be stderr instead? probably should take a stream as an arg, but what should the default be?)

Blocks

class gcc.Block

A symbol binding block, such as the global symbols within a compilation unit.

vars

The list of gcc.Tree for the declarations and labels in this block

Declarations

class gcc.Declaration

A subclass of gcc.Tree indicating a declaration

Corresponds to the tcc_declaration value of enum tree_code_class within GCC’s own C sources.

name

(string) the name of this declaration

location

The gcc.Location for this declaration

is_artificial

(bool) Is this declaration a compiler-generated entity, rather than one provided by the user?

An example of such an “artificial” declaration occurs within the arguments of C++ methods: the initial this argument is a compiler-generated gcc.ParmDecl.

is_builtin

(bool) Is this declaration a compiler-builtin?

class gcc.FieldDecl

A subclass of gcc.Declaration indicating the declaration of a field within a structure.

name

(string) The name of this field

class gcc.FunctionDecl

A subclass of gcc.Declaration indicating the declaration of a function. Internally, this wraps a (struct tree_function_decl *)

function

The gcc.Function for this declaration

arguments

List of gcc.ParmDecl representing the arguments of this function

result

The gcc.ResultDecl representing the return value of this function

fullname

Note

This attribute is only usable with C++ code. Attempting to use it from another language will lead to a RuntimeError exception.

(string) The “full name” of this function, including the scope, return type and default arguments.

For example, given this code:

namespace Example {
    struct Coord {
        int x;
        int y;
    };

    class Widget {
    public:
        void set_location(const struct Coord& coord);
    };
};

set_location’s fullname is:

'void Example::Widget::set_location(const Example::Coord&)'
callgraph_node

The gcc.CallgraphNode for this function declaration, or None

is_public

(bool) For C++: is this declaration “public”

is_private

(bool) For C++: is this declaration “private”

is_protected

(bool) For C++: is this declaration “protected”

is_static

(bool) For C++: is this declaration “static”

class gcc.ParmDecl

A subclass of gcc.Declaration indicating the declaration of a parameter to a function or method.

class gcc.ResultDecl

A subclass of gcc.Declaration declararing a dummy variable that will hold the return value from a function.

class gcc.VarDecl

A subclass of gcc.Declaration indicating the declaration of a variable (e.g. a global or a local).

initial

The initial value for this variable as a gcc.Constructor, or None

static

(boolean) Is this variable to be allocated with static storage?

class gcc.NamespaceDecl

A subclass of gcc.Declaration representing a C++ namespace

alias_of

The gcc.NamespaceDecl which this namespace is an alias of or None if this namespace is not an alias.

declarations

Note

This attribute is only usable with non-alias namespaces. Accessing it on an alias will lead to a RuntimeError exception.

List of gcc.Declaration objects in this namespace. This attribute is only valid for non-aliases

namespaces

Note

This attribute is only usable with non-alias namespaces. Accessing it on an alias will lead to a RuntimeError exception.

List of gcc.NamespaceDecl objects nested in this namespace. This attribute is only valid for non-aliases

lookup(name)

Locate the given name within the namespace, returning a gcc.Tree or None

unalias()

Always returns a gcc.NamespaceDecl object which is not an alias. Returns self if this namespace is not an alias.

Types

class gcc.Type

A subclass of gcc.Tree indicating a type

Corresponds to the tcc_type value of enum tree_code_class within GCC’s own C sources.

name

The gcc.IdentifierNode for the name of the type, or None.

pointer

The gcc.PointerType representing the (this_type *) type

attributes

The user-defined attributes on this type (using GCC’s __attribute syntax), as a dictionary (mapping from attribute names to list of values). Typically this will be the empty dictionary.

sizeof

sizeof() this type, as an int, or raising TypeError for those types which don’t have a well-defined size

Note

This attribute is not usable from within lto1; attempting to use it there will lead to a RuntimeError exception.

Additional attributes for various gcc.Type subclasses:

const

(Boolean) Does this type have the const modifier?

const_equivalent

The gcc.Type for the const version of this type

volatile

(Boolean) Does this type have the volatile modifier?

volatile_equivalent

The gcc.Type for the volatile version of this type

restrict

(Boolean) Does this type have the restrict modifier?

restrict_equivalent

The gcc.Type for the restrict version of this type

unqualified_equivalent

The gcc.Type for the version of this type that does not have any qualifiers.

The standard C types are accessible via class methods of gcc.Type. They are only created by GCC after plugins are loaded, and so they’re only visible during callbacks, not during the initial run of the code. (yes, having them as class methods is slightly clumsy).

Each of the following returns a gcc.Type instance representing the given type (or None at startup before any passes, when the types don’t yet exist)

Class method C Type
gcc.Type.void() void
gcc.Type.size_t() size_t
gcc.Type.char() char
gcc.Type.signed_char() signed char
gcc.Type.unsigned_char() unsigned char
gcc.Type.double() double
gcc.Type.float() float
gcc.Type.short() short
gcc.Type.unsigned_short() unsigned short
gcc.Type.int() int
gcc.Type.unsigned_int() unsigned int
gcc.Type.long() long
gcc.Type.unsigned_long() unsigned long
gcc.Type.long_double() long double
gcc.Type.long_long() long long
gcc.Type.unsigned_long_long() unsigned long long
gcc.Type.int128() int128
gcc.Type.unsigned_int128() unsigned int128
gcc.Type.uint32() uint32
gcc.Type.uint64() uint64
class gcc.IntegerType

Subclass of gcc.Type, adding a few properties:

unsigned

(Boolean) True for ‘unsigned’, False for ‘signed’

precision

(int) The precision of this type in bits, as an int (e.g. 32)

signed_equivalent

The gcc.IntegerType for the signed version of this type

Note

This attribute is not usable from within lto1; attempting to use it there will lead to a RuntimeError exception.

unsigned_equivalent

The gcc.IntegerType for the unsigned version of this type

Note

This attribute is not usable from within lto1; attempting to use it there will lead to a RuntimeError exception.

max_value

The maximum possible value for this type, as a gcc.IntegerCst

min_value

The minimum possible value for this type, as a gcc.IntegerCst

class gcc.FloatType

Subclass of gcc.Type representing C’s float and double types

precision

(int) The precision of this type in bits (32 for float; 64 for double)

class gcc.PointerType

Subclass of gcc.Type representing a pointer type, such as an int *

dereference

The gcc.Type that this type points to. In the above example (int *), this would be the int type.

class gcc.EnumeralType

Subclass of gcc.Type representing an enumeral type.

values

A list of tuple representing the constants defined in this enumeration. Each tuple consists of two elements; the first being the name of the constant, a gcc.IdentifierNode; and the second being the value, a gcc.Constant.

class gcc.ArrayType

Subclass of gcc.Type representing an array type. For example, in a C declaration such as:

char buf[16]

we have a gcc.VarDecl for buf, and its type is an instance of gcc.ArrayType, representing char [16].

dereference

The gcc.Type that this type points to. In the above example, this would be the char type.

range

The gcc.Type that represents the range of the array’s indices. If the array has a known range, then this will ordinarily be an gcc.IntegerType whose min_value and max_value are the (inclusive) bounds of the array. If the array does not have a known range, then this attribute will be None.

That is, in the example above, range.min_val is 0, and range.max_val is 15.

But, for a C declaration like:

extern char array[];

the type’s range would be None.

class gcc.VectorType
dereference

The gcc.Type that this type points to

class gcc.FunctionType

Subclass of gcc.Type representing the type of a given function (or or a typedef to a function type, e.g. for callbacks).

See also gcc.FunctionType

The type attribute holds the return type.

is_variadic

True if this type represents a variadic function. Note that for a variadic function, the final argument is not explicitly represented in argument_types.

argument_types

A tuple of gcc.Type instances, representing the function’s argument types

gccutils.get_nonnull_arguments(funtype)

This is a utility function for working with the “nonnull” custom attribute on function types:

http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

Return a frozenset of 0-based integers, giving the arguments for which we can assume “nonnull-ness”, handling the various cases of:

  • the attribute isn’t present (returning the empty frozenset)
  • the attribute is present, without args (all pointer args are non-NULL)
  • the attribute is present, with a list of 1-based argument indices (Note that the result is still 0-based)
class gcc.MethodType

Subclass of gcc.Type representing the type of a given method. Similar to gcc.FunctionType

The type attribute holds the return type.

argument_types

A tuple of gcc.Type instances, representing the function’s argument types

class gcc.RecordType

A compound type, such as a C struct

fields

The fields of this type, as a list of gcc.FieldDecl instances

methods

The methods of this type, as a list of gcc.MethodType instances

You can look up C structures by looking within the top-level gcc.Block within the current translation unit. For example, given this sample C code:

/* Example of a struct: */
struct test_struct {
    int a;
    char b;
    float c;
};

void foo()
{
}

then the following Python code:

import gcc

class TestPass(gcc.GimplePass):
    def execute(self, fn):
        print('fn: %r' % fn)
        for u in gcc.get_translation_units():
            for decl in u.block.vars:
                if isinstance(decl, gcc.TypeDecl):
                    # "decl" is a gcc.TypeDecl
                    # "decl.type" is a gcc.RecordType:
                    print('  type(decl): %s' % type(decl))
                    print('  type(decl.type): %s' % type(decl.type))
                    print('  decl.type.name: %r' % decl.type.name)
                    for f in decl.type.fields:
                        print('    type(f): %s' % type(f))
                        print('      f.name: %r' % f.name)
                        print('      f.type: %s' % f.type)
                        print('      type(f.type): %s' % type(f.type))

test_pass = TestPass(name='test-pass')

will generate this output:

fn: gcc.Function('foo')
  type(decl): <type 'gcc.TypeDecl'>
  type(decl.type): <type 'gcc.RecordType'>
  decl.type.name: gcc.IdentifierNode(name='test_struct')
    type(f): <type 'gcc.FieldDecl'>
      f.name: 'a'
      f.type: int
      type(f.type): <type 'gcc.IntegerType'>
    type(f): <type 'gcc.FieldDecl'>
      f.name: 'b'
      f.type: char
      type(f.type): <type 'gcc.IntegerType'>
    type(f): <type 'gcc.FieldDecl'>
      f.name: 'c'
      f.type: float
      type(f.type): <type 'gcc.RealType'>

Constants

class gcc.Constant

Subclass of gcc.Tree indicating a constant value.

Corresponds to the tcc_constant value of enum tree_code_class within GCC’s own C sources.

constant

The actual value of this constant, as the appropriate Python type:

Subclass Python type
class ComplexCst
 
class FixedCst
 
class IntegerCst
int or long
class PtrmemCst
 
class RealCst
float
class StringCst
str
class VectorCst
 

Binary Expressions

class gcc.Binary

Subclass of gcc.Tree indicating a binary expression.

Corresponds to the tcc_binary value of enum tree_code_class within GCC’s own C sources.

location

The gcc.Location for this binary expression

classmethod get_symbol()

Get the symbol used in debug dumps for this gcc.Binary subclass, if any, as a str. A table showing these strings can be seen here.

Has subclasses for the various kinds of binary expression. These include:

Simple arithmetic:

Subclass C/C++ operators enum tree_code
class gcc.PlusExpr
+ PLUS_EXPR
class gcc.MinusExpr
- MINUS_EXPR
class gcc.MultExpr
* MULT_EXPR

Pointer addition:

Subclass C/C++ operators enum tree_code
class gcc.PointerPlusExpr
  POINTER_PLUS_EXPR

Various division operations:

Subclass C/C++ operators
class gcc.TruncDivExr
 
class gcc.CeilDivExpr
 
class gcc.FloorDivExpr
 
class gcc.RoundDivExpr
 

The remainder counterparts of the above division operators:

Subclass C/C++ operators
class gcc.TruncModExpr
 
class gcc.CeilModExpr
 
class gcc.FloorModExpr
 
class gcc.RoundModExpr
 

Division for reals:

Subclass C/C++ operators
class gcc.RdivExpr
 

Division that does not need rounding (e.g. for pointer subtraction in C):

Subclass C/C++ operators
class gcc.ExactDivExpr
 

Max and min:

Subclass C/C++ operators
class gcc.MaxExpr
 
class gcc.MinExpr
 

Shift and rotate operations:

Subclass C/C++ operators
class gcc.LrotateExpr
 
class gcc.LshiftExpr
<<, <<=
class gcc.RrotateExpr
 
class gcc.RshiftExpr
>>, >>=

Bitwise binary expressions:

Subclass C/C++ operators
class gcc.BitAndExpr
&, &= (bitwise “and”)
class gcc.BitIorExpr
|, |= (bitwise “or”)
class gcc.BitXorExpr
^, ^= (bitwise “xor”)

Other gcc.Binary subclasses:

Subclass Usage
class gcc.CompareExpr
 
class gcc.CompareGExpr
 
class gcc.CompareLExpr
 
class gcc.ComplexExpr
 
class gcc.MinusNomodExpr
 
class gcc.PlusNomodExpr
 
class gcc.RangeExpr
 
class gcc.UrshiftExpr
 
class gcc.VecExtractevenExpr
 
class gcc.VecExtractoddExpr
 
class gcc.VecInterleavehighExpr
 
class gcc.VecInterleavelowExpr
 
class gcc.VecLshiftExpr
 
class gcc.VecPackFixTruncExpr
 
class gcc.VecPackSatExpr
 
class gcc.VecPackTruncExpr
 
class gcc.VecRshiftExpr
 
class gcc.WidenMultExpr
 
class gcc.WidenMultHiExpr
 
class gcc.WidenMultLoExpr
 
class gcc.WidenSumExpr
 

Unary Expressions

class gcc.Unary

Subclass of gcc.Tree indicating a unary expression (i.e. taking a single argument).

Corresponds to the tcc_unary value of enum tree_code_class within GCC’s own C sources.

operand

The operand of this operator, as a gcc.Tree.

location

The gcc.Location for this unary expression

classmethod get_symbol()

Get the symbol used in debug dumps for this gcc.Unary subclass, if any, as a str. A table showing these strings can be seen here.

Subclasses include:

Subclass Meaning; C/C++ operators
class gcc.AbsExpr
Absolute value
class gcc.AddrSpaceConvertExpr
Conversion of pointers between address spaces
class gcc.BitNotExpr
~ (bitwise “not”)
class gcc.CastExpr
 
class gcc.ConjExpr
For complex types: complex conjugate
class gcc.ConstCastExpr
 
class gcc.ConvertExpr
 
class gcc.DynamicCastExpr
 
class gcc.FixTruncExpr
Convert real to fixed-point, via truncation
class gcc.FixedConvertExpr
 
class gcc.FloatExpr
Convert integer to real
class gcc.NegateExpr
Unary negation
class gcc.NoexceptExpr
 
class gcc.NonLvalueExpr
 
class gcc.NopExpr
 
class gcc.ParenExpr
 
class gcc.ReducMaxExpr
 
class gcc.ReducMinExpr
 
class gcc.ReducPlusExpr
 
class gcc.ReinterpretCastExpr
 
class gcc.StaticCastExpr
 
class gcc.UnaryPlusExpr
 

Comparisons

class gcc.Comparison

Subclass of gcc.Tree for comparison expressions

Corresponds to the tcc_comparison value of enum tree_code_class within GCC’s own C sources.

location

The gcc.Location for this comparison

classmethod get_symbol()

Get the symbol used in debug dumps for this gcc.Comparison subclass, if any, as a str. A table showing these strings can be seen here.

Subclasses include:

Subclass C/C++ operators
class EqExpr
==
class GeExpr
>=
class GtExpr
>
class LeExpr
<=
class LtExpr
<
class LtgtExpr
 
class NeExpr
!=
class OrderedExpr
 
class UneqExpr
 
class UngeExpr
 
class UngtExpr
 
class UnleExpr
 
class UnltExpr
 
class UnorderedExpr
 

References to storage

class gcc.Reference

Subclass of gcc.Tree for expressions involving a reference to storage.

Corresponds to the tcc_reference value of enum tree_code_class within GCC’s own C sources.

location

The gcc.Location for this storage reference

classmethod get_symbol()

Get the symbol used in debug dumps for this gcc.Reference subclass, if any, as a str. A table showing these strings can be seen here.

class gcc.ArrayRef

A subclass of gcc.Reference for expressions involving an array reference:

unsigned char buffer[4096];
...
/* The left-hand side of this gcc.GimpleAssign is a gcc.ArrayRef: */
buffer[42] = 0xff;
array

The gcc.Tree for the array within the reference (gcc.VarDecl(‘buffer’) in the example above)

index

The gcc.Tree for the index within the reference (gcc.IntegerCst(42) in the example above)

class gcc.ComponentRef

A subclass of gcc.Reference for expressions involving a field lookup.

This can mean either a direct field lookup, as in:

struct mystruct s;
...
s.idx = 42;

or dereferenced field lookup:

struct mystruct *p;
...
p->idx = 42;
target

The gcc.Tree for the container of the field (either s or *p in the examples above)

field

The gcc.FieldDecl for the field within the target.

class gcc.MemRef

A subclass of gcc.Reference for expressions involving dereferencing a pointer:

int p, *q;
...
p = *q;
operand

The gcc.Tree for the expression describing the target of the pointer

Other subclasses of gcc.Reference include:

Subclass C/C++ operators
class ArrayRangeRef
 
class AttrAddrExpr
 
class BitFieldRef
 
class ImagpartExpr
 
class IndirectRef
 
class MemberRef
 
class OffsetRef
 
class RealpartExpr
 
class ScopeRef
 
class TargetMemRef
 
class UnconstrainedArrayRef
 
class ViewConvertExpr
 

Other expression subclasses

class gcc.Expression

Subclass of gcc.Tree indicating an expression that doesn’t fit into the other categories.

Corresponds to the tcc_expression value of enum tree_code_class within GCC’s own C sources.

location

The gcc.Location for this expression

classmethod get_symbol()

Get the symbol used in debug dumps for this gcc.Expression subclass, if any, as a str. A table showing these strings can be seen here.

Subclasses include:

Subclass C/C++ operators
class gcc.AddrExpr
 
class gcc.AlignofExpr
 
class gcc.ArrowExpr
 
class gcc.AssertExpr
 
class gcc.AtEncodeExpr
 
class gcc.BindExpr
 
class gcc.CMaybeConstExpr
 
class gcc.ClassReferenceExpr
 
class gcc.CleanupPointExpr
 
class gcc.CompoundExpr
 
class gcc.CompoundLiteralExpr
 
class gcc.CondExpr
 
class gcc.CtorInitializer
 
class gcc.DlExpr
 
class gcc.DotProdExpr
 
class gcc.DotstarExpr
 
class gcc.EmptyClassExpr
 
class gcc.ExcessPrecisionExpr
 
class gcc.ExprPackExpansion
 
class gcc.ExprStmt
 
class gcc.FdescExpr
 
class gcc.FmaExpr
 
class gcc.InitExpr
 
class gcc.MessageSendExpr
 
class gcc.ModifyExpr
 
class gcc.ModopExpr
 
class gcc.MustNotThrowExpr
 
class gcc.NonDependentExpr
 
class gcc.NontypeArgumentPack
 
class gcc.NullExpr
 
class gcc.NwExpr
 
class gcc.ObjTypeRef
 
class gcc.OffsetofExpr
 
class gcc.PolynomialChrec
 
class gcc.PostdecrementExpr
 
class gcc.PostincrementExpr
 
class gcc.PredecrementExpr
 
class gcc.PredictExpr
 
class gcc.PreincrementExpr
 
class gcc.PropertyRef
 
class gcc.PseudoDtorExpr
 
class gcc.RealignLoad
 
class gcc.SaveExpr
 
class gcc.ScevKnown
 
class gcc.ScevNotKnown
 
class gcc.SizeofExpr
 
class gcc.StmtExpr
 
class gcc.TagDefn
 
class gcc.TargetExpr
 
class gcc.TemplateIdExpr
 
class gcc.ThrowExpr
 
class gcc.TruthAndExpr
 
class gcc.TruthAndifExpr
 
class gcc.TruthNotExpr
 
class gcc.TruthOrExpr
 
class gcc.TruthOrifExpr
 
class gcc.TruthXorExpr
 
class gcc.TypeExpr
 
class gcc.TypeidExpr
 
class gcc.VaArgExpr
 
class gcc.VecCondExpr
 
class gcc.VecDlExpr
 
class gcc.VecInitExpr
 
class gcc.VecNwExpr
 
class gcc.WidenMultMinusExpr
 
class gcc.WidenMultPlusExpr
 
class gcc.WithCleanupExpr
 
class gcc.WithSizeExpr
 

TODO

Statements

class gcc.Statement

A subclass of gcc.Tree for statements

Corresponds to the tcc_statement value of enum tree_code_class within GCC’s own C sources.

class gcc.CaseLabelExpr

A subclass of gcc.Statement for the case and default labels within a switch statement.

low
  • for single-valued case labels, the value, as a gcc.Tree
  • for range-valued case labels, the lower bound, as a gcc.Tree
  • None for the default label
high

For range-valued case labels, the upper bound, as a gcc.Tree.

None for single-valued case labels, and for the default label

target

The target of the case label, as a gcc.LabelDecl

SSA Names

class gcc.SsaName

A subclass of gcc.Tree representing a variable references during SSA analysis. New SSA names are created every time a variable is assigned a new value.

var

The variable being referenced, as a gcc.VarDecl or gcc.ParmDecl

def_stmt

The gcc.Gimple statement which defines this SSA name

version

An int value giving the version number of this SSA name