Subversion Repositories openrisc

@c Copyright (C) 1988, 1989, 1992, 1994, 1997, 1998, 1999, 2000, 2001, 2002,

@c 2003, 2004, 2005

@c Free Software Foundation, Inc.

@c This is part of the GCC manual.

@c For copying conditions, see the file gcc.texi.

@node RTL

@chapter RTL Representation

@cindex RTL representation

@cindex representation of RTL

@cindex Register Transfer Language (RTL)

Most of the work of the compiler is done on an intermediate representation

called register transfer language.  In this language, the instructions to be

output are described, pretty much one by one, in an algebraic form that

describes what the instruction does.

RTL is inspired by Lisp lists.  It has both an internal form, made up of

structures that point at other structures, and a textual form that is used

in the machine description and in printed debugging dumps.  The textual

form uses nested parentheses to indicate the pointers in the internal form.

@menu

* RTL Objects::       Expressions vs vectors vs strings vs integers.

* RTL Classes::       Categories of RTL expression objects, and their structure.

* Accessors::         Macros to access expression operands or vector elts.

* Special Accessors:: Macros to access specific annotations on RTL.

* Flags::             Other flags in an RTL expression.

* Machine Modes::     Describing the size and format of a datum.

* Constants::         Expressions with constant values.

* Regs and Memory::   Expressions representing register contents or memory.

* Arithmetic::        Expressions representing arithmetic on other expressions.

* Comparisons::       Expressions representing comparison of expressions.

* Bit-Fields::        Expressions representing bit-fields in memory or reg.

* Vector Operations:: Expressions involving vector datatypes.

* Conversions::       Extending, truncating, floating or fixing.

* RTL Declarations::  Declaring volatility, constancy, etc.

* Side Effects::      Expressions for storing in registers, etc.

* Incdec::            Embedded side-effects for autoincrement addressing.

* Assembler::         Representing @code{asm} with operands.

* Insns::             Expression types for entire insns.

* Calls::             RTL representation of function call insns.

* Sharing::           Some expressions are unique; others *must* be copied.

* Reading RTL::       Reading textual RTL from a file.

@end menu

@node RTL Objects

@section RTL Object Types

@cindex RTL object types

@cindex RTL integers

@cindex RTL strings

@cindex RTL vectors

@cindex RTL expression

@cindex RTX (See RTL)

RTL uses five kinds of objects: expressions, integers, wide integers,

strings and vectors.  Expressions are the most important ones.  An RTL

expression (``RTX'', for short) is a C structure, but it is usually

referred to with a pointer; a type that is given the typedef name

@code{rtx}.

An integer is simply an @code{int}; their written form uses decimal

digits.  A wide integer is an integral object whose type is

@code{HOST_WIDE_INT}; their written form uses decimal digits.

A string is a sequence of characters.  In core it is represented as a

@code{char *} in usual C fashion, and it is written in C syntax as well.

However, strings in RTL may never be null.  If you write an empty string in

a machine description, it is represented in core as a null pointer rather

than as a pointer to a null character.  In certain contexts, these null

pointers instead of strings are valid.  Within RTL code, strings are most

commonly found inside @code{symbol_ref} expressions, but they appear in

other contexts in the RTL expressions that make up machine descriptions.

In a machine description, strings are normally written with double

quotes, as you would in C@.  However, strings in machine descriptions may

extend over many lines, which is invalid C, and adjacent string

constants are not concatenated as they are in C@.  Any string constant

may be surrounded with a single set of parentheses.  Sometimes this

makes the machine description easier to read.

There is also a special syntax for strings, which can be useful when C

code is embedded in a machine description.  Wherever a string can

appear, it is also valid to write a C-style brace block.  The entire

brace block, including the outermost pair of braces, is considered to be

the string constant.  Double quote characters inside the braces are not

special.  Therefore, if you write string constants in the C code, you

need not escape each quote character with a backslash.

A vector contains an arbitrary number of pointers to expressions.  The

number of elements in the vector is explicitly present in the vector.

The written form of a vector consists of square brackets

(@samp{[@dots{}]}) surrounding the elements, in sequence and with

whitespace separating them.  Vectors of length zero are not created;

null pointers are used instead.

@cindex expression codes

@cindex codes, RTL expression

@findex GET_CODE

@findex PUT_CODE

Expressions are classified by @dfn{expression codes} (also called RTX

codes).  The expression code is a name defined in @file{rtl.def}, which is

also (in uppercase) a C enumeration constant.  The possible expression

codes and their meanings are machine-independent.  The code of an RTX can

be extracted with the macro @code{GET_CODE (@var{x})} and altered with

@code{PUT_CODE (@var{x}, @var{newcode})}.

The expression code determines how many operands the expression contains,

and what kinds of objects they are.  In RTL, unlike Lisp, you cannot tell

by looking at an operand what kind of object it is.  Instead, you must know

from its context---from the expression code of the containing expression.

For example, in an expression of code @code{subreg}, the first operand is

to be regarded as an expression and the second operand as an integer.  In

an expression of code @code{plus}, there are two operands, both of which

are to be regarded as expressions.  In a @code{symbol_ref} expression,

there is one operand, which is to be regarded as a string.

Expressions are written as parentheses containing the name of the

expression type, its flags and machine mode if any, and then the operands

of the expression (separated by spaces).

Expression code names in the @samp{md} file are written in lowercase,

but when they appear in C code they are written in uppercase.  In this

manual, they are shown as follows: @code{const_int}.

@cindex (nil)

@cindex nil

In a few contexts a null pointer is valid where an expression is normally

wanted.  The written form of this is @code{(nil)}.

@node RTL Classes

@section RTL Classes and Formats

@cindex RTL classes

@cindex classes of RTX codes

@cindex RTX codes, classes of

@findex GET_RTX_CLASS

The various expression codes are divided into several @dfn{classes},

which are represented by single characters.  You can determine the class

of an RTX code with the macro @code{GET_RTX_CLASS (@var{code})}.

Currently, @file{rtl.def} defines these classes:

@table @code

@item RTX_OBJ

An RTX code that represents an actual object, such as a register

(@code{REG}) or a memory location (@code{MEM}, @code{SYMBOL_REF}).

@code{LO_SUM}) is also included; instead, @code{SUBREG} and

@code{STRICT_LOW_PART} are not in this class, but in class @code{x}.

@item RTX_CONST_OBJ

An RTX code that represents a constant object.  @code{HIGH} is also

included in this class.

@item RTX_COMPARE

An RTX code for a non-symmetric comparison, such as @code{GEU} or

@code{LT}.

@item RTX_COMM_COMPARE

An RTX code for a symmetric (commutative) comparison, such as @code{EQ}

or @code{ORDERED}.

@item RTX_UNARY

An RTX code for a unary arithmetic operation, such as @code{NEG},

@code{NOT}, or @code{ABS}.  This category also includes value extension

(sign or zero) and conversions between integer and floating point.

@item RTX_COMM_ARITH

An RTX code for a commutative binary operation, such as @code{PLUS} or

@code{AND}.  @code{NE} and @code{EQ} are comparisons, so they have class

@code{<}.

@item RTX_BIN_ARITH

An RTX code for a non-commutative binary operation, such as @code{MINUS},

@code{DIV}, or @code{ASHIFTRT}.

@item RTX_BITFIELD_OPS

An RTX code for a bit-field operation.  Currently only

@code{ZERO_EXTRACT} and @code{SIGN_EXTRACT}.  These have three inputs

and are lvalues (so they can be used for insertion as well).

@xref{Bit-Fields}.

@item RTX_TERNARY

An RTX code for other three input operations.  Currently only

@code{IF_THEN_ELSE} and @code{VEC_MERGE}.

@item RTX_INSN

An RTX code for an entire instruction:  @code{INSN}, @code{JUMP_INSN}, and

@code{CALL_INSN}.  @xref{Insns}.

@item RTX_MATCH

An RTX code for something that matches in insns, such as

@code{MATCH_DUP}.  These only occur in machine descriptions.

@item RTX_AUTOINC

An RTX code for an auto-increment addressing mode, such as

@code{POST_INC}.

@item RTX_EXTRA

All other RTX codes.  This category includes the remaining codes used

only in machine descriptions (@code{DEFINE_*}, etc.).  It also includes

all the codes describing side effects (@code{SET}, @code{USE},

@code{CLOBBER}, etc.) and the non-insns that may appear on an insn

chain, such as @code{NOTE}, @code{BARRIER}, and @code{CODE_LABEL}.

@code{SUBREG} is also part of this class.

@end table

@cindex RTL format

For each expression code, @file{rtl.def} specifies the number of

contained objects and their kinds using a sequence of characters

called the @dfn{format} of the expression code.  For example,

the format of @code{subreg} is @samp{ei}.

@cindex RTL format characters

These are the most commonly used format characters:

@table @code

@item e

An expression (actually a pointer to an expression).

@item i

An integer.

@item w

A wide integer.

@item s

A string.

@item E

A vector of expressions.

@end table

A few other format characters are used occasionally:

@table @code

@item u

@samp{u} is equivalent to @samp{e} except that it is printed differently

in debugging dumps.  It is used for pointers to insns.

@item n

@samp{n} is equivalent to @samp{i} except that it is printed differently

in debugging dumps.  It is used for the line number or code number of a

@code{note} insn.

@item S

@samp{S} indicates a string which is optional.  In the RTL objects in

core, @samp{S} is equivalent to @samp{s}, but when the object is read,

from an @samp{md} file, the string value of this operand may be omitted.

An omitted string is taken to be the null string.

@item V

@samp{V} indicates a vector which is optional.  In the RTL objects in

core, @samp{V} is equivalent to @samp{E}, but when the object is read

from an @samp{md} file, the vector value of this operand may be omitted.

An omitted vector is effectively the same as a vector of no elements.

@item B

@samp{B} indicates a pointer to basic block structure.

@item 0

@samp{0} means a slot whose contents do not fit any normal category.

@samp{0} slots are not printed at all in dumps, and are often used in

special ways by small parts of the compiler.

@end table

There are macros to get the number of operands and the format

of an expression code:

@table @code

@findex GET_RTX_LENGTH

@item GET_RTX_LENGTH (@var{code})

Number of operands of an RTX of code @var{code}.

@findex GET_RTX_FORMAT

@item GET_RTX_FORMAT (@var{code})

The format of an RTX of code @var{code}, as a C string.

@end table

Some classes of RTX codes always have the same format.  For example, it

is safe to assume that all comparison operations have format @code{ee}.

@table @code

@item 1

All codes of this class have format @code{e}.

@item <

@itemx c

@itemx 2

All codes of these classes have format @code{ee}.

@item b

@itemx 3

All codes of these classes have format @code{eee}.

@item i

All codes of this class have formats that begin with @code{iuueiee}.

@xref{Insns}.  Note that not all RTL objects linked onto an insn chain

are of class @code{i}.

@item o

@itemx m

@itemx x

You can make no assumptions about the format of these codes.

@end table

@node Accessors

@section Access to Operands

@cindex accessors

@cindex access to operands

@cindex operand access

@findex XEXP

@findex XINT

@findex XWINT

@findex XSTR

Operands of expressions are accessed using the macros @code{XEXP},

@code{XINT}, @code{XWINT} and @code{XSTR}.  Each of these macros takes

two arguments: an expression-pointer (RTX) and an operand number

(counting from zero).  Thus,

@smallexample

XEXP (@var{x}, 2)

@end smallexample

@noindent

accesses operand 2 of expression @var{x}, as an expression.

@smallexample

XINT (@var{x}, 2)

@end smallexample

@noindent

accesses the same operand as an integer.  @code{XSTR}, used in the same

fashion, would access it as a string.

Any operand can be accessed as an integer, as an expression or as a string.

You must choose the correct method of access for the kind of value actually

stored in the operand.  You would do this based on the expression code of

the containing expression.  That is also how you would know how many

operands there are.

For example, if @var{x} is a @code{subreg} expression, you know that it has

two operands which can be correctly accessed as @code{XEXP (@var{x}, 0)}

and @code{XINT (@var{x}, 1)}.  If you did @code{XINT (@var{x}, 0)}, you

would get the address of the expression operand but cast as an integer;

that might occasionally be useful, but it would be cleaner to write

@code{(int) XEXP (@var{x}, 0)}.  @code{XEXP (@var{x}, 1)} would also

compile without error, and would return the second, integer operand cast as

an expression pointer, which would probably result in a crash when

accessed.  Nothing stops you from writing @code{XEXP (@var{x}, 28)} either,

but this will access memory past the end of the expression with

unpredictable results.

Access to operands which are vectors is more complicated.  You can use the

macro @code{XVEC} to get the vector-pointer itself, or the macros

@code{XVECEXP} and @code{XVECLEN} to access the elements and length of a

vector.

@table @code

@findex XVEC

@item XVEC (@var{exp}, @var{idx})

Access the vector-pointer which is operand number @var{idx} in @var{exp}.

@findex XVECLEN

@item XVECLEN (@var{exp}, @var{idx})

Access the length (number of elements) in the vector which is

in operand number @var{idx} in @var{exp}.  This value is an @code{int}.

@findex XVECEXP

@item XVECEXP (@var{exp}, @var{idx}, @var{eltnum})

Access element number @var{eltnum} in the vector which is

in operand number @var{idx} in @var{exp}.  This value is an RTX@.

It is up to you to make sure that @var{eltnum} is not negative

and is less than @code{XVECLEN (@var{exp}, @var{idx})}.

@end table

All the macros defined in this section expand into lvalues and therefore

can be used to assign the operands, lengths and vector elements as well as

to access them.

@node Special Accessors

@section Access to Special Operands

@cindex access to special operands

Some RTL nodes have special annotations associated with them.

@table @code

@item MEM

@table @code

@findex MEM_ALIAS_SET

@item MEM_ALIAS_SET (@var{x})

If 0, @var{x} is not in any alias set, and may alias anything.  Otherwise,

@var{x} can only alias @code{MEM}s in a conflicting alias set.  This value

is set in a language-dependent manner in the front-end, and should not be

altered in the back-end.  In some front-ends, these numbers may correspond

in some way to types, or other language-level entities, but they need not,

and the back-end makes no such assumptions.

These set numbers are tested with @code{alias_sets_conflict_p}.

@findex MEM_EXPR

@item MEM_EXPR (@var{x})

If this register is known to hold the value of some user-level

declaration, this is that tree node.  It may also be a

@code{COMPONENT_REF}, in which case this is some field reference,

and @code{TREE_OPERAND (@var{x}, 0)} contains the declaration,

or another @code{COMPONENT_REF}, or null if there is no compile-time

object associated with the reference.

@findex MEM_OFFSET

@item MEM_OFFSET (@var{x})

The offset from the start of @code{MEM_EXPR} as a @code{CONST_INT} rtx.

@findex MEM_SIZE

@item MEM_SIZE (@var{x})

The size in bytes of the memory reference as a @code{CONST_INT} rtx.

This is mostly relevant for @code{BLKmode} references as otherwise

the size is implied by the mode.

@findex MEM_ALIGN

@item MEM_ALIGN (@var{x})

The known alignment in bits of the memory reference.

@end table

@item REG

@table @code

@findex ORIGINAL_REGNO

@item ORIGINAL_REGNO (@var{x})

This field holds the number the register ``originally'' had; for a

pseudo register turned into a hard reg this will hold the old pseudo

register number.

@findex REG_EXPR

@item REG_EXPR (@var{x})

If this register is known to hold the value of some user-level

declaration, this is that tree node.

@findex REG_OFFSET

@item REG_OFFSET (@var{x})

If this register is known to hold the value of some user-level

declaration, this is the offset into that logical storage.

@end table

@item SYMBOL_REF

@table @code

@findex SYMBOL_REF_DECL

@item SYMBOL_REF_DECL (@var{x})

If the @code{symbol_ref} @var{x} was created for a @code{VAR_DECL} or

a @code{FUNCTION_DECL}, that tree is recorded here.  If this value is

null, then @var{x} was created by back end code generation routines,

and there is no associated front end symbol table entry.

@code{SYMBOL_REF_DECL} may also point to a tree of class @code{'c'},

that is, some sort of constant.  In this case, the @code{symbol_ref}

is an entry in the per-file constant pool; again, there is no associated

front end symbol table entry.

@findex SYMBOL_REF_CONSTANT

@item SYMBOL_REF_CONSTANT (@var{x})

If @samp{CONSTANT_POOL_ADDRESS_P (@var{x})} is true, this is the constant

pool entry for @var{x}.  It is null otherwise.

@findex SYMBOL_REF_DATA

@item SYMBOL_REF_DATA (@var{x})

A field of opaque type used to store @code{SYMBOL_REF_DECL} or

@code{SYMBOL_REF_CONSTANT}.

@findex SYMBOL_REF_FLAGS

@item SYMBOL_REF_FLAGS (@var{x})

In a @code{symbol_ref}, this is used to communicate various predicates

about the symbol.  Some of these are common enough to be computed by

common code, some are specific to the target.  The common bits are:

@table @code

@findex SYMBOL_REF_FUNCTION_P

@findex SYMBOL_FLAG_FUNCTION

@item SYMBOL_FLAG_FUNCTION

Set if the symbol refers to a function.

@findex SYMBOL_REF_LOCAL_P

@findex SYMBOL_FLAG_LOCAL

@item SYMBOL_FLAG_LOCAL

Set if the symbol is local to this ``module''.

See @code{TARGET_BINDS_LOCAL_P}.

@findex SYMBOL_REF_EXTERNAL_P

@findex SYMBOL_FLAG_EXTERNAL

@item SYMBOL_FLAG_EXTERNAL

Set if this symbol is not defined in this translation unit.

Note that this is not the inverse of @code{SYMBOL_FLAG_LOCAL}.

@findex SYMBOL_REF_SMALL_P

@findex SYMBOL_FLAG_SMALL

@item SYMBOL_FLAG_SMALL

Set if the symbol is located in the small data section.

See @code{TARGET_IN_SMALL_DATA_P}.

@findex SYMBOL_FLAG_TLS_SHIFT

@findex SYMBOL_REF_TLS_MODEL

@item SYMBOL_REF_TLS_MODEL (@var{x})

This is a multi-bit field accessor that returns the @code{tls_model}

to be used for a thread-local storage symbol.  It returns zero for

non-thread-local symbols.

@findex SYMBOL_REF_HAS_BLOCK_INFO_P

@findex SYMBOL_FLAG_HAS_BLOCK_INFO

@item SYMBOL_FLAG_HAS_BLOCK_INFO

Set if the symbol has @code{SYMBOL_REF_BLOCK} and

@code{SYMBOL_REF_BLOCK_OFFSET} fields.

@findex SYMBOL_REF_ANCHOR_P

@findex SYMBOL_FLAG_ANCHOR

@cindex @option{-fsection-anchors}

@item SYMBOL_FLAG_ANCHOR

Set if the symbol is used as a section anchor.  ``Section anchors''

are symbols that have a known position within an @code{object_block}

and that can be used to access nearby members of that block.

They are used to implement @option{-fsection-anchors}.

If this flag is set, then @code{SYMBOL_FLAG_HAS_BLOCK_INFO} will be too.

@end table

Bits beginning with @code{SYMBOL_FLAG_MACH_DEP} are available for

the target's use.

@end table

@findex SYMBOL_REF_BLOCK

@item SYMBOL_REF_BLOCK (@var{x})

If @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})}, this is the

@samp{object_block} structure to which the symbol belongs,

or @code{NULL} if it has not been assigned a block.

@findex SYMBOL_REF_BLOCK_OFFSET

@item SYMBOL_REF_BLOCK_OFFSET (@var{x})

If @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})}, this is the offset of @var{x}

from the first object in @samp{SYMBOL_REF_BLOCK (@var{x})}.  The value is

negative if @var{x} has not yet been assigned to a block, or it has not

been given an offset within that block.

@end table

@node Flags

@section Flags in an RTL Expression

@cindex flags in RTL expression

RTL expressions contain several flags (one-bit bit-fields)

that are used in certain types of expression.  Most often they

are accessed with the following macros, which expand into lvalues.

@table @code

@findex CONSTANT_POOL_ADDRESS_P

@cindex @code{symbol_ref} and @samp{/u}

@cindex @code{unchanging}, in @code{symbol_ref}

@item CONSTANT_POOL_ADDRESS_P (@var{x})

Nonzero in a @code{symbol_ref} if it refers to part of the current

function's constant pool.  For most targets these addresses are in a

@code{.rodata} section entirely separate from the function, but for

some targets the addresses are close to the beginning of the function.

In either case GCC assumes these addresses can be addressed directly,

perhaps with the help of base registers.

Stored in the @code{unchanging} field and printed as @samp{/u}.

@findex CONST_OR_PURE_CALL_P

@cindex @code{call_insn} and @samp{/u}

@cindex @code{unchanging}, in @code{call_insn}

@item CONST_OR_PURE_CALL_P (@var{x})

In a @code{call_insn}, @code{note}, or an @code{expr_list} for notes,

indicates that the insn represents a call to a const or pure function.

Stored in the @code{unchanging} field and printed as @samp{/u}.

@findex INSN_ANNULLED_BRANCH_P

@cindex @code{jump_insn} and @samp{/u}

@cindex @code{call_insn} and @samp{/u}

@cindex @code{insn} and @samp{/u}

@cindex @code{unchanging}, in @code{jump_insn}, @code{call_insn} and @code{insn}

@item INSN_ANNULLED_BRANCH_P (@var{x})

In a @code{jump_insn}, @code{call_insn}, or @code{insn} indicates

that the branch is an annulling one.  See the discussion under

@code{sequence} below.  Stored in the @code{unchanging} field and

printed as @samp{/u}.

@findex INSN_DELETED_P

@cindex @code{insn} and @samp{/v}

@cindex @code{call_insn} and @samp{/v}

@cindex @code{jump_insn} and @samp{/v}

@cindex @code{code_label} and @samp{/v}

@cindex @code{barrier} and @samp{/v}

@cindex @code{note} and @samp{/v}

@cindex @code{volatil}, in @code{insn}, @code{call_insn}, @code{jump_insn}, @code{code_label}, @code{barrier}, and @code{note}

@item INSN_DELETED_P (@var{x})

In an @code{insn}, @code{call_insn}, @code{jump_insn}, @code{code_label},

@code{barrier}, or @code{note},

nonzero if the insn has been deleted.  Stored in the

@code{volatil} field and printed as @samp{/v}.

@findex INSN_FROM_TARGET_P

@cindex @code{insn} and @samp{/s}

@cindex @code{jump_insn} and @samp{/s}

@cindex @code{call_insn} and @samp{/s}

@cindex @code{in_struct}, in @code{insn} and @code{jump_insn} and @code{call_insn}

@item INSN_FROM_TARGET_P (@var{x})

In an @code{insn} or @code{jump_insn} or @code{call_insn} in a delay

slot of a branch, indicates that the insn

is from the target of the branch.  If the branch insn has

@code{INSN_ANNULLED_BRANCH_P} set, this insn will only be executed if

the branch is taken.  For annulled branches with

@code{INSN_FROM_TARGET_P} clear, the insn will be executed only if the

branch is not taken.  When @code{INSN_ANNULLED_BRANCH_P} is not set,

this insn will always be executed.  Stored in the @code{in_struct}

field and printed as @samp{/s}.

@findex LABEL_PRESERVE_P

@cindex @code{code_label} and @samp{/i}

@cindex @code{note} and @samp{/i}

@cindex @code{in_struct}, in @code{code_label} and @code{note}

@item LABEL_PRESERVE_P (@var{x})

In a @code{code_label} or @code{note}, indicates that the label is referenced by

code or data not visible to the RTL of a given function.

Labels referenced by a non-local goto will have this bit set.  Stored

in the @code{in_struct} field and printed as @samp{/s}.

@findex LABEL_REF_NONLOCAL_P

@cindex @code{label_ref} and @samp{/v}

@cindex @code{reg_label} and @samp{/v}

@cindex @code{volatil}, in @code{label_ref} and @code{reg_label}

@item LABEL_REF_NONLOCAL_P (@var{x})

In @code{label_ref} and @code{reg_label} expressions, nonzero if this is

a reference to a non-local label.

Stored in the @code{volatil} field and printed as @samp{/v}.

@findex MEM_IN_STRUCT_P

@cindex @code{mem} and @samp{/s}

@cindex @code{in_struct}, in @code{mem}

@item MEM_IN_STRUCT_P (@var{x})

In @code{mem} expressions, nonzero for reference to an entire structure,

union or array, or to a component of one.  Zero for references to a

scalar variable or through a pointer to a scalar.  If both this flag and

@code{MEM_SCALAR_P} are clear, then we don't know whether this @code{mem}

is in a structure or not.  Both flags should never be simultaneously set.

Stored in the @code{in_struct} field and printed as @samp{/s}.

@findex MEM_KEEP_ALIAS_SET_P

@cindex @code{mem} and @samp{/j}

@cindex @code{jump}, in @code{mem}

@item MEM_KEEP_ALIAS_SET_P (@var{x})

In @code{mem} expressions, 1 if we should keep the alias set for this

mem unchanged when we access a component.  Set to 1, for example, when we

are already in a non-addressable component of an aggregate.

Stored in the @code{jump} field and printed as @samp{/j}.

@findex MEM_SCALAR_P

@cindex @code{mem} and @samp{/f}

@cindex @code{frame_related}, in @code{mem}

@item MEM_SCALAR_P (@var{x})

In @code{mem} expressions, nonzero for reference to a scalar known not

to be a member of a structure, union, or array.  Zero for such

references and for indirections through pointers, even pointers pointing

to scalar types.  If both this flag and @code{MEM_IN_STRUCT_P} are clear,

then we don't know whether this @code{mem} is in a structure or not.

Both flags should never be simultaneously set.

Stored in the @code{frame_related} field and printed as @samp{/f}.

@findex MEM_VOLATILE_P

@cindex @code{mem} and @samp{/v}

@cindex @code{asm_input} and @samp{/v}

@cindex @code{asm_operands} and @samp{/v}

@cindex @code{volatil}, in @code{mem}, @code{asm_operands}, and @code{asm_input}

@item MEM_VOLATILE_P (@var{x})

In @code{mem}, @code{asm_operands}, and @code{asm_input} expressions,

nonzero for volatile memory references.

Stored in the @code{volatil} field and printed as @samp{/v}.

@findex MEM_NOTRAP_P

@cindex @code{mem} and @samp{/c}

@cindex @code{call}, in @code{mem}

@item MEM_NOTRAP_P (@var{x})

In @code{mem}, nonzero for memory references that will not trap.

Stored in the @code{call} field and printed as @samp{/c}.

@findex REG_FUNCTION_VALUE_P

@cindex @code{reg} and @samp{/i}

@cindex @code{integrated}, in @code{reg}

@item REG_FUNCTION_VALUE_P (@var{x})

Nonzero in a @code{reg} if it is the place in which this function's

value is going to be returned.  (This happens only in a hard

register.)  Stored in the @code{integrated} field and printed as

@samp{/i}.

@findex REG_POINTER

@cindex @code{reg} and @samp{/f}

@cindex @code{frame_related}, in @code{reg}

@item REG_POINTER (@var{x})

Nonzero in a @code{reg} if the register holds a pointer.  Stored in the

@code{frame_related} field and printed as @samp{/f}.

@findex REG_USERVAR_P

@cindex @code{reg} and @samp{/v}

@cindex @code{volatil}, in @code{reg}

@item REG_USERVAR_P (@var{x})

In a @code{reg}, nonzero if it corresponds to a variable present in

the user's source code.  Zero for temporaries generated internally by

the compiler.  Stored in the @code{volatil} field and printed as

@samp{/v}.

The same hard register may be used also for collecting the values of

functions called by this one, but @code{REG_FUNCTION_VALUE_P} is zero

in this kind of use.

@findex RTX_FRAME_RELATED_P

@cindex @code{insn} and @samp{/f}

@cindex @code{call_insn} and @samp{/f}

@cindex @code{jump_insn} and @samp{/f}

@cindex @code{barrier} and @samp{/f}

@cindex @code{set} and @samp{/f}

@cindex @code{frame_related}, in @code{insn}, @code{call_insn}, @code{jump_insn}, @code{barrier}, and @code{set}

@item RTX_FRAME_RELATED_P (@var{x})

Nonzero in an @code{insn}, @code{call_insn}, @code{jump_insn},

@code{barrier}, or @code{set} which is part of a function prologue

and sets the stack pointer, sets the frame pointer, or saves a register.

This flag should also be set on an instruction that sets up a temporary

register to use in place of the frame pointer.

Stored in the @code{frame_related} field and printed as @samp{/f}.

In particular, on RISC targets where there are limits on the sizes of

immediate constants, it is sometimes impossible to reach the register

save area directly from the stack pointer.  In that case, a temporary

register is used that is near enough to the register save area, and the

Canonical Frame Address, i.e., DWARF2's logical frame pointer, register

must (temporarily) be changed to be this temporary register.  So, the

instruction that sets this temporary register must be marked as

@code{RTX_FRAME_RELATED_P}.

If the marked instruction is overly complex (defined in terms of what

@code{dwarf2out_frame_debug_expr} can handle), you will also have to

create a @code{REG_FRAME_RELATED_EXPR} note and attach it to the

instruction.  This note should contain a simple expression of the

computation performed by this instruction, i.e., one that

@code{dwarf2out_frame_debug_expr} can handle.

This flag is required for exception handling support on targets with RTL

prologues.

@cindex @code{insn} and @samp{/i}

@cindex @code{call_insn} and @samp{/i}

@cindex @code{jump_insn} and @samp{/i}

@cindex @code{barrier} and @samp{/i}

@cindex @code{code_label} and @samp{/i}

@cindex @code{insn_list} and @samp{/i}

@cindex @code{const} and @samp{/i}

@cindex @code{note} and @samp{/i}

@cindex @code{integrated}, in @code{insn}, @code{call_insn}, @code{jump_insn}, @code{barrier}, @code{code_label}, @code{insn_list}, @code{const}, and @code{note}

@code{code_label}, @code{insn_list}, @code{const}, or @code{note} if it

resulted from an in-line function call.

Stored in the @code{integrated} field and printed as @samp{/i}.

@findex MEM_READONLY_P

@cindex @code{mem} and @samp{/u}

@cindex @code{unchanging}, in @code{mem}

@item MEM_READONLY_P (@var{x})

Nonzero in a @code{mem}, if the memory is statically allocated and read-only.

Read-only in this context means never modified during the lifetime of the

program, not necessarily in ROM or in write-disabled pages.  A common

example of the later is a shared library's global offset table.  This

table is initialized by the runtime loader, so the memory is technically

writable, but after control is transfered from the runtime loader to the

application, this memory will never be subsequently modified.

Stored in the @code{unchanging} field and printed as @samp{/u}.

@findex SCHED_GROUP_P

@cindex @code{insn} and @samp{/s}

@cindex @code{call_insn} and @samp{/s}

@cindex @code{jump_insn} and @samp{/s}

@cindex @code{in_struct}, in @code{insn}, @code{jump_insn} and @code{call_insn}

@item SCHED_GROUP_P (@var{x})

During instruction scheduling, in an @code{insn}, @code{call_insn} or

@code{jump_insn}, indicates that the

previous insn must be scheduled together with this insn.  This is used to

ensure that certain groups of instructions will not be split up by the

instruction scheduling pass, for example, @code{use} insns before

a @code{call_insn} may not be separated from the @code{call_insn}.

Stored in the @code{in_struct} field and printed as @samp{/s}.

@findex SET_IS_RETURN_P

@cindex @code{insn} and @samp{/j}

@cindex @code{jump}, in @code{insn}

@item SET_IS_RETURN_P (@var{x})

For a @code{set}, nonzero if it is for a return.

Stored in the @code{jump} field and printed as @samp{/j}.

@findex SIBLING_CALL_P

@cindex @code{call_insn} and @samp{/j}

@cindex @code{jump}, in @code{call_insn}

@item SIBLING_CALL_P (@var{x})

For a @code{call_insn}, nonzero if the insn is a sibling call.

Stored in the @code{jump} field and printed as @samp{/j}.

@findex STRING_POOL_ADDRESS_P

@cindex @code{symbol_ref} and @samp{/f}

@cindex @code{frame_related}, in @code{symbol_ref}

@item STRING_POOL_ADDRESS_P (@var{x})

For a @code{symbol_ref} expression, nonzero if it addresses this function's

string constant pool.

Stored in the @code{frame_related} field and printed as @samp{/f}.

@findex SUBREG_PROMOTED_UNSIGNED_P

@cindex @code{subreg} and @samp{/u} and @samp{/v}

@cindex @code{unchanging}, in @code{subreg}

@cindex @code{volatil}, in @code{subreg}

@item SUBREG_PROMOTED_UNSIGNED_P (@var{x})

Returns a value greater then zero for a @code{subreg} that has

@code{SUBREG_PROMOTED_VAR_P} nonzero if the object being referenced is kept

zero-extended, zero if it is kept sign-extended, and less then zero if it is

extended some other way via the @code{ptr_extend} instruction.

Stored in the @code{unchanging}

field and @code{volatil} field, printed as @samp{/u} and @samp{/v}.

This macro may only be used to get the value it may not be used to change

the value.  Use @code{SUBREG_PROMOTED_UNSIGNED_SET} to change the value.

@findex SUBREG_PROMOTED_UNSIGNED_SET

@cindex @code{subreg} and @samp{/u}

@cindex @code{unchanging}, in @code{subreg}

@cindex @code{volatil}, in @code{subreg}

@item SUBREG_PROMOTED_UNSIGNED_SET (@var{x})

Set the @code{unchanging} and @code{volatil} fields in a @code{subreg}

to reflect zero, sign, or other extension.  If @code{volatil} is

zero, then @code{unchanging} as nonzero means zero extension and as

zero means sign extension.  If @code{volatil} is nonzero then some

other type of extension was done via the @code{ptr_extend} instruction.

@findex SUBREG_PROMOTED_VAR_P

@cindex @code{subreg} and @samp{/s}

@cindex @code{in_struct}, in @code{subreg}

@item SUBREG_PROMOTED_VAR_P (@var{x})

Nonzero in a @code{subreg} if it was made when accessing an object that

was promoted to a wider mode in accord with the @code{PROMOTED_MODE} machine

description macro (@pxref{Storage Layout}).  In this case, the mode of

the @code{subreg} is the declared mode of the object and the mode of

@code{SUBREG_REG} is the mode of the register that holds the object.

Promoted variables are always either sign- or zero-extended to the wider

mode on every assignment.  Stored in the @code{in_struct} field and

printed as @samp{/s}.

@findex SYMBOL_REF_USED

@cindex @code{used}, in @code{symbol_ref}

@item SYMBOL_REF_USED (@var{x})

In a @code{symbol_ref}, indicates that @var{x} has been used.  This is

normally only used to ensure that @var{x} is only declared external

once.  Stored in the @code{used} field.

@findex SYMBOL_REF_WEAK

@cindex @code{symbol_ref} and @samp{/i}

@cindex @code{integrated}, in @code{symbol_ref}

@item SYMBOL_REF_WEAK (@var{x})

In a @code{symbol_ref}, indicates that @var{x} has been declared weak.

Stored in the @code{integrated} field and printed as @samp{/i}.

@findex SYMBOL_REF_FLAG

@cindex @code{symbol_ref} and @samp{/v}

@cindex @code{volatil}, in @code{symbol_ref}

@item SYMBOL_REF_FLAG (@var{x})

In a @code{symbol_ref}, this is used as a flag for machine-specific purposes.

Stored in the @code{volatil} field and printed as @samp{/v}.

Most uses of @code{SYMBOL_REF_FLAG} are historic and may be subsumed

by @code{SYMBOL_REF_FLAGS}.  Certainly use of @code{SYMBOL_REF_FLAGS}

is mandatory if the target requires more than one bit of storage.

@end table

These are the fields to which the above macros refer:

@table @code

@findex call

@cindex @samp{/c} in RTL dump

@item call

In a @code{mem}, 1 means that the memory reference will not trap.

In an RTL dump, this flag is represented as @samp{/c}.

@findex frame_related

@cindex @samp{/f} in RTL dump

@item frame_related

In an @code{insn} or @code{set} expression, 1 means that it is part of

a function prologue and sets the stack pointer, sets the frame pointer,

saves a register, or sets up a temporary register to use in place of the

frame pointer.

In @code{reg} expressions, 1 means that the register holds a pointer.

In @code{symbol_ref} expressions, 1 means that the reference addresses

this function's string constant pool.

In @code{mem} expressions, 1 means that the reference is to a scalar.

In an RTL dump, this flag is represented as @samp{/f}.

@findex in_struct

@cindex @samp{/s} in RTL dump

@item in_struct

In @code{mem} expressions, it is 1 if the memory datum referred to is

all or part of a structure or array; 0 if it is (or might be) a scalar

variable.  A reference through a C pointer has 0 because the pointer

might point to a scalar variable.  This information allows the compiler

to determine something about possible cases of aliasing.

In @code{reg} expressions, it is 1 if the register has its entire life

contained within the test expression of some loop.

In @code{subreg} expressions, 1 means that the @code{subreg} is accessing

an object that has had its mode promoted from a wider mode.

In @code{label_ref} expressions, 1 means that the referenced label is

outside the innermost loop containing the insn in which the @code{label_ref}

was found.

In @code{code_label} expressions, it is 1 if the label may never be deleted.

This is used for labels which are the target of non-local gotos.  Such a

label that would have been deleted is replaced with a @code{note} of type

@code{NOTE_INSN_DELETED_LABEL}.

In an @code{insn} during dead-code elimination, 1 means that the insn is

dead code.

In an @code{insn} or @code{jump_insn} during reorg for an insn in the

delay slot of a branch,

1 means that this insn is from the target of the branch.

In an @code{insn} during instruction scheduling, 1 means that this insn

must be scheduled as part of a group together with the previous insn.

In an RTL dump, this flag is represented as @samp{/s}.

@findex integrated

@cindex @samp{/i} in RTL dump

@item integrated

In an @code{insn}, @code{insn_list}, or @code{const}, 1 means the RTL was

produced by procedure integration.

In @code{reg} expressions, 1 means the register contains