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