--- gcc/gcc.info-10	2018/04/24 16:53:39	1.1
+++ gcc/gcc.info-10	2018/04/24 16:57:35	1.1.1.3
@@ -3,7 +3,7 @@ file gcc.texinfo.
 
 This file documents the use and the internals of the GNU compiler.
 
-Copyright (C) 1988, 1989 Free Software Foundation, Inc.
+Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.
 
 Permission is granted to make and distribute verbatim copies of this
 manual provided the copyright notice and this permission notice are
@@ -11,18 +11,311 @@ preserved on all copies.
 
 Permission is granted to copy and distribute modified versions of
 this manual under the conditions for verbatim copying, provided also
-that the sections entitled ``GNU General Public License'' and
-``Protect Your Freedom--Fight `Look And Feel''' are included exactly
-as in the original, and provided that the entire resulting derived
-work is distributed under the terms of a permission notice identical
-to this one.
+that the sections entitled "GNU General Public License" and "Protect
+Your Freedom--Fight `Look And Feel'" are included exactly as in the
+original, and provided that the entire resulting derived work is
+distributed under the terms of a permission notice identical to this
+one.
 
 Permission is granted to copy and distribute translations of this
 manual into another language, under the above conditions for modified
-versions, except that the sections entitled ``GNU General Public
-License'' and ``Protect Your Freedom--Fight `Look And Feel''' and
-this permission notice may be included in translations approved by
-the Free Software Foundation instead of in the original English.
+versions, except that the sections entitled "GNU General Public
+License" and "Protect Your Freedom--Fight `Look And Feel'" and this
+permission notice may be included in translations approved by the
+Free Software Foundation instead of in the original English.
+
+
+
+File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Condition Code,  Up: Machine Macros
+
+Cross Compilation and Floating-Point Format
+===========================================
+
+While all modern machines use 2's complement representation for
+integers, there are a variety of representations for floating point
+numbers.  This means that in a cross-compiler the representation of
+floating point numbers in the compiled program may be different from
+that used in the machine doing the compilation.
+
+Because different representation systems may offer different amounts
+of range and precision, the cross compiler cannot safely use the host
+machine's floating point arithmetic.  Therefore, floating point
+constants must be represented in the target machine's format.  This
+means that the cross compiler cannot use `atof' to parse a floating
+point constant; it must have its own special routine to use instead. 
+Also, constant folding must emulate the target machine's arithmetic
+(or must not be done at all).
+
+The macros in the following table should be defined only if you are
+cross compiling between different floating point formats.
+
+Otherwise, don't define them. Then default definitions will be set up
+which use `double' as the data type, `==' to test for equality, etc.
+
+You don't need to worry about how many times you use an operand of
+any of these macros.  The compiler never uses operands which have
+side effects.
+
+`REAL_VALUE_TYPE'
+     A macro for the C data type to be used to hold a floating point
+     value in the target machine's format.  Typically this would be a
+     `struct' containing an array of `int'.
+
+`REAL_VALUES_EQUAL (X, Y)'
+     A macro for a C expression which compares for equality the two
+     values, X and Y, both of type `REAL_VALUE_TYPE'.
+
+`REAL_VALUES_LESS (X, Y)'
+     A macro for a C expression which tests whether X is less than Y,
+     both values being of type `REAL_VALUE_TYPE' and interpreted as
+     floating point numbers in the target machine's representation.
+
+`REAL_VALUE_LDEXP (X, SCALE)'
+     A macro for a C expression which performs the standard library
+     function `ldexp', but using the target machine's floating point
+     representation.  Both X and the value of the expression have
+     type `REAL_VALUE_TYPE'.  The second argument, SCALE, is an
+     integer.
+
+`REAL_VALUE_ATOF (STRING)'
+     A macro for a C expression which converts STRING, an expression
+     of type `char *', into a floating point number in the target
+     machine's representation.  The value has type `REAL_VALUE_TYPE'.
+
+Define the following additional macros if you want to make floating
+point constant folding work while cross compiling.  If you don't
+define them, cross compilation is still possible, but constant
+folding will not happen for floating point values.
+
+`REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
+     A macro for a C statement which calculates an arithmetic
+     operation of the two floating point values X and Y, both of type
+     `REAL_VALUE_TYPE' in the target machine's representation, to
+     produce a result of the same type and representation which is
+     stored in OUTPUT (which will be a variable).
+
+     The operation to be performed is specified by CODE, a tree code
+     which will always be one of the following: `PLUS_EXPR',
+     `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
+
+     The expansion of this macro is responsible for checking for
+     overflow.  If overflow happens, the macro expansion should
+     execute the statement `return 0;', which indicates the inability
+     to perform the arithmetic operation requested.
+
+`REAL_VALUE_NEGATE (X)'
+     A macro for a C expression which returns the negative of the
+     floating point value X.  Both X and the value of the expression
+     have type `REAL_VALUE_TYPE' and are in the target machine's
+     floating point representation.
+
+     There is no way for this macro to report overflow, since
+     overflow can't happen in the negation operation.
+
+`REAL_VALUE_TO_INT (LOW, HIGH, X)'
+     A macro for a C expression which converts a floating point value
+     X into a double-precision integer which is then stored into LOW
+     and HIGH, two variables of type INT.
+
+`REAL_VALUE_FROM_INT (X, LOW, HIGH)'
+     A macro for a C expression which converts a double-precision
+     integer found in LOW and HIGH, two variables of type INT, into a
+     floating point value which is then stored into X.
+
+
+
+File: gcc.info,  Node: Misc,  Next: Assembler Format,  Prev: Cross-compilation,  Up: Machine Macros
+
+Miscellaneous Parameters
+========================
+
+`CASE_VECTOR_MODE'
+     An alias for a machine mode name.  This is the machine mode that
+     elements of a jump-table should have.
+
+`CASE_VECTOR_PC_RELATIVE'
+     Define this macro if jump-tables should contain relative
+     addresses.
+
+`CASE_DROPS_THROUGH'
+     Define this if control falls through a `case' insn when the
+     index value is out of range.  This means the specified
+     default-label is actually ignored by the `case' insn proper.
+
+`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,
+     `FIX_ROUND_EXPR' is used.
+
+`FIXUNS_TRUNC_LIKE_FIX_TRUNC'
+     Define this macro if the same instructions that convert a
+     floating point number to a signed fixed point number also
+     convert validly to an unsigned one.
+
+`EASY_DIV_EXPR'
+     An alias for a tree code that is the easiest kind of division to
+     compile code for in the general case.  It may be
+     `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or
+     `ROUND_DIV_EXPR'.  These four division operators differ in how
+     they round the result to an integer.  `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.
+
+`DEFAULT_SIGNED_CHAR'
+     An expression whose value is 1 or 0, according to whether the
+     type `char' should be signed or unsigned by default.  The user
+     can always override this default with the options
+     `-fsigned-char' and `-funsigned-char'.
+
+`SCCS_DIRECTIVE'
+     Define this if the preprocessor should ignore `#sccs' directives
+     and print no error message.
+
+`HAVE_VPRINTF'
+     Define this if the library function `vprintf' is available on
+     your system.
+
+`MOVE_MAX'
+     The maximum number of bytes that a single instruction can move
+     quickly from memory to memory.
+
+`INT_TYPE_SIZE'
+     A C expression for the size in bits of the type `int' on the
+     target machine.  If you don't define this, the default is one
+     word.
+
+`SHORT_TYPE_SIZE'
+     A C expression for the size in bits of the type `short' on the
+     target machine.  If you don't define this, the default is half a
+     word.  (If this would be less than one storage unit, it is
+     rounded up to one unit.)
+
+`LONG_TYPE_SIZE'
+     A C expression for the size in bits of the type `long' on the
+     target machine.  If you don't define this, the default is one
+     word.
+
+`LONG_LONG_TYPE_SIZE'
+     A C expression for the size in bits of the type `long long' on
+     the target machine.  If you don't define this, the default is
+     two words.
+
+`CHAR_TYPE_SIZE'
+     A C expression for the size in bits of the type `char' on the
+     target machine.  If you don't define this, the default is one
+     quarter of a word.  (If this would be less than one storage
+     unit, it is rounded up to one unit.)
+
+`FLOAT_TYPE_SIZE'
+     A C expression for the size in bits of the type `float' on the
+     target machine.  If you don't define this, the default is one
+     word.
+
+`DOUBLE_TYPE_SIZE'
+     A C expression for the size in bits of the type `double' on the
+     target machine.  If you don't define this, the default is two
+     words.
+
+`LONG_DOUBLE_TYPE_SIZE'
+     A C expression for the size in bits of the type `long double' on
+     the target machine.  If you don't define this, the default is
+     two words.
+
+`SLOW_BYTE_ACCESS'
+     Define this macro as a C expression which is nonzero if
+     accessing less than a word of memory (i.e. a `char' or a
+     `short') is slow (requires more than one instruction).
+
+`SLOW_ZERO_EXTEND'
+     Define this macro if zero-extension (of a `char' or `short' to
+     an `int') can be done faster if the destination is a register
+     that is known to be zero.
+
+     If you define this macro, you must have instruction patterns
+     that recognize RTL structures like this:
+
+          (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)
+
+     and likewise for `HImode'.
+
+`SHIFT_COUNT_TRUNCATED'
+     Define this macro if shift instructions ignore all but the
+     lowest few bits of the shift count.  It implies that a
+     sign-extend or zero-extend instruction for the shift count can
+     be omitted.
+
+`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
+     A C expression which is nonzero if on this machine it is safe to
+     "convert" an integer of INPREC bits to one of OUTPREC bits
+     (where OUTPREC is smaller than INPREC) by merely operating on it
+     as if it had only OUTPREC bits.
+
+     On many machines, this expression can be 1.
+
+`NO_FUNCTION_CSE'
+     Define this macro if it is as good or better to call a constant
+     function address than to call an address kept in a register.
+
+`PROMOTE_PROTOTYPES'
+     Define this macro if an argument declared as `char' or `short'
+     in a prototype should actually be passed as an `int'.  In
+     addition to avoiding errors in certain cases of mismatch, it
+     also makes for better code on certain machines.
+
+`STORE_FLAG_VALUE'
+     A C expression for the value stored by a store-flag instruction
+     (`sCOND') when the condition is true.  This is usually 1 or -1;
+     it is required to be an odd number or a negative number.
+
+     Do not define `STORE_FLAG_VALUE' if the machine has no
+     store-flag instructions.
+
+`Pmode'
+     An alias for the machine mode for pointers.  Normally the
+     definition can be
+
+          #define Pmode SImode
+
+`FUNCTION_MODE'
+     An alias for the machine mode used for memory references to
+     functions being called, in `call' RTL expressions.  On most
+     machines this should be `QImode'.
+
+`INSN_MACHINE_INFO'
+     This macro should expand into a C structure type to use for the
+     machine-dependent info field specified with the optional last
+     argument in `define_insn' and `define_peephole' patterns.  For
+     example, it might expand into `struct machine_info'; then it
+     would be up to you to define this structure in the `tm.h' file.
+
+     You do not need to define this macro if you do not write the
+     optional last argument in any of the patterns in the machine
+     description.
+
+`DEFAULT_MACHINE_INFO'
+     This macro should expand into a C initializer to use to
+     initialize the machine-dependent info for one insn pattern.  It
+     is used for patterns that do not specify the machine-dependent
+     info.
+
+     If you do not define this macro, zero is used.
+
+`CONST_COSTS (X, CODE)'
+     A part of a C `switch' statement that describes the relative
+     costs of constant RTL expressions.  It must contain `case'
+     labels for expression codes `const_int', `const', `symbol_ref',
+     `label_ref' and `const_double'.  Each case must ultimately reach
+     a `return' statement to return the relative cost of the use of
+     that kind of constant value in an expression.  The cost may
+     depend on the precise value of the constant, which is available
+     for examination in X.
+
+     CODE is the expression code--redundant, since it can be obtained
+     with `GET_CODE (X)'.
+
+`DOLLARS_IN_IDENTIFIERS'
+     Define this to be nonzero if the character `$' should be allowed
+     by default in identifier names.
 
 
 
@@ -407,8 +700,8 @@ Output of Assembler Code
      instruction to assemble a `int', `short' or `char' constant
      whose value is VALUE.  The argument EXP will be an RTL
      expression which represents a constant value.  Use
-     `output_addr_const (EXP)' to output this value as an assembler
-     expression.
+     `output_addr_const (STREAM, EXP)' to output this value as an
+     assembler expression.
 
 `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
      A C statement to output to the stdio stream STREAM an assembler
@@ -512,11 +805,11 @@ Output of Assembler Code
      The definition is a C statement or statements which output an
      assembler instruction opcode to the stdio stream STREAM.  The
      macro-operand PTR is a variable of type `char *' which points to
-     the opcode name in its ``internal'' form--the form that is
-     written in the machine description.  The definition should
-     output the opcode name to STREAM, performing any translation you
-     desire, and increment the variable PTR to point at the end of
-     the opcode so that it will not be output twice.
+     the opcode name in its "internal" form--the form that is written
+     in the machine description.  The definition should output the
+     opcode name to STREAM, performing any translation you desire,
+     and increment the variable PTR to point at the end of the opcode
+     so that it will not be output twice.
 
      In fact, your macro definition may process less than the entire
      opcode name, or more than the opcode name; but if you want to
@@ -616,8 +909,31 @@ identical.  But there are some macros th
      A C expression for the status code to be returned when the
      compiler exits without serious errors.
 
+`USE_C_ALLOCA'
+     Define this macro to indicate that the compiler is running with
+     the `alloca' implemented in C.  This version of `alloca' can be
+     found in the file `alloca.c'; to use it, you must also alter the
+     `Makefile' variable `ALLOCA'.
+
+     This macro, unlike most, describes the machine that the compiler
+     is running on, rather than the one the compiler is compiling for.
+     Therefore, it should be set in the `xm-MACHINE.h' file rather
+     than in the `tm-MACHINE.h' file.
+
+     If you do define this macro, you should probably do it as follows:
+
+          #ifndef __GNUC__
+          #define USE_C_ALLOCA
+          #else
+          #define alloca __builtin_alloca
+          #endif
+
+     so that when the compiler is compiled with GNU CC it uses the
+     more efficient built-in `alloca' function.
+
 In addition, configuration files for system V define `bcopy', `bzero'
 and `bcmp' as aliases.  Some files define `alloca' as a macro when
 compiled with GNU CC, in order to take advantage of the benefit of
 GNU CC's built-in `alloca'.
 
+