+2001-06-24 Joseph S. Myers <jsm28@cam.ac.uk>
+
+ * doc/extend.texi, doc/gcc.texi, doc/install-old.texi,
+ doc/invoke.texi, doc/md.texi, doc/rtl.texi, doc/tm.texi: Remove
+ uses of @refill.
+
Sun Jun 24 21:21:49 CEST 2001 Jan Hubicka <jh@suse.cz>
* (movsi_insv_1, movsi_insv_1_rex64): Allow immediate operand.
@noindent
the value of @code{__alignof__ (foo1.y)} is probably 2 or 4, the same as
@code{__alignof__ (int)}, even though the data type of @code{foo1.y}
-does not itself demand any alignment.@refill
+does not itself demand any alignment.
It is an error to ask for the alignment of an incomplete type.
compiled with @option{-traditional}. The ISO C99 keyword
@code{restrict} is only available when @option{-std=gnu99} (which will
eventually be the default) or @option{-std=c99} (or the equivalent
-@option{-std=iso9899:1999}) is used.@refill
+@option{-std=iso9899:1999}) is used.
The way to solve these problems is to put @samp{__} at the beginning and
end of each problematical keyword. For example, use @code{__asm__}
The language-independent source files for parsing are
@file{stor-layout.c}, @file{fold-const.c}, and @file{tree.c}.
There are also header files @file{tree.h} and @file{tree.def}
-which define the format of the tree representation.@refill
+which define the format of the tree representation.
C Preprocessing, for language front ends, that want or require it, is
performed by cpplib, which is covered in seperate documentation. In
Also, the file
@file{insn-emit.c}, generated from the machine description by the
program @code{genemit}, is used in this pass. The header file
-@file{expr.h} is used for communication within this pass.@refill
+@file{expr.h} is used for communication within this pass.
@findex genflags
@findex gencodes
The header files @file{insn-flags.h} and @file{insn-codes.h},
generated from the machine description by the programs @code{genflags}
and @code{gencodes}, tell this pass which standard names are available
-for use and which patterns correspond to them.@refill
+for use and which patterns correspond to them.
Aside from debugging information output, none of the following passes
refers to the tree structure representation of the function (only
@file{recog.c} and @file{recog.h}, plus the files @file{insn-recog.c}
and @file{insn-extract.c} that are generated automatically from the
machine description by the tools @file{genrecog} and
-@file{genextract}.@refill
+@file{genextract}.
@item
Several passes use the header files @file{regs.h} which defines the
@file{insn-attr.h}, which is generated from the machine description by
the program @file{genattr}. The file @file{insn-attrtab.c} contains
subroutines to obtain the attribute values for insns. It is generated
-from the machine description by the program @file{genattrtab}.@refill
+from the machine description by the program @file{genattrtab}.
@end itemize
@end ifset
Define the VMS logical names @samp{GNU_CC} and @samp{GNU_CC_INCLUDE}
to point to the directories where the GNU CC executables
(@file{gcc-cpp.exe}, @file{gcc-cc1.exe}, etc.) and the C include files are
-kept respectively. This should be done with the commands:@refill
+kept respectively. This should be done with the commands:
@smallexample
$ assign /system /translation=concealed -
@item
Define the VMS logical name @samp{GNU_GXX_INCLUDE} to point to the
directory where the preprocessor will search for the C++ header files.
-This can be done with the command:@refill
+This can be done with the command:
@smallexample
$ assign /system /translation=concealed -
@file{tm.h}, @file{config.h}, @file{aux-output.c}, and @file{md.}, and
to create files @file{tconfig.h} and @file{hconfig.h}. This procedure
also creates several linker option files used by @file{make-cc1.com} and
-a data file used by @file{make-l2.com}.@refill
+a data file used by @file{make-l2.com}.
@smallexample
$ @@vmsconfig.com
Setup the logical names and command tables as defined above. In
addition, define the VMS logical name @samp{GNU_BISON} to point at the
to the directories where the Bison executable is kept. This should be
-done with the command:@refill
+done with the command:
@smallexample
$ assign /system /translation=concealed -
@file{[BISON]} directory.
@item
-Install the @samp{BISON} command with the command line:@refill
+Install the @samp{BISON} command with the command line:
@smallexample
$ set command /table=sys$common:[syslib]dcltables -
the file @file{make-gcc.com} to a batch queue). If you wish to build
the GNU C++ compiler as well as the GNU CC compiler, you must first edit
@file{make-gcc.com} and follow the instructions that appear in the
-comments.@refill
+comments.
@item
In order to use GCC, you need a library of functions which GCC compiled code
the same distribution that @file{libgcc2.c} came from, and
@file{make-gcc.com} will automatically do all of this for you.
-To install the library, use the following commands:@refill
+To install the library, use the following commands:
@smallexample
$ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
If @option{-o} is not specified, the default is to put an executable file
in @file{a.out}, the object file for @file{@var{source}.@var{suffix}} in
@file{@var{source}.o}, its assembler file in @file{@var{source}.s}, and
-all preprocessed C source on standard output.@refill
+all preprocessed C source on standard output.
@item -v
@opindex v
@option{-fdelayed-branch} on machines that have delay slots, and
@option{-fomit-frame-pointer} on machines that can support debugging even
without a frame pointer. On some machines the compiler also turns
-on other flags.@refill
+on other flags.
@item -O2
@opindex O2
the standard calling sequence automatically handles the frame pointer
and nothing is saved by pretending it doesn't exist. The
machine-description macro @code{FRAME_POINTER_REQUIRED} controls
-whether a target machine supports this flag. @xref{Registers}.@refill
+whether a target machine supports this flag. @xref{Registers}.
@end ifset
@ifclear INTERNALS
On some machines, such as the Vax, this flag has no effect, because
and nothing is saved by pretending it doesn't exist. The
machine-description macro @code{FRAME_POINTER_REQUIRED} controls
whether a target machine supports this flag. @xref{Registers,,Register
-Usage, gcc.info, Using and Porting GCC}.@refill
+Usage, gcc.info, Using and Porting GCC}.
@end ifclear
@item -foptimize-sibling-calls
The @option{-b} and @option{-V} options actually work by controlling part of
the file name used for the executable files and libraries used for
compilation. A given version of GCC, for a given target machine, is
-normally kept in the directory @file{/usr/local/lib/gcc-lib/@var{machine}/@var{version}}.@refill
+normally kept in the directory @file{/usr/local/lib/gcc-lib/@var{machine}/@var{version}}.
Thus, sites can customize the effect of @option{-b} or @option{-V} either by
changing the names of these directories or adding alternate names (or
@option{-mcpu=power2}, @option{-mcpu=powerpc}, and @option{-mcpu=powerpc64}
specify generic POWER, POWER2, pure 32-bit PowerPC (i.e., not MPC601),
and 64-bit PowerPC architecture machine types, with an appropriate,
-generic processor model assumed for scheduling purposes.@refill
+generic processor model assumed for scheduling purposes.
Specifying any of the following options:
@option{-mcpu=rios1}, @option{-mcpu=rios2}, @option{-mcpu=rsc},
@option{-mcpu=505}, @option{-mcpu=821}, @option{-mcpu=860} and @option{-mcpu=powerpc}
enable the @option{-mpowerpc} option and disable the @option{-mpower} option.
@option{-mcpu=common} disables both the
-@option{-mpower} and @option{-mpowerpc} options.@refill
+@option{-mpower} and @option{-mpowerpc} options.
AIX versions 4 or greater selects @option{-mcpu=common} by default, so
that code will operate on all members of the RS/6000 POWER and PowerPC
@option{-mcpu=602}, @option{-mcpu=603}, @option{-mcpu=603e}, @option{-mcpu=604},
@option{-mcpu=620}, @option{-mcpu=630}, @option{-mcpu=403}, @option{-mcpu=505},
@option{-mcpu=821}, @option{-mcpu=860} or @option{-mcpu=powerpc} also enables
-the @samp{new-mnemonics} option.@refill
+the @samp{new-mnemonics} option.
Specifying @option{-mcpu=403}, @option{-mcpu=821}, or @option{-mcpu=860} also
enables the @option{-msoft-float} option.
GCC to make only one TOC entry for every file. When you specify this
option, GCC will produce code that is slower and larger but which
uses extremely little TOC space. You may wish to use this option
-only on files that contain less frequently executed code. @refill
+only on files that contain less frequently executed code.
@item -maix64
@itemx -maix32
@emph{and} the function @var{predicate} returns nonzero on the
@code{parallel} that is the body of the insn. It is the responsibility
of the predicate to validate elements of the @code{parallel} beyond
-those listed in the @code{match_parallel}.@refill
+those listed in the @code{match_parallel}.
A typical use of @code{match_parallel} is to match load and store
multiple expressions, which can contain a variable number of elements
@item
The only possible RTL expressions involving both bitwise exclusive-or
and bitwise negation are @code{(xor:@var{m} @var{x} @var{y})}
-and @code{(not:@var{m} (xor:@var{m} @var{x} @var{y}))}.@refill
+and @code{(not:@var{m} (xor:@var{m} @var{x} @var{y}))}.
@item
The sum of three items, one of which is a constant, will only appear in
@item
On machines that do not use @code{cc0},
@code{(compare @var{x} (const_int 0))} will be converted to
-@var{x}.@refill
+@var{x}.
@cindex @code{zero_extract}, canonicalization of
@cindex @code{sign_extract}, canonicalization of
@code{jump_insn} or @code{call_insn}. If you don't need a real insn
at the end, emit an insn to copy the result of the operation into
itself. Such an insn will generate no code, but it can avoid problems
-in the compiler.@refill
+in the compiler.
@node Insn Splitting
@section Defining How to Split Instructions
In this skeleton, @var{insn-pattern-1} and so on are patterns to match
consecutive insns. The optimization applies to a sequence of insns when
@var{insn-pattern-1} matches the first one, @var{insn-pattern-2} matches
-the next, and so on.@refill
+the next, and so on.
Each of the insns matched by a peephole must also match a
@code{define_insn}. Peepholes are checked only at the last stage just
@var{op})}, where @var{insn} is the insn in which you expect the value
to be used for the last time (from the value of @code{insn}, together
with use of @code{prev_nonnote_insn}), and @var{op} is the intermediate
-value (from @code{operands[@var{i}]}).@refill
+value (from @code{operands[@var{i}]}).
Applying the optimization means replacing the sequence of insns with one
new insn. The @var{template} controls ultimate output of assembler code
If @var{value} is specified as @samp{"*"}, it means that the default value of
the attribute is to be used for the insn containing this expression.
@samp{"*"} obviously cannot be used in the @var{default} expression
-of a @code{define_attr}.@refill
+of a @code{define_attr}.
If the attribute whose value is being specified is numeric, @var{value}
must be a string containing a non-negative integer (normally
expressions is true. Arithmetic expressions are formed with
@code{plus}, @code{minus}, @code{mult}, @code{div}, @code{mod},
@code{abs}, @code{neg}, @code{and}, @code{ior}, @code{xor}, @code{not},
-@code{ashift}, @code{lshiftrt}, and @code{ashiftrt} expressions.@refill
+@code{ashift}, @code{lshiftrt}, and @code{ashiftrt} expressions.
@findex get_attr
@code{const_int} and @code{symbol_ref} are always valid terms (@pxref{Insn
Lengths},for additional forms). @code{symbol_ref} is a string
denoting a C expression that yields an @code{int} when evaluated by the
@samp{get_attr_@dots{}} routine. It should normally be a global
-variable.@refill
+variable.
@findex eq_attr
@item (eq_attr @var{name} @var{value})
If @var{name} specifies an attribute of @samp{alternative}, it refers to the
value of the compiler variable @code{which_alternative}
(@pxref{Output Statement}) and the values must be small integers. For
-example,@refill
+example,
@smallexample
(eq_attr "alternative" "2,3")
Note that, for most attributes, an @code{eq_attr} test is simplified in cases
where the value of the attribute being tested is known for all insns matching
-a particular pattern. This is by far the most common case.@refill
+a particular pattern. This is by far the most common case.
@findex attr_flag
@item (attr_flag @var{name})
@code{define_attr}. Extensive use of default values for attributes
permits the specification of the values for only one or two attributes
in the definition of most insn patterns, as seen in the example in the
-next section.@refill
+next section.
The optional last argument of @code{define_insn} and
@code{define_peephole} is a vector of expressions, each of which defines
attribute's value is to use a @code{set} expression whose first operand is an
@code{attr} expression giving the name of the attribute being set. The
second operand of the @code{set} is an attribute expression
-(@pxref{Expressions}) giving the value of the attribute.@refill
+(@pxref{Expressions}) giving the value of the attribute.
When the attribute value depends on the @samp{alternative} attribute
(i.e., which is the applicable alternative in the constraint of the
attribute test that specifies which insns may be annulled if the branch
is true. Similarly, @var{annul-false-n} specifies which insns in the
delay slot may be annulled if the branch is false. If annulling is not
-supported for that delay slot, @code{(nil)} should be coded.@refill
+supported for that delay slot, @code{(nil)} should be coded.
For example, in the common case where branch and call insns require
a single delay slot, which may contain any insn other than a branch or
@samp{w} for wide integer, @samp{s} for string, and @samp{E} for vector
of expressions. The sequence of letters for an expression code is
called its @dfn{format}. For example, the format of @code{subreg} is
-@samp{ei}.@refill
+@samp{ei}.
@cindex RTL format characters
A few other format characters are used occasionally:
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,@refill
+(counting from zero). Thus,
@example
XEXP (@var{x}, 2)
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.@refill
+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{constm1_rtx}. Any attempt to create an expression of code
@code{const_int} and value zero, one, two or negative one will return
@code{const0_rtx}, @code{const1_rtx}, @code{const2_rtx} or
-@code{constm1_rtx} as appropriate.@refill
+@code{constm1_rtx} as appropriate.
@findex const_true_rtx
Similarly, there is only one object for the integer whose value is
@code{STORE_FLAG_VALUE} is one, @code{const_true_rtx} and
@code{const1_rtx} will point to the same object. If
@code{STORE_FLAG_VALUE} is @minus{}1, @code{const_true_rtx} and
-@code{constm1_rtx} will point to the same object.@refill
+@code{constm1_rtx} will point to the same object.
@findex const_double
@item (const_double:@var{m} @var{addr} @var{i0} @var{i1} @dots{})
undisplayed field), @var{addr} contains @code{const0_rtx}. If it is not
on the chain, @var{addr} contains @code{cc0_rtx}. @var{addr} is
customarily accessed with the macro @code{CONST_DOUBLE_MEM} and the
-chain field via @code{CONST_DOUBLE_CHAIN}.@refill
+chain field via @code{CONST_DOUBLE_CHAIN}.
@findex CONST_DOUBLE_LOW
If @var{m} is @code{VOIDmode}, the bits of the value are stored in
represented by @var{lval}. @var{lval} must be an expression
representing a place that can be stored in: @code{reg} (or @code{subreg}
or @code{strict_low_part}), @code{mem}, @code{pc}, @code{parallel}, or
-@code{cc0}.@refill
+@code{cc0}.
If @var{lval} is a @code{reg}, @code{subreg} or @code{mem}, it has a
-machine mode; then @var{x} must be valid for that mode.@refill
+machine mode; then @var{x} must be valid for that mode.
If @var{lval} is a @code{reg} whose machine mode is less than the full
width of the register, then it means that the part of the register
If @var{lval} is a @code{strict_low_part} of a @code{subreg}, then the
part of the register specified by the machine mode of the
@code{subreg} is given the value @var{x} and the rest of the register
-is not changed.@refill
+is not changed.
If @var{lval} is @code{(cc0)}, it has no machine mode, and @var{x} may
be either a @code{compare} expression or a value that may have any mode.
(for the case which does jump). @var{x} may also be a @code{mem} or
@code{(plus:SI (pc) @var{y})}, where @var{y} may be a @code{reg} or a
@code{mem}; these unusual patterns are used to represent jumps through
-branch tables.@refill
+branch tables.
If @var{lval} is neither @code{(cc0)} nor @code{(pc)}, the mode of
@var{lval} must not be @code{VOIDmode} and the mode of @var{x} must be
brackets stand for a vector; the operand of @code{parallel} is a
vector of expressions. @var{x0}, @var{x1} and so on are individual
side effect expressions---expressions of code @code{set}, @code{call},
-@code{return}, @code{clobber} or @code{use}.@refill
+@code{return}, @code{clobber} or @code{use}.
``In parallel'' means that first all the values used in the individual
side-effects are computed, and second all the actual side-effects are
are set up by branch shortening and hold a label with a minimum and a
maximum address, respectively. @var{flags} indicates the relative
position of @var{base}, @var{min} and @var{max} to the containing insn
-and of @var{min} and @var{max} to @var{base}. See rtl.def for details.@refill
+and of @var{min} and @var{max} to @var{base}. See rtl.def for details.
@end table
@node Incdec
for pointers on the machine in use. The amount @var{x} is decremented
by is the length in bytes of the machine mode of the containing memory
reference of which this expression serves as the address. Here is an
-example of its use:@refill
+example of its use:
@example
(mem:DF (pre_dec:SI (reg:SI 39)))
@end table
where @var{z} is an index register and @var{i} is a constant.
-Here is an example of its use:@refill
+Here is an example of its use:
@example
(mem:SF (post_modify:SI (reg:SI 42) (plus (reg:SI 42) (reg:SI 48))))
is the insn containing the @code{sequence} expression, as is the value
of @code{PREV_INSN (NEXT_INSN (@var{insn}))} is @var{insn} is the last
insn in the @code{sequence} expression. You can use these expressions
-to find the containing @code{sequence} expression.@refill
+to find the containing @code{sequence} expression.
Every insn has one of the following six expression codes:
@code{REG_CC_USER} note will be placed on the insn setting @code{cc0} to
point to the insn using @code{cc0} and a @code{REG_CC_SETTER} note will
be placed on the insn using @code{cc0} to point to the insn setting
-@code{cc0}.@refill
+@code{cc0}.
@end table
These values are only used in the @code{LOG_LINKS} field, and indicate
function is @code{STATIC_CHAIN_INCOMING_REGNUM}, while the register
number as seen by the calling function is @code{STATIC_CHAIN_REGNUM}. If
these registers are the same, @code{STATIC_CHAIN_INCOMING_REGNUM} need
-not be defined.@refill
+not be defined.
The static chain register need not be a fixed register.
@code{STATIC_CHAIN} and @code{STATIC_CHAIN_INCOMING} give the locations
as seen by the calling and called functions, respectively. Often the former
will be at an offset from the stack pointer and the latter at an offset from
-the frame pointer.@refill
+the frame pointer.
@findex stack_pointer_rtx
@findex frame_pointer_rtx
without a frame pointer. The compiler recognizes those cases and
automatically gives the function a frame pointer regardless of what
@code{FRAME_POINTER_REQUIRED} says. You don't need to worry about
-them.@refill
+them.
In a function that does not require a frame pointer, the frame pointer
register can be allocated for ordinary usage, unless you mark it as a
where the arguments will arrive.
If @code{FUNCTION_INCOMING_ARG} is not defined, @code{FUNCTION_ARG}
-serves both purposes.@refill
+serves both purposes.
@findex FUNCTION_ARG_PARTIAL_NREGS
@item FUNCTION_ARG_PARTIAL_NREGS (@var{cum}, @var{mode}, @var{type}, @var{named})
@var{cum} to advance past an argument in the argument list. The
values @var{mode}, @var{type} and @var{named} describe that argument.
Once this is done, the variable @var{cum} is suitable for analyzing
-the @emph{following} argument with @code{FUNCTION_ARG}, etc.@refill
+the @emph{following} argument with @code{FUNCTION_ARG}, etc.
This macro need not do anything if the argument in question was passed
on the stack. The compiler knows how to track the amount of stack space
(@var{valtype})} to get the machine mode used to represent that type.
On many machines, only the mode is relevant. (Actually, on most
machines, scalar values are returned in the same place regardless of
-mode).@refill
+mode).
The value of the expression is usually a @code{reg} RTX for the hard
register where the return value is stored. The value can also be a
node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null
pointer. This makes it possible to use a different value-returning
convention for specific functions when all their calls are
-known.@refill
+known.
@code{FUNCTION_VALUE} is not used for return vales with aggregate data
types, because these are returned in another way. See
For such machines, @code{FUNCTION_VALUE} computes the register in which
the caller will see the value. @code{FUNCTION_OUTGOING_VALUE} should be
defined in a similar fashion to tell the function where to put the
-value.@refill
+value.
If @code{FUNCTION_OUTGOING_VALUE} is not defined,
-@code{FUNCTION_VALUE} serves both purposes.@refill
+@code{FUNCTION_VALUE} serves both purposes.
@code{FUNCTION_OUTGOING_VALUE} is not used for return vales with
aggregate data types, because these are returned in another way. See
(@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null
pointer. This makes it possible to use a different value-returning
convention for specific functions when all their calls are
-known.@refill
+known.
Note that ``library function'' in this context means a compiler
support routine, used to perform arithmetic, whose name is known
for base registers, one for index registers, and so on) are typically
among the subroutines used to define @code{GO_IF_LEGITIMATE_ADDRESS}.
Then only these subroutine macros need have two variants; the higher
-levels of macros may be the same whether strict or not.@refill
+levels of macros may be the same whether strict or not.
Normally, constant addresses which are the sum of a @code{symbol_ref}
and an integer are stored inside a @code{const} RTX to mark them as
an immediate operand on the target machine. You can assume that
@var{x} satisfies @code{CONSTANT_P}, so you need not check this. In fact,
@samp{1} is a suitable definition for this macro on machines where
-anything @code{CONSTANT_P} is valid.@refill
+anything @code{CONSTANT_P} is valid.
@end table
@node Condition Code
respectively, whose value is @var{value}. The argument @var{exp} will
be an RTL expression which represents a constant value. Use
@samp{output_addr_const (@var{stream}, @var{exp})} to output this value
-as an assembler expression.@refill
+as an assembler expression.
For sizes larger than @code{UNITS_PER_WORD}, if the action of a macro
would be identical to repeatedly calling the macro corresponding to
to assemble 16-, 32-, and 64-bit integers respectively @emph{without}
adding implicit padding or alignment. These macros are required if
DWARF 2 frame unwind is used. On ELF systems, these will default
-to @code{.2byte}, @code{.4byte}, and @code{.8byte}.@refill
+to @code{.2byte}, @code{.4byte}, and @code{.8byte}.
@findex ASM_OUTPUT_ASCII
@item ASM_OUTPUT_ASCII (@var{stream}, @var{ptr}, @var{len})
The operation to be performed is specified by @var{code}, a tree code
which will always be one of the following: @code{PLUS_EXPR},
@code{MINUS_EXPR}, @code{MULT_EXPR}, @code{RDIV_EXPR},
-@code{MAX_EXPR}, @code{MIN_EXPR}.@refill
+@code{MAX_EXPR}, @code{MIN_EXPR}.
@cindex overflow while constant folding
The expansion of this macro is responsible for checking for overflow.
@item IMPLICIT_FIX_EXPR
An alias for a tree code that should be used by default for conversion
of floating point values to fixed point. Normally,
-@code{FIX_ROUND_EXPR} is used.@refill
+@code{FIX_ROUND_EXPR} is used.
@findex FIXUNS_TRUNC_LIKE_FIX_TRUNC
@item FIXUNS_TRUNC_LIKE_FIX_TRUNC
@code{ROUND_DIV_EXPR}. These four division operators differ in how
they round the result to an integer. @code{EASY_DIV_EXPR} is used
when it is permissible to use any of those kinds of division and the
-choice should be made on the basis of efficiency.@refill
+choice should be made on the basis of efficiency.
@findex MOVE_MAX
@item MOVE_MAX
projects / thirdparty / gcc.git / commitdiff
