Subversion Repositories openrisc

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

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

@c 2003, 2004, 2005

@c 2003, 2004, 2005

@c Free Software Foundation, Inc.

@c Free Software Foundation, Inc.

@c This is part of the GCC manual.

@c This is part of the GCC manual.

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

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

@node RTL

@node RTL

@chapter RTL Representation

@chapter RTL Representation

@cindex RTL representation

@cindex RTL representation

@cindex representation of RTL

@cindex representation of RTL

@cindex Register Transfer Language (RTL)

@cindex Register Transfer Language (RTL)

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

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

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

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

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

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

describes what the instruction does.

describes what the instruction does.

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

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

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

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

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

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

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

@menu

@menu

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

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

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

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

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

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

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

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

* Flags::             Other flags in an RTL expression.

* Flags::             Other flags in an RTL expression.

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

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

* Constants::         Expressions with constant values.

* Constants::         Expressions with constant values.

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

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

* Arithmetic::        Expressions representing arithmetic on other expressions.

* Arithmetic::        Expressions representing arithmetic on other expressions.

* Comparisons::       Expressions representing comparison of expressions.

* Comparisons::       Expressions representing comparison of expressions.

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

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

* Vector Operations:: Expressions involving vector datatypes.

* Vector Operations:: Expressions involving vector datatypes.

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

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

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

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

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

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

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

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

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

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

* Insns::             Expression types for entire insns.

* Insns::             Expression types for entire insns.

* Calls::             RTL representation of function call insns.

* Calls::             RTL representation of function call insns.

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

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

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

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

@end menu

@end menu

@node RTL Objects

@node RTL Objects

@section RTL Object Types

@section RTL Object Types

@cindex RTL object types

@cindex RTL object types

@cindex RTL integers

@cindex RTL integers

@cindex RTL strings

@cindex RTL strings

@cindex RTL vectors

@cindex RTL vectors

@cindex RTL expression

@cindex RTL expression

@cindex RTX (See RTL)

@cindex RTX (See RTL)

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

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

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

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

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

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

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

@code{rtx}.

@code{rtx}.

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

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

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

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

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

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

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

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.

@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

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

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

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

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

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

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

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

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

In a machine description, strings are normally written with double

In a machine description, strings are normally written with double

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

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

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

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

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

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

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

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

makes the machine description easier to read.

makes the machine description easier to read.

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

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

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

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

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

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

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

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

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

need not escape each quote character with a backslash.

need not escape each quote character with a backslash.

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

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

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

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

The written form of a vector consists of square brackets

The written form of a vector consists of square brackets

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

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

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

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

null pointers are used instead.

null pointers are used instead.

@cindex expression codes

@cindex expression codes

@cindex codes, RTL expression

@cindex codes, RTL expression

@findex GET_CODE

@findex GET_CODE

@findex PUT_CODE

@findex PUT_CODE

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

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

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

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

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

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

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

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

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

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

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

The expression code determines how many operands the expression contains,

The expression code determines how many operands the expression contains,

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

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

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.

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

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

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

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

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,

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

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

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

Expressions are written as parentheses containing the name of the

Expressions are written as parentheses containing the name of the

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

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

of the expression (separated by spaces).

of the expression (separated by spaces).

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

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

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

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

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

@cindex (nil)

@cindex (nil)

@cindex nil

@cindex nil

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

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

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

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

@node RTL Classes

@node RTL Classes

@section RTL Classes and Formats

@section RTL Classes and Formats

@cindex RTL classes

@cindex RTL classes

@cindex classes of RTX codes

@cindex classes of RTX codes

@cindex RTX codes, classes of

@cindex RTX codes, classes of

@findex GET_RTX_CLASS

@findex GET_RTX_CLASS

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

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

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

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

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

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

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

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

@table @code

@table @code

@item RTX_OBJ

@item RTX_OBJ

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

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

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

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

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

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

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

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

@item RTX_CONST_OBJ

@item RTX_CONST_OBJ

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

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

included in this class.

included in this class.

@item RTX_COMPARE

@item RTX_COMPARE

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

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

@code{LT}.

@code{LT}.

@item RTX_COMM_COMPARE

@item RTX_COMM_COMPARE

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

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

or @code{ORDERED}.

or @code{ORDERED}.

@item RTX_UNARY

@item RTX_UNARY

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

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

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

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

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

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

@item RTX_COMM_ARITH

@item RTX_COMM_ARITH

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

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{AND}.  @code{NE} and @code{EQ} are comparisons, so they have class

@code{<}.

@code{<}.

@item RTX_BIN_ARITH

@item RTX_BIN_ARITH

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

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

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

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

@item RTX_BITFIELD_OPS

@item RTX_BITFIELD_OPS

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

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

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

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

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

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

@xref{Bit-Fields}.

@xref{Bit-Fields}.

@item RTX_TERNARY

@item RTX_TERNARY

An RTX code for other three input operations.  Currently only

An RTX code for other three input operations.  Currently only

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

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

@item RTX_INSN

@item RTX_INSN

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

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

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

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

@item RTX_MATCH

@item RTX_MATCH

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

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

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

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

@item RTX_AUTOINC

@item RTX_AUTOINC

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

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

@code{POST_INC}.

@code{POST_INC}.

@item RTX_EXTRA

@item RTX_EXTRA

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

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

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

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

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

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

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

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

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

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

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

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

@end table

@end table

@cindex RTL format

@cindex RTL format

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

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

contained objects and their kinds using a sequence of characters

contained objects and their kinds using a sequence of characters

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

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

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

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

@cindex RTL format characters

@cindex RTL format characters

These are the most commonly used format characters:

These are the most commonly used format characters:

@table @code

@table @code

@item e

@item e

An expression (actually a pointer to an expression).

An expression (actually a pointer to an expression).

@item i

@item i

An integer.

An integer.

@item w

@item w

A wide integer.

A wide integer.

@item s

@item s

A string.

A string.

@item E

@item E

A vector of expressions.

A vector of expressions.

@end table

@end table

A few other format characters are used occasionally:

A few other format characters are used occasionally:

@table @code

@table @code

@item u

@item u

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

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

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

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

@item n

@item n

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

@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

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

@code{note} insn.

@code{note} insn.

@item S

@item S

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

@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,

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.

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

An omitted string is taken to be the null string.

An omitted string is taken to be the null string.

@item V

@item V

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

@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

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.

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.

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

@item B

@item B

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

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

@item 0

@item 0

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

@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

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

special ways by small parts of the compiler.

special ways by small parts of the compiler.

@end table

@end table

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

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

of an expression code:

of an expression code:

@table @code

@table @code

@findex GET_RTX_LENGTH

@findex GET_RTX_LENGTH

@item GET_RTX_LENGTH (@var{code})

@item GET_RTX_LENGTH (@var{code})

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

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

@findex GET_RTX_FORMAT

@findex GET_RTX_FORMAT

@item GET_RTX_FORMAT (@var{code})

@item GET_RTX_FORMAT (@var{code})

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

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

@end table

@end table

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

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}.

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

@table @code

@table @code

@item 1

@item 1

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

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

@item <

@item <

@itemx c

@itemx c

@itemx 2

@itemx 2

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

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

@item b

@item b

@itemx 3

@itemx 3

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

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

@item i

@item i

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

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

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

are of class @code{i}.

are of class @code{i}.

@item o

@item o

@itemx m

@itemx m

@itemx x

@itemx x

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

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

@end table

@end table

@node Accessors

@node Accessors

@section Access to Operands

@section Access to Operands

@cindex accessors

@cindex accessors

@cindex access to operands

@cindex access to operands

@cindex operand access

@cindex operand access

@findex XEXP

@findex XEXP

@findex XINT

@findex XINT

@findex XWINT

@findex XWINT

@findex XSTR

@findex XSTR

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

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

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

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

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

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

(counting from zero).  Thus,

(counting from zero).  Thus,

@smallexample

@smallexample

XEXP (@var{x}, 2)

XEXP (@var{x}, 2)

@end smallexample

@end smallexample

@noindent

@noindent

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

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

@smallexample

@smallexample

XINT (@var{x}, 2)

XINT (@var{x}, 2)

@end smallexample

@end smallexample

@noindent

@noindent

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

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

fashion, would access it as a string.

fashion, would access it as a string.

Any operand can be accessed as an integer, as an expression or 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

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

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

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

operands there are.

operands there are.

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

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)}

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

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;

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

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

@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

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

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

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

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

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

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

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

unpredictable results.

unpredictable results.

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

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

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

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

vector.

vector.

@table @code

@table @code

@findex XVEC

@findex XVEC

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

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

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

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

@findex XVECLEN

@findex XVECLEN

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

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

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

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}.

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

@findex XVECEXP

@findex XVECEXP

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

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

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

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

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

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

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

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

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

@end table

@end table

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

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

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

to access them.

to access them.

@node Special Accessors

@node Special Accessors

@section Access to Special Operands

@section Access to Special Operands

@cindex access to special operands

@cindex access to special operands

Some RTL nodes have special annotations associated with them.

Some RTL nodes have special annotations associated with them.

@table @code

@table @code

@item MEM

@item MEM

@table @code

@table @code

@findex MEM_ALIAS_SET

@findex MEM_ALIAS_SET

@item MEM_ALIAS_SET (@var{x})

@item MEM_ALIAS_SET (@var{x})

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

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

@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

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

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,

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

and the back-end makes no such assumptions.

and the back-end makes no such assumptions.

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

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

@findex MEM_EXPR

@findex MEM_EXPR

@item MEM_EXPR (@var{x})

@item MEM_EXPR (@var{x})

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

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

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

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

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

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

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

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

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

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

object associated with the reference.

object associated with the reference.

@findex MEM_OFFSET

@findex MEM_OFFSET

@item MEM_OFFSET (@var{x})

@item MEM_OFFSET (@var{x})

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

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

@findex MEM_SIZE

@findex MEM_SIZE

@item MEM_SIZE (@var{x})

@item MEM_SIZE (@var{x})

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

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

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

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

the size is implied by the mode.

the size is implied by the mode.

@findex MEM_ALIGN

@findex MEM_ALIGN

@item MEM_ALIGN (@var{x})

@item MEM_ALIGN (@var{x})

The known alignment in bits of the memory reference.

The known alignment in bits of the memory reference.

@end table

@end table

@item REG

@item REG

@table @code

@table @code

@findex ORIGINAL_REGNO

@findex ORIGINAL_REGNO

@item ORIGINAL_REGNO (@var{x})

@item ORIGINAL_REGNO (@var{x})

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

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

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

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

register number.

register number.

@findex REG_EXPR

@findex REG_EXPR

@item REG_EXPR (@var{x})

@item REG_EXPR (@var{x})

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

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

declaration, this is that tree node.

declaration, this is that tree node.

@findex REG_OFFSET

@findex REG_OFFSET

@item REG_OFFSET (@var{x})

@item REG_OFFSET (@var{x})

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

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

declaration, this is the offset into that logical storage.

declaration, this is the offset into that logical storage.

@end table

@end table

@item SYMBOL_REF

@item SYMBOL_REF

@table @code

@table @code

@findex SYMBOL_REF_DECL

@findex SYMBOL_REF_DECL

@item SYMBOL_REF_DECL (@var{x})

@item SYMBOL_REF_DECL (@var{x})

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

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

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,

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

and there is no associated front end symbol table entry.

and there is no associated front end symbol table entry.

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

@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}

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

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

front end symbol table entry.

front end symbol table entry.

@findex SYMBOL_REF_CONSTANT

@findex SYMBOL_REF_CONSTANT

@item SYMBOL_REF_CONSTANT (@var{x})

@item SYMBOL_REF_CONSTANT (@var{x})

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

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

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

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

@findex SYMBOL_REF_DATA

@findex SYMBOL_REF_DATA

@item SYMBOL_REF_DATA (@var{x})

@item SYMBOL_REF_DATA (@var{x})

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

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

@code{SYMBOL_REF_CONSTANT}.

@code{SYMBOL_REF_CONSTANT}.

@findex SYMBOL_REF_FLAGS

@findex SYMBOL_REF_FLAGS

@item SYMBOL_REF_FLAGS (@var{x})

@item SYMBOL_REF_FLAGS (@var{x})

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

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

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:

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

@table @code

@table @code

@findex SYMBOL_REF_FUNCTION_P

@findex SYMBOL_REF_FUNCTION_P

@findex SYMBOL_FLAG_FUNCTION

@findex SYMBOL_FLAG_FUNCTION

@item SYMBOL_FLAG_FUNCTION

@item SYMBOL_FLAG_FUNCTION

Set if the symbol refers to a function.

Set if the symbol refers to a function.

@findex SYMBOL_REF_LOCAL_P

@findex SYMBOL_REF_LOCAL_P

@findex SYMBOL_FLAG_LOCAL

@findex SYMBOL_FLAG_LOCAL

@item SYMBOL_FLAG_LOCAL

@item SYMBOL_FLAG_LOCAL

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

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

See @code{TARGET_BINDS_LOCAL_P}.

See @code{TARGET_BINDS_LOCAL_P}.

@findex SYMBOL_REF_EXTERNAL_P

@findex SYMBOL_REF_EXTERNAL_P

@findex SYMBOL_FLAG_EXTERNAL

@findex SYMBOL_FLAG_EXTERNAL

@item SYMBOL_FLAG_EXTERNAL

@item SYMBOL_FLAG_EXTERNAL

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

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

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

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

@findex SYMBOL_REF_SMALL_P

@findex SYMBOL_REF_SMALL_P

@findex SYMBOL_FLAG_SMALL

@findex SYMBOL_FLAG_SMALL

@item SYMBOL_FLAG_SMALL

@item SYMBOL_FLAG_SMALL

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

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

See @code{TARGET_IN_SMALL_DATA_P}.

See @code{TARGET_IN_SMALL_DATA_P}.

@findex SYMBOL_FLAG_TLS_SHIFT

@findex SYMBOL_FLAG_TLS_SHIFT

@findex SYMBOL_REF_TLS_MODEL

@findex SYMBOL_REF_TLS_MODEL

@item SYMBOL_REF_TLS_MODEL (@var{x})

@item SYMBOL_REF_TLS_MODEL (@var{x})

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

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

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

non-thread-local symbols.

non-thread-local symbols.

@findex SYMBOL_REF_HAS_BLOCK_INFO_P

@findex SYMBOL_REF_HAS_BLOCK_INFO_P

@findex SYMBOL_FLAG_HAS_BLOCK_INFO

@findex SYMBOL_FLAG_HAS_BLOCK_INFO

@item SYMBOL_FLAG_HAS_BLOCK_INFO

@item SYMBOL_FLAG_HAS_BLOCK_INFO

Set if the symbol has @code{SYMBOL_REF_BLOCK} and

Set if the symbol has @code{SYMBOL_REF_BLOCK} and

@code{SYMBOL_REF_BLOCK_OFFSET} fields.

@code{SYMBOL_REF_BLOCK_OFFSET} fields.

@findex SYMBOL_REF_ANCHOR_P

@findex SYMBOL_REF_ANCHOR_P

@findex SYMBOL_FLAG_ANCHOR

@findex SYMBOL_FLAG_ANCHOR

@cindex @option{-fsection-anchors}

@cindex @option{-fsection-anchors}

@item SYMBOL_FLAG_ANCHOR

@item SYMBOL_FLAG_ANCHOR

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

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

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

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

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

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

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

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

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

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

@end table

@end table

Bits beginning with @code{SYMBOL_FLAG_MACH_DEP} are available for

Bits beginning with @code{SYMBOL_FLAG_MACH_DEP} are available for

the target's use.

the target's use.

@end table

@end table

@findex SYMBOL_REF_BLOCK

@findex SYMBOL_REF_BLOCK

@item SYMBOL_REF_BLOCK (@var{x})

@item SYMBOL_REF_BLOCK (@var{x})

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

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

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

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

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

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

@findex SYMBOL_REF_BLOCK_OFFSET

@findex SYMBOL_REF_BLOCK_OFFSET

@item SYMBOL_REF_BLOCK_OFFSET (@var{x})

@item SYMBOL_REF_BLOCK_OFFSET (@var{x})

If @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})}, this is the offset of @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

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

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

been given an offset within that block.

been given an offset within that block.

@end table

@end table

@node Flags

@node Flags

@section Flags in an RTL Expression

@section Flags in an RTL Expression

@cindex flags in RTL expression

@cindex flags in RTL expression

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

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

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

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

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

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

@table @code

@table @code

@findex CONSTANT_POOL_ADDRESS_P

@findex CONSTANT_POOL_ADDRESS_P

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

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

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

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

@item CONSTANT_POOL_ADDRESS_P (@var{x})

@item CONSTANT_POOL_ADDRESS_P (@var{x})

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

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

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

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

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

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

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

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

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

perhaps with the help of base registers.

perhaps with the help of base registers.

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

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

@findex CONST_OR_PURE_CALL_P

@findex CONST_OR_PURE_CALL_P

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

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

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

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

@item CONST_OR_PURE_CALL_P (@var{x})

@item CONST_OR_PURE_CALL_P (@var{x})

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

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.

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

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

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

@findex INSN_ANNULLED_BRANCH_P

@findex INSN_ANNULLED_BRANCH_P

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

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

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

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

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

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

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

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

@item INSN_ANNULLED_BRANCH_P (@var{x})

@item INSN_ANNULLED_BRANCH_P (@var{x})

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

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

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

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

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

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

printed as @samp{/u}.

printed as @samp{/u}.

@findex INSN_DELETED_P

@findex INSN_DELETED_P

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

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

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

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

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

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

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

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

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

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

@cindex @code{note} 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}

@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})

@item INSN_DELETED_P (@var{x})

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

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

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

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

nonzero if the insn has been deleted.  Stored in the

nonzero if the insn has been deleted.  Stored in the

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

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

@findex INSN_FROM_TARGET_P

@findex INSN_FROM_TARGET_P

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

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

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

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

@cindex @code{call_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}

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

@item INSN_FROM_TARGET_P (@var{x})

@item INSN_FROM_TARGET_P (@var{x})

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

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

slot of a branch, indicates that the insn

slot of a branch, indicates that the insn

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

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

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

the branch is taken.  For annulled branches with

the branch is taken.  For annulled branches with

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

@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,

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}

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

field and printed as @samp{/s}.

field and printed as @samp{/s}.

@findex LABEL_PRESERVE_P

@findex LABEL_PRESERVE_P

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

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

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

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

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

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

@item LABEL_PRESERVE_P (@var{x})

@item LABEL_PRESERVE_P (@var{x})

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

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.

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

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

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

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

@findex LABEL_REF_NONLOCAL_P

@findex LABEL_REF_NONLOCAL_P

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

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

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

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

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

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

@item LABEL_REF_NONLOCAL_P (@var{x})

@item LABEL_REF_NONLOCAL_P (@var{x})

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

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

a reference to a non-local label.

a reference to a non-local label.

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

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

@findex MEM_IN_STRUCT_P

@findex MEM_IN_STRUCT_P

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

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

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

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

@item MEM_IN_STRUCT_P (@var{x})

@item MEM_IN_STRUCT_P (@var{x})

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

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

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

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}

@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.

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}.

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

@findex MEM_KEEP_ALIAS_SET_P

@findex MEM_KEEP_ALIAS_SET_P

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

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

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

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

@item MEM_KEEP_ALIAS_SET_P (@var{x})

@item MEM_KEEP_ALIAS_SET_P (@var{x})

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

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

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

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

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

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

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

@findex MEM_SCALAR_P

@findex MEM_SCALAR_P

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

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

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

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

@item MEM_SCALAR_P (@var{x})

@item MEM_SCALAR_P (@var{x})

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

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

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

references and for indirections through pointers, even pointers pointing

references and for indirections through pointers, even pointers pointing

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

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.

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

Both flags should never be simultaneously set.

Both flags should never be simultaneously set.

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

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

@findex MEM_VOLATILE_P

@findex MEM_VOLATILE_P

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

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

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

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

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

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

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

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

@item MEM_VOLATILE_P (@var{x})

@item MEM_VOLATILE_P (@var{x})

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

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

nonzero for volatile memory references.

nonzero for volatile memory references.

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

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

@findex MEM_NOTRAP_P

@findex MEM_NOTRAP_P

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

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

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

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

@item MEM_NOTRAP_P (@var{x})

@item MEM_NOTRAP_P (@var{x})

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

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

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

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

@findex REG_FUNCTION_VALUE_P

@findex REG_FUNCTION_VALUE_P

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

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

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

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

@item REG_FUNCTION_VALUE_P (@var{x})

@item REG_FUNCTION_VALUE_P (@var{x})

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

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

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

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

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

@samp{/i}.

@samp{/i}.

@findex REG_POINTER

@findex REG_POINTER

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

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

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

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

@item REG_POINTER (@var{x})

@item REG_POINTER (@var{x})

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

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

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

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

@findex REG_USERVAR_P

@findex REG_USERVAR_P

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

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

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

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

@item REG_USERVAR_P (@var{x})

@item REG_USERVAR_P (@var{x})

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

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 user's source code.  Zero for temporaries generated internally by

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

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

@samp{/v}.

@samp{/v}.

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

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

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

in this kind of use.

in this kind of use.

@findex RTX_FRAME_RELATED_P

@findex RTX_FRAME_RELATED_P

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

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

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

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

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

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

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

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

@cindex @code{set} 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}

@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})

@item RTX_FRAME_RELATED_P (@var{x})

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

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

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

@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.

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

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

register to use in place of the frame pointer.

register to use in place of the frame pointer.

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

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

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

immediate constants, it is sometimes impossible to reach the register

immediate constants, it is sometimes impossible to reach the register

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

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

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

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

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

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

instruction that sets this temporary register must be marked as

instruction that sets this temporary register must be marked as

@code{RTX_FRAME_RELATED_P}.

@code{RTX_FRAME_RELATED_P}.

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

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

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

@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

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

instruction.  This note should contain a simple expression of the

instruction.  This note should contain a simple expression of the

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

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

@code{dwarf2out_frame_debug_expr} can handle.

@code{dwarf2out_frame_debug_expr} can handle.

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

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

prologues.

prologues.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@cindex @code{note} 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}

@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

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

resulted from an in-line function call.

resulted from an in-line function call.

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

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

@findex MEM_READONLY_P

@findex MEM_READONLY_P

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

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

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

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

@item MEM_READONLY_P (@var{x})

@item MEM_READONLY_P (@var{x})

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

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

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

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

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

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

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

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

application, this memory will never be subsequently modified.

application, this memory will never be subsequently modified.

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

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

@findex SCHED_GROUP_P

@findex SCHED_GROUP_P

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

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

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

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

@cindex @code{jump_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}

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

@item SCHED_GROUP_P (@var{x})

@item SCHED_GROUP_P (@var{x})

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

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

@code{jump_insn}, indicates that the

@code{jump_insn}, indicates that the

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

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

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

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

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

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

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}.

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

@findex SET_IS_RETURN_P

@findex SET_IS_RETURN_P

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

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

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

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

@item SET_IS_RETURN_P (@var{x})

@item SET_IS_RETURN_P (@var{x})

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

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

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

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

@findex SIBLING_CALL_P

@findex SIBLING_CALL_P

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

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

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

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

@item SIBLING_CALL_P (@var{x})

@item SIBLING_CALL_P (@var{x})

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

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

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

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

@findex STRING_POOL_ADDRESS_P

@findex STRING_POOL_ADDRESS_P

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

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

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

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

@item STRING_POOL_ADDRESS_P (@var{x})

@item STRING_POOL_ADDRESS_P (@var{x})

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

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

string constant pool.

string constant pool.

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

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

@findex SUBREG_PROMOTED_UNSIGNED_P

@findex SUBREG_PROMOTED_UNSIGNED_P

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

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

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

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

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

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

@item SUBREG_PROMOTED_UNSIGNED_P (@var{x})

@item SUBREG_PROMOTED_UNSIGNED_P (@var{x})

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

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

@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

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.

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

Stored in the @code{unchanging}

Stored in the @code{unchanging}

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

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

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.

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

@findex SUBREG_PROMOTED_UNSIGNED_SET

@findex SUBREG_PROMOTED_UNSIGNED_SET

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

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

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

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

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

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

@item SUBREG_PROMOTED_UNSIGNED_SET (@var{x})

@item SUBREG_PROMOTED_UNSIGNED_SET (@var{x})

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

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

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

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

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

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

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

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

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

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

@findex SUBREG_PROMOTED_VAR_P

@findex SUBREG_PROMOTED_VAR_P

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

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

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

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

@item SUBREG_PROMOTED_VAR_P (@var{x})

@item SUBREG_PROMOTED_VAR_P (@var{x})

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

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

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

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

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.

@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

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

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

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

printed as @samp{/s}.

printed as @samp{/s}.

@findex SYMBOL_REF_USED

@findex SYMBOL_REF_USED

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

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

@item SYMBOL_REF_USED (@var{x})

@item SYMBOL_REF_USED (@var{x})

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

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

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

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

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

@findex SYMBOL_REF_WEAK

@findex SYMBOL_REF_WEAK

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

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

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

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

@item SYMBOL_REF_WEAK (@var{x})

@item SYMBOL_REF_WEAK (@var{x})

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

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

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

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

@findex SYMBOL_REF_FLAG

@findex SYMBOL_REF_FLAG

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

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

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

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

@item SYMBOL_REF_FLAG (@var{x})

@item SYMBOL_REF_FLAG (@var{x})

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

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}.

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

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

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}

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

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

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

@end table

@end table

These are the fields to which the above macros refer:

These are the fields to which the above macros refer:

@table @code

@table @code

@findex call

@findex call

@cindex @samp{/c} in RTL dump

@cindex @samp{/c} in RTL dump

@item call

@item call

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

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

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

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

@findex frame_related

@findex frame_related

@cindex @samp{/f} in RTL dump

@cindex @samp{/f} in RTL dump

@item frame_related

@item frame_related

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

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,

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

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

frame pointer.

frame pointer.

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

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

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

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

this function's string constant pool.

this function's string constant pool.

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

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

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

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

@findex in_struct

@findex in_struct

@cindex @samp{/s} in RTL dump

@cindex @samp{/s} in RTL dump

@item in_struct

@item in_struct

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

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

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

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

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

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

to determine something about possible cases of aliasing.

to determine something about possible cases of aliasing.

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

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

contained within the test expression of some loop.

contained within the test expression of some loop.

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

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

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

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

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

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}

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

was found.

was found.

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

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

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

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

@code{NOTE_INSN_DELETED_LABEL}.

@code{NOTE_INSN_DELETED_LABEL}.

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

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

dead code.

dead code.

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

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

delay slot of a branch,

delay slot of a branch,

1 means that this insn is from the target of the 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

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.

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

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

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

@findex integrated

@findex integrated

@cindex @samp{/i} in RTL dump

@cindex @samp{/i} in RTL dump

@item integrated

@item integrated

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

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

produced by procedure integration.

produced by procedure integration.

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

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

the value to be returned by the current function.  On