Return to gcc.info-22 CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/gcc.info-22, revision 1.1.1.3

1.1.1.3 ! root        1: This is Info file gcc.info, produced by Makeinfo-1.55 from the input
1.1       root        2: file gcc.texi.
                      3: 
                      4:    This file documents the use and the internals of the GNU compiler.
                      5: 
                      6:    Published by the Free Software Foundation 675 Massachusetts Avenue
                      7: Cambridge, MA 02139 USA
                      8: 
1.1.1.3 ! root        9:    Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation,
        !            10: Inc.
1.1       root       11: 
                     12:    Permission is granted to make and distribute verbatim copies of this
                     13: manual provided the copyright notice and this permission notice are
                     14: preserved on all copies.
                     15: 
                     16:    Permission is granted to copy and distribute modified versions of
                     17: this manual under the conditions for verbatim copying, provided also
1.1.1.3 ! root       18: that the sections entitled "GNU General Public License," "Funding for
        !            19: Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
        !            20: included exactly as in the original, and provided that the entire
        !            21: resulting derived work is distributed under the terms of a permission
        !            22: notice identical to this one.
1.1       root       23: 
                     24:    Permission is granted to copy and distribute translations of this
                     25: manual into another language, under the above conditions for modified
                     26: versions, except that the sections entitled "GNU General Public
1.1.1.3 ! root       27: License," "Funding for Free Software," and "Protect Your Freedom--Fight
        !            28: `Look And Feel'", and this permission notice, may be included in
        !            29: translations approved by the Free Software Foundation instead of in the
        !            30: original English.
        !            31: 
        !            32: 
        !            33: File: gcc.info,  Node: Initialization,  Next: Macros for Initialization,  Prev: Label Output,  Up: Assembler Format
        !            34: 
        !            35: How Initialization Functions Are Handled
        !            36: ----------------------------------------
        !            37: 
        !            38:    The compiled code for certain languages includes "constructors"
        !            39: (also called "initialization routines")--functions to initialize data
        !            40: in the program when the program is started.  These functions need to be
        !            41: called before the program is "started"--that is to say, before `main'
        !            42: is called.
        !            43: 
        !            44:    Compiling some languages generates "destructors" (also called
        !            45: "termination routines") that should be called when the program
        !            46: terminates.
        !            47: 
        !            48:    To make the initialization and termination functions work, the
        !            49: compiler must output something in the assembler code to cause those
        !            50: functions to be called at the appropriate time.  When you port the
        !            51: compiler to a new system, you need to specify how to do this.
        !            52: 
        !            53:    There are two major ways that GCC currently supports the execution of
        !            54: initialization and termination functions.  Each way has two variants.
        !            55: Much of the structure is common to all four variations.
        !            56: 
        !            57:    The linker must build two lists of these functions--a list of
        !            58: initialization functions, called `__CTOR_LIST__', and a list of
        !            59: termination functions, called `__DTOR_LIST__'.
        !            60: 
        !            61:    Each list always begins with an ignored function pointer (which may
        !            62: hold 0, -1, or a count of the function pointers after it, depending on
        !            63: the environment).  This is followed by a series of zero or more function
        !            64: pointers to constructors (or destructors), followed by a function
        !            65: pointer containing zero.
        !            66: 
        !            67:    Depending on the operating system and its executable file format,
        !            68: either `crtstuff.c' or `libgcc2.c' traverses these lists at startup
        !            69: time and exit time.  Constructors are called in forward order of the
        !            70: list; destructors in reverse order.
        !            71: 
        !            72:    The best way to handle static constructors works only for object file
        !            73: formats which provide arbitrarily-named sections.  A section is set
        !            74: aside for a list of constructors, and another for a list of destructors.
        !            75: Traditionally these are called `.ctors' and `.dtors'.  Each object file
        !            76: that defines an initialization function also puts a word in the
        !            77: constructor section to point to that function.  The linker accumulates
        !            78: all these words into one contiguous `.ctors' section.  Termination
        !            79: functions are handled similarly.
        !            80: 
        !            81:    To use this method, you need appropriate definitions of the macros
        !            82: `ASM_OUTPUT_CONSTRUCTOR' and `ASM_OUTPUT_DESTRUCTOR'.  Usually you can
        !            83: get them by including `svr4.h'.
        !            84: 
        !            85:    When arbitrary sections are available, there are two variants,
        !            86: depending upon how the code in `crtstuff.c' is called.  On systems that
        !            87: support an "init" section which is executed at program startup, parts
        !            88: of `crtstuff.c' are compiled into that section.  The program is linked
        !            89: by the `gcc' driver like this:
        !            90: 
        !            91:      ld -o OUTPUT_FILE crtbegin.o ... crtend.o -lgcc
        !            92: 
        !            93:    The head of a function (`__do_global_ctors') appears in the init
        !            94: section of `crtbegin.o'; the remainder of the function appears in the
        !            95: init section of `crtend.o'.  The linker will pull these two parts of
        !            96: the section together, making a whole function.  If any of the user's
        !            97: object files linked into the middle of it contribute code, then that
        !            98: code will be executed as part of the body of `__do_global_ctors'.
        !            99: 
        !           100:    To use this variant, you must define the `INIT_SECTION_ASM_OP' macro
        !           101: properly.
        !           102: 
        !           103:    If no init section is available, do not define
        !           104: `INIT_SECTION_ASM_OP'.  Then `__do_global_ctors' is built into the text
        !           105: section like all other functions, and resides in `libgcc.a'.  When GCC
        !           106: compiles any function called `main', it inserts a procedure call to
        !           107: `__main' as the first executable code after the function prologue.  The
        !           108: `__main' function, also defined in `libgcc2.c', simply calls
        !           109: `__do_global_ctors'.
        !           110: 
        !           111:    In file formats that don't support arbitrary sections, there are
        !           112: again two variants.  In the simplest variant, the GNU linker (GNU `ld')
        !           113: and an `a.out' format must be used.  In this case,
        !           114: `ASM_OUTPUT_CONSTRUCTOR' is defined to produce a `.stabs' entry of type
        !           115: `N_SETT', referencing the name `__CTOR_LIST__', and with the address of
        !           116: the void function containing the initialization code as its value.  The
        !           117: GNU linker recognizes this as a request to add the value to a "set";
        !           118: the values are accumulated, and are eventually placed in the executable
        !           119: as a vector in the format described above, with a leading (ignored)
        !           120: count and a trailing zero element.  `ASM_OUTPUT_DESTRUCTOR' is handled
        !           121: similarly.  Since no init section is available, the absence of
        !           122: `INIT_SECTION_ASM_OP' causes the compilation of `main' to call `__main'
        !           123: as above, starting the initialization process.
        !           124: 
        !           125:    The last variant uses neither arbitrary sections nor the GNU linker.
        !           126: This is preferable when you want to do dynamic linking and when using
        !           127: file formats which the GNU linker does not support, such as `ECOFF'.  In
        !           128: this case, `ASM_OUTPUT_CONSTRUCTOR' does not produce an `N_SETT'
        !           129: symbol; initialization and termination functions are recognized simply
        !           130: by their names.  This requires an extra program in the linkage step,
        !           131: called `collect2'.  This program pretends to be the linker, for use
        !           132: with GNU CC; it does its job by running the ordinary linker, but also
        !           133: arranges to include the vectors of initialization and termination
        !           134: functions.  These functions are called via `__main' as described above.
        !           135: 
        !           136:    Choosing among these configuration options has been simplified by a
        !           137: set of operating-system-dependent files in the `config' subdirectory.
        !           138: These files define all of the relevant parameters.  Usually it is
        !           139: sufficient to include one into your specific machine-dependent
        !           140: configuration file.  These files are:
        !           141: 
        !           142: `aoutos.h'
        !           143:      For operating systems using the `a.out' format.
        !           144: 
        !           145: `next.h'
        !           146:      For operating systems using the `MachO' format.
        !           147: 
        !           148: `svr3.h'
        !           149:      For System V Release 3 and similar systems using `COFF' format.
        !           150: 
        !           151: `svr4.h'
        !           152:      For System V Release 4 and similar systems using `ELF' format.
        !           153: 
        !           154: `vms.h'
        !           155:      For the VMS operating system.
        !           156: 
        !           157:    The following section describes the specific macros that control and
        !           158: customize the handling of initialization and termination functions.
        !           159: 
        !           160: 
        !           161: File: gcc.info,  Node: Macros for Initialization,  Next: Instruction Output,  Prev: Initialization,  Up: Assembler Format
        !           162: 
        !           163: Macros Controlling Initialization Routines
        !           164: ------------------------------------------
        !           165: 
        !           166:    Here are the macros that control how the compiler handles
        !           167: initialization and termination functions:
        !           168: 
        !           169: `INIT_SECTION_ASM_OP'
        !           170:      If defined, a C string constant for the assembler operation to
        !           171:      identify the following data as initialization code.  If not
        !           172:      defined, GNU CC will assume such a section does not exist.  When
        !           173:      you are using special sections for initialization and termination
        !           174:      functions, this macro also controls how `crtstuff.c' and
        !           175:      `libgcc2.c' arrange to run the initialization functions.
        !           176: 
        !           177: `HAS_INIT_SECTION'
        !           178:      If defined, `main' will not call `__main' as described above.
        !           179:      This macro should be defined for systems that control the contents
        !           180:      of the init section on a symbol-by-symbol basis, such as OSF/1,
        !           181:      and should not be defined explicitly for systems that support
        !           182:      `INIT_SECTION_ASM_OP'.
        !           183: 
        !           184: `INVOKE__main'
        !           185:      If defined, `main' will call `__main' despite the presence of
        !           186:      `INIT_SECTION_ASM_OP'.  This macro should be defined for systems
        !           187:      where the init section is not actually run automatically, but is
        !           188:      still useful for collecting the lists of constructors and
        !           189:      destructors.
        !           190: 
        !           191: `ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)'
        !           192:      Define this macro as a C statement to output on the stream STREAM
        !           193:      the assembler code to arrange to call the function named NAME at
        !           194:      initialization time.
        !           195: 
        !           196:      Assume that NAME is the name of a C function generated
        !           197:      automatically by the compiler.  This function takes no arguments.
        !           198:      Use the function `assemble_name' to output the name NAME; this
        !           199:      performs any system-specific syntactic transformations such as
        !           200:      adding an underscore.
        !           201: 
        !           202:      If you don't define this macro, nothing special is output to
        !           203:      arrange to call the function.  This is correct when the function
        !           204:      will be called in some other manner--for example, by means of the
        !           205:      `collect2' program, which looks through the symbol table to find
        !           206:      these functions by their names.
        !           207: 
        !           208: `ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)'
        !           209:      This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination
        !           210:      functions rather than initialization functions.
        !           211: 
        !           212:    If your system uses `collect2' as the means of processing
        !           213: constructors, then that program normally uses `nm' to scan an object
        !           214: file for constructor functions to be called.  On certain kinds of
        !           215: systems, you can define these macros to make `collect2' work faster
        !           216: (and, in some cases, make it work at all):
        !           217: 
        !           218: `OBJECT_FORMAT_COFF'
        !           219:      Define this macro if the system uses COFF (Common Object File
        !           220:      Format) object files, so that `collect2' can assume this format
        !           221:      and scan object files directly for dynamic constructor/destructor
        !           222:      functions.
        !           223: 
        !           224: `OBJECT_FORMAT_ROSE'
        !           225:      Define this macro if the system uses ROSE format object files, so
        !           226:      that `collect2' can assume this format and scan object files
        !           227:      directly for dynamic constructor/destructor functions.
        !           228: 
        !           229: `REAL_NM_FILE_NAME'
        !           230:      Define this macro as a C string constant containing the file name
        !           231:      to use to execute `nm'.  The default is to search the path
        !           232:      normally for `nm'.
        !           233: 
        !           234:    These macros are effective only in a native compiler; `collect2' as
        !           235: part of a cross compiler always uses `nm' for the target machine.
        !           236: 
        !           237: 
        !           238: File: gcc.info,  Node: Instruction Output,  Next: Dispatch Tables,  Prev: Macros for Initialization,  Up: Assembler Format
        !           239: 
        !           240: Output of Assembler Instructions
        !           241: --------------------------------
        !           242: 
        !           243:    This describes assembler instruction output.
        !           244: 
        !           245: `REGISTER_NAMES'
        !           246:      A C initializer containing the assembler's names for the machine
        !           247:      registers, each one as a C string constant.  This is what
        !           248:      translates register numbers in the compiler into assembler
        !           249:      language.
        !           250: 
        !           251: `ADDITIONAL_REGISTER_NAMES'
        !           252:      If defined, a C initializer for an array of structures containing
        !           253:      a name and a register number.  This macro defines additional names
        !           254:      for hard registers, thus allowing the `asm' option in declarations
        !           255:      to refer to registers using alternate names.
        !           256: 
        !           257: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
        !           258:      Define this macro if you are using an unusual assembler that
        !           259:      requires different names for the machine instructions.
        !           260: 
        !           261:      The definition is a C statement or statements which output an
        !           262:      assembler instruction opcode to the stdio stream STREAM.  The
        !           263:      macro-operand PTR is a variable of type `char *' which points to
        !           264:      the opcode name in its "internal" form--the form that is written
        !           265:      in the machine description.  The definition should output the
        !           266:      opcode name to STREAM, performing any translation you desire, and
        !           267:      increment the variable PTR to point at the end of the opcode so
        !           268:      that it will not be output twice.
        !           269: 
        !           270:      In fact, your macro definition may process less than the entire
        !           271:      opcode name, or more than the opcode name; but if you want to
        !           272:      process text that includes `%'-sequences to substitute operands,
        !           273:      you must take care of the substitution yourself.  Just be sure to
        !           274:      increment PTR over whatever text should not be output normally.
        !           275: 
        !           276:      If you need to look at the operand values, they can be found as the
        !           277:      elements of `recog_operand'.
        !           278: 
        !           279:      If the macro definition does nothing, the instruction is output in
        !           280:      the usual way.
        !           281: 
        !           282: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
        !           283:      If defined, a C statement to be executed just prior to the output
        !           284:      of assembler code for INSN, to modify the extracted operands so
        !           285:      they will be output differently.
        !           286: 
        !           287:      Here the argument OPVEC is the vector containing the operands
        !           288:      extracted from INSN, and NOPERANDS is the number of elements of
        !           289:      the vector which contain meaningful data for this insn.  The
        !           290:      contents of this vector are what will be used to convert the insn
        !           291:      template into assembler code, so you can change the assembler
        !           292:      output by changing the contents of the vector.
        !           293: 
        !           294:      This macro is useful when various assembler syntaxes share a single
        !           295:      file of instruction patterns; by defining this macro differently,
        !           296:      you can cause a large class of instructions to be output
        !           297:      differently (such as with rearranged operands).  Naturally,
        !           298:      variations in assembler syntax affecting individual insn patterns
        !           299:      ought to be handled by writing conditional output routines in
        !           300:      those patterns.
        !           301: 
        !           302:      If this macro is not defined, it is equivalent to a null statement.
        !           303: 
        !           304: `PRINT_OPERAND (STREAM, X, CODE)'
        !           305:      A C compound statement to output to stdio stream STREAM the
        !           306:      assembler syntax for an instruction operand X.  X is an RTL
        !           307:      expression.
        !           308: 
        !           309:      CODE is a value that can be used to specify one of several ways of
        !           310:      printing the operand.  It is used when identical operands must be
        !           311:      printed differently depending on the context.  CODE comes from the
        !           312:      `%' specification that was used to request printing of the
        !           313:      operand.  If the specification was just `%DIGIT' then CODE is 0;
        !           314:      if the specification was `%LTR DIGIT' then CODE is the ASCII code
        !           315:      for LTR.
        !           316: 
        !           317:      If X is a register, this macro should print the register's name.
        !           318:      The names can be found in an array `reg_names' whose type is `char
        !           319:      *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.
        !           320: 
        !           321:      When the machine description has a specification `%PUNCT' (a `%'
        !           322:      followed by a punctuation character), this macro is called with a
        !           323:      null pointer for X and the punctuation character for CODE.
        !           324: 
        !           325: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
        !           326:      A C expression which evaluates to true if CODE is a valid
        !           327:      punctuation character for use in the `PRINT_OPERAND' macro.  If
        !           328:      `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
        !           329:      punctuation characters (except for the standard one, `%') are used
        !           330:      in this way.
        !           331: 
        !           332: `PRINT_OPERAND_ADDRESS (STREAM, X)'
        !           333:      A C compound statement to output to stdio stream STREAM the
        !           334:      assembler syntax for an instruction operand that is a memory
        !           335:      reference whose address is X.  X is an RTL expression.
        !           336: 
        !           337:      On some machines, the syntax for a symbolic address depends on the
        !           338:      section that the address refers to.  On these machines, define the
        !           339:      macro `ENCODE_SECTION_INFO' to store the information into the
        !           340:      `symbol_ref', and then check for it here.  *Note Assembler
        !           341:      Format::.
        !           342: 
        !           343: `DBR_OUTPUT_SEQEND(FILE)'
        !           344:      A C statement, to be executed after all slot-filler instructions
        !           345:      have been output.  If necessary, call `dbr_sequence_length' to
        !           346:      determine the number of slots filled in a sequence (zero if not
        !           347:      currently outputting a sequence), to decide how many no-ops to
        !           348:      output, or whatever.
        !           349: 
        !           350:      Don't define this macro if it has nothing to do, but it is helpful
        !           351:      in reading assembly output if the extent of the delay sequence is
        !           352:      made explicit (e.g. with white space).
        !           353: 
        !           354:      Note that output routines for instructions with delay slots must be
        !           355:      prepared to deal with not being output as part of a sequence (i.e.
        !           356:      when the scheduling pass is not run, or when no slot fillers could
        !           357:      be found.)  The variable `final_sequence' is null when not
        !           358:      processing a sequence, otherwise it contains the `sequence' rtx
        !           359:      being output.
        !           360: 
        !           361: `REGISTER_PREFIX'
        !           362: `LOCAL_LABEL_PREFIX'
        !           363: `USER_LABEL_PREFIX'
        !           364: `IMMEDIATE_PREFIX'
        !           365:      If defined, C string expressions to be used for the `%R', `%L',
        !           366:      `%U', and `%I' options of `asm_fprintf' (see `final.c').  These
        !           367:      are useful when a single `md' file must support multiple assembler
        !           368:      formats.  In that case, the various `tm.h' files can define these
        !           369:      macros differently.
        !           370: 
        !           371: `ASSEMBLER_DIALECT'
        !           372:      If your target supports multiple dialects of assembler language
        !           373:      (such as different opcodes), define this macro as a C expression
        !           374:      that gives the numeric index of the assembler langauge dialect to
        !           375:      use, with zero as the first variant.
        !           376: 
        !           377:      If this macro is defined, you may use
        !           378:      `{option0|option1|option2...}' constructs in the output templates
        !           379:      of patterns (*note Output Template::.) or in the first argument of
        !           380:      `asm_fprintf'.  This construct outputs `option0', `option1' or
        !           381:      `option2', etc., if the value of `ASSEMBLER_DIALECT' is zero, one
        !           382:      or two, etc.  Any special characters within these strings retain
        !           383:      their usual meaning.
        !           384: 
        !           385:      If you do not define this macro, the characters `{', `|' and `}'
        !           386:      do not have any special meaning when used in templates or operands
        !           387:      to `asm_fprintf'.
        !           388: 
        !           389:      Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX',
        !           390:      `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the
        !           391:      variations in assemble language syntax with that mechanism.  Define
        !           392:      `ASSEMBLER_DIALECT' and use the `{option0|option1}' syntax if the
        !           393:      syntax variant are larger and involve such things as different
        !           394:      opcodes or operand order.
        !           395: 
        !           396: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
        !           397:      A C expression to output to STREAM some assembler code which will
        !           398:      push hard register number REGNO onto the stack.  The code need not
        !           399:      be optimal, since this macro is used only when profiling.
        !           400: 
        !           401: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
        !           402:      A C expression to output to STREAM some assembler code which will
        !           403:      pop hard register number REGNO off of the stack.  The code need
        !           404:      not be optimal, since this macro is used only when profiling.
        !           405: 
        !           406: 
        !           407: File: gcc.info,  Node: Dispatch Tables,  Next: Alignment Output,  Prev: Instruction Output,  Up: Assembler Format
        !           408: 
        !           409: Output of Dispatch Tables
        !           410: -------------------------
        !           411: 
        !           412:    This concerns dispatch tables.
        !           413: 
        !           414: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
        !           415:      This macro should be provided on machines where the addresses in a
        !           416:      dispatch table are relative to the table's own address.
        !           417: 
        !           418:      The definition should be a C statement to output to the stdio
        !           419:      stream STREAM an assembler pseudo-instruction to generate a
        !           420:      difference between two labels.  VALUE and REL are the numbers of
        !           421:      two internal labels.  The definitions of these labels are output
        !           422:      using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
        !           423:      same way here.  For example,
        !           424: 
        !           425:           fprintf (STREAM, "\t.word L%d-L%d\n",
        !           426:                    VALUE, REL)
        !           427: 
        !           428: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
        !           429:      This macro should be provided on machines where the addresses in a
        !           430:      dispatch table are absolute.
        !           431: 
        !           432:      The definition should be a C statement to output to the stdio
        !           433:      stream STREAM an assembler pseudo-instruction to generate a
        !           434:      reference to a label.  VALUE is the number of an internal label
        !           435:      whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'.  For
        !           436:      example,
        !           437: 
        !           438:           fprintf (STREAM, "\t.word L%d\n", VALUE)
        !           439: 
        !           440: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
        !           441:      Define this if the label before a jump-table needs to be output
        !           442:      specially.  The first three arguments are the same as for
        !           443:      `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
        !           444:      which follows (a `jump_insn' containing an `addr_vec' or
        !           445:      `addr_diff_vec').
        !           446: 
        !           447:      This feature is used on system V to output a `swbeg' statement for
        !           448:      the table.
        !           449: 
        !           450:      If this macro is not defined, these labels are output with
        !           451:      `ASM_OUTPUT_INTERNAL_LABEL'.
        !           452: 
        !           453: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
        !           454:      Define this if something special must be output at the end of a
        !           455:      jump-table.  The definition should be a C statement to be executed
        !           456:      after the assembler code for the table is written.  It should write
        !           457:      the appropriate code to stdio stream STREAM.  The argument TABLE
        !           458:      is the jump-table insn, and NUM is the label-number of the
        !           459:      preceding label.
        !           460: 
        !           461:      If this macro is not defined, nothing special is output at the end
        !           462:      of the jump-table.
        !           463: 
        !           464: 
        !           465: File: gcc.info,  Node: Alignment Output,  Prev: Dispatch Tables,  Up: Assembler Format
        !           466: 
        !           467: Assembler Commands for Alignment
        !           468: --------------------------------
        !           469: 
        !           470:    This describes commands for alignment.
        !           471: 
        !           472: `ASM_OUTPUT_ALIGN_CODE (FILE)'
        !           473:      A C expression to output text to align the location counter in the
        !           474:      way that is desirable at a point in the code that is reached only
        !           475:      by jumping.
        !           476: 
        !           477:      This macro need not be defined if you don't want any special
        !           478:      alignment to be done at such a time.  Most machine descriptions do
        !           479:      not currently define the macro.
        !           480: 
        !           481: `ASM_OUTPUT_LOOP_ALIGN (FILE)'
        !           482:      A C expression to output text to align the location counter in the
        !           483:      way that is desirable at the beginning of a loop.
        !           484: 
        !           485:      This macro need not be defined if you don't want any special
        !           486:      alignment to be done at such a time.  Most machine descriptions do
        !           487:      not currently define the macro.
        !           488: 
        !           489: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
        !           490:      A C statement to output to the stdio stream STREAM an assembler
        !           491:      instruction to advance the location counter by NBYTES bytes.
        !           492:      Those bytes should be zero when loaded.  NBYTES will be a C
        !           493:      expression of type `int'.
        !           494: 
        !           495: `ASM_NO_SKIP_IN_TEXT'
        !           496:      Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
        !           497:      text section because it fails put zeros in the bytes that are
        !           498:      skipped.  This is true on many Unix systems, where the pseudo-op
        !           499:      to skip bytes produces no-op instructions rather than zeros when
        !           500:      used in the text section.
        !           501: 
        !           502: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
        !           503:      A C statement to output to the stdio stream STREAM an assembler
        !           504:      command to advance the location counter to a multiple of 2 to the
        !           505:      POWER bytes.  POWER will be a C expression of type `int'.
        !           506: 
        !           507: 
        !           508: File: gcc.info,  Node: Debugging Info,  Next: Cross-compilation,  Prev: Assembler Format,  Up: Target Macros
        !           509: 
        !           510: Controlling Debugging Information Format
        !           511: ========================================
        !           512: 
        !           513:    This describes how to specify debugging information.
        !           514: 
        !           515: * Menu:
        !           516: 
        !           517: * All Debuggers::      Macros that affect all debugging formats uniformly.
        !           518: * DBX Options::        Macros enabling specific options in DBX format.
        !           519: * DBX Hooks::          Hook macros for varying DBX format.
        !           520: * File Names and DBX:: Macros controlling output of file names in DBX format.
        !           521: * SDB and DWARF::      Macros for SDB (COFF) and DWARF formats.
        !           522: 
        !           523: 
        !           524: File: gcc.info,  Node: All Debuggers,  Next: DBX Options,  Up: Debugging Info
        !           525: 
        !           526: Macros Affecting All Debugging Formats
        !           527: --------------------------------------
        !           528: 
        !           529:    These macros affect all debugging formats.
        !           530: 
        !           531: `DBX_REGISTER_NUMBER (REGNO)'
        !           532:      A C expression that returns the DBX register number for the
        !           533:      compiler register number REGNO.  In simple cases, the value of this
        !           534:      expression may be REGNO itself.  But sometimes there are some
        !           535:      registers that the compiler knows about and DBX does not, or vice
        !           536:      versa.  In such cases, some register may need to have one number in
        !           537:      the compiler and another for DBX.
        !           538: 
        !           539:      If two registers have consecutive numbers inside GNU CC, and they
        !           540:      can be used as a pair to hold a multiword value, then they *must*
        !           541:      have consecutive numbers after renumbering with
        !           542:      `DBX_REGISTER_NUMBER'.  Otherwise, debuggers will be unable to
        !           543:      access such a pair, because they expect register pairs to be
        !           544:      consecutive in their own numbering scheme.
        !           545: 
        !           546:      If you find yourself defining `DBX_REGISTER_NUMBER' in way that
        !           547:      does not preserve register pairs, then what you must do instead is
        !           548:      redefine the actual register numbering scheme.
        !           549: 
        !           550: `DEBUGGER_AUTO_OFFSET (X)'
        !           551:      A C expression that returns the integer offset value for an
        !           552:      automatic variable having address X (an RTL expression).  The
        !           553:      default computation assumes that X is based on the frame-pointer
        !           554:      and gives the offset from the frame-pointer.  This is required for
        !           555:      targets that produce debugging output for DBX or COFF-style
        !           556:      debugging output for SDB and allow the frame-pointer to be
        !           557:      eliminated when the `-g' options is used.
        !           558: 
        !           559: `DEBUGGER_ARG_OFFSET (OFFSET, X)'
        !           560:      A C expression that returns the integer offset value for an
        !           561:      argument having address X (an RTL expression).  The nominal offset
        !           562:      is OFFSET.
        !           563: 
        !           564: `PREFERRED_DEBUGGING_TYPE'
        !           565:      A C expression that returns the type of debugging output GNU CC
        !           566:      produces when the user specifies `-g' or `-ggdb'.  Define this if
        !           567:      you have arranged for GNU CC to support more than one format of
        !           568:      debugging output.  Currently, the allowable values are `DBX_DEBUG',
        !           569:      `SDB_DEBUG', `DWARF_DEBUG', and `XCOFF_DEBUG'.
        !           570: 
        !           571:      The value of this macro only affects the default debugging output;
        !           572:      the user can always get a specific type of output by using
        !           573:      `-gstabs', `-gcoff', `-gdwarf', or `-gxcoff'.
        !           574: 
        !           575: 
        !           576: File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
        !           577: 
        !           578: Specific Options for DBX Output
        !           579: -------------------------------
        !           580: 
        !           581:    These are specific options for DBX output.
        !           582: 
        !           583: `DBX_DEBUGGING_INFO'
        !           584:      Define this macro if GNU CC should produce debugging output for DBX
        !           585:      in response to the `-g' option.
        !           586: 
        !           587: `XCOFF_DEBUGGING_INFO'
        !           588:      Define this macro if GNU CC should produce XCOFF format debugging
        !           589:      output in response to the `-g' option.  This is a variant of DBX
        !           590:      format.
        !           591: 
        !           592: `DEFAULT_GDB_EXTENSIONS'
        !           593:      Define this macro to control whether GNU CC should by default
        !           594:      generate GDB's extended version of DBX debugging information
        !           595:      (assuming DBX-format debugging information is enabled at all).  If
        !           596:      you don't define the macro, the default is 1: always generate the
        !           597:      extended information if there is any occasion to.
        !           598: 
        !           599: `DEBUG_SYMS_TEXT'
        !           600:      Define this macro if all `.stabs' commands should be output while
        !           601:      in the text section.
        !           602: 
        !           603: `ASM_STABS_OP'
        !           604:      A C string constant naming the assembler pseudo op to use instead
        !           605:      of `.stabs' to define an ordinary debugging symbol.  If you don't
        !           606:      define this macro, `.stabs' is used.  This macro applies only to
        !           607:      DBX debugging information format.
        !           608: 
        !           609: `ASM_STABD_OP'
        !           610:      A C string constant naming the assembler pseudo op to use instead
        !           611:      of `.stabd' to define a debugging symbol whose value is the current
        !           612:      location.  If you don't define this macro, `.stabd' is used.  This
        !           613:      macro applies only to DBX debugging information format.
        !           614: 
        !           615: `ASM_STABN_OP'
        !           616:      A C string constant naming the assembler pseudo op to use instead
        !           617:      of `.stabn' to define a debugging symbol with no name.  If you
        !           618:      don't define this macro, `.stabn' is used.  This macro applies
        !           619:      only to DBX debugging information format.
        !           620: 
        !           621: `DBX_NO_XREFS'
        !           622:      Define this macro if DBX on your system does not support the
        !           623:      construct `xsTAGNAME'.  On some systems, this construct is used to
        !           624:      describe a forward reference to a structure named TAGNAME.  On
        !           625:      other systems, this construct is not supported at all.
        !           626: 
        !           627: `DBX_CONTIN_LENGTH'
        !           628:      A symbol name in DBX-format debugging information is normally
        !           629:      continued (split into two separate `.stabs' directives) when it
        !           630:      exceeds a certain length (by default, 80 characters).  On some
        !           631:      operating systems, DBX requires this splitting; on others,
        !           632:      splitting must not be done.  You can inhibit splitting by defining
        !           633:      this macro with the value zero.  You can override the default
        !           634:      splitting-length by defining this macro as an expression for the
        !           635:      length you desire.
        !           636: 
        !           637: `DBX_CONTIN_CHAR'
        !           638:      Normally continuation is indicated by adding a `\' character to
        !           639:      the end of a `.stabs' string when a continuation follows.  To use
        !           640:      a different character instead, define this macro as a character
        !           641:      constant for the character you want to use.  Do not define this
        !           642:      macro if backslash is correct for your system.
        !           643: 
        !           644: `DBX_STATIC_STAB_DATA_SECTION'
        !           645:      Define this macro if it is necessary to go to the data section
        !           646:      before outputting the `.stabs' pseudo-op for a non-global static
        !           647:      variable.
        !           648: 
        !           649: `DBX_TYPE_DECL_STABS_CODE'
        !           650:      The value to use in the "code" field of the `.stabs' directive for
        !           651:      a typedef.  The default is `N_LSYM'.
        !           652: 
        !           653: `DBX_STATIC_CONST_VAR_CODE'
        !           654:      The value to use in the "code" field of the `.stabs' directive for
        !           655:      a static variable located in the text section.  DBX format does not
        !           656:      provide any "right" way to do this.  The default is `N_FUN'.
        !           657: 
        !           658: `DBX_REGPARM_STABS_CODE'
        !           659:      The value to use in the "code" field of the `.stabs' directive for
        !           660:      a parameter passed in registers.  DBX format does not provide any
        !           661:      "right" way to do this.  The default is `N_RSYM'.
        !           662: 
        !           663: `DBX_REGPARM_STABS_LETTER'
        !           664:      The letter to use in DBX symbol data to identify a symbol as a
        !           665:      parameter passed in registers.  DBX format does not customarily
        !           666:      provide any way to do this.  The default is `'P''.
        !           667: 
        !           668: `DBX_MEMPARM_STABS_LETTER'
        !           669:      The letter to use in DBX symbol data to identify a symbol as a
        !           670:      stack parameter.  The default is `'p''.
        !           671: 
        !           672: `DBX_FUNCTION_FIRST'
        !           673:      Define this macro if the DBX information for a function and its
        !           674:      arguments should precede the assembler code for the function.
        !           675:      Normally, in DBX format, the debugging information entirely
        !           676:      follows the assembler code.
        !           677: 
        !           678: `DBX_LBRAC_FIRST'
        !           679:      Define this macro if the `N_LBRAC' symbol for a block should
        !           680:      precede the debugging information for variables and functions
        !           681:      defined in that block.  Normally, in DBX format, the `N_LBRAC'
        !           682:      symbol comes first.
        !           683: 
        !           684: `DBX_BLOCKS_FUNCTION_RELATIVE'
        !           685:      Define this macro if the value of a symbol describing the scope of
        !           686:      a block (`N_LBRAC' or `N_RBRAC') should be relative to the start
        !           687:      of the enclosing function.  Normally, GNU C uses an absolute
        !           688:      address.
        !           689: 
        !           690: 
        !           691: File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
        !           692: 
        !           693: Open-Ended Hooks for DBX Format
        !           694: -------------------------------
        !           695: 
        !           696:    These are hooks for DBX format.
        !           697: 
        !           698: `DBX_OUTPUT_LBRAC (STREAM, NAME)'
        !           699:      Define this macro to say how to output to STREAM the debugging
        !           700:      information for the start of a scope level for variable names.  The
        !           701:      argument NAME is the name of an assembler symbol (for use with
        !           702:      `assemble_name') whose value is the address where the scope begins.
        !           703: 
        !           704: `DBX_OUTPUT_RBRAC (STREAM, NAME)'
        !           705:      Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
        !           706: 
        !           707: `DBX_OUTPUT_ENUM (STREAM, TYPE)'
        !           708:      Define this macro if the target machine requires special handling
        !           709:      to output an enumeration type.  The definition should be a C
        !           710:      statement (sans semicolon) to output the appropriate information
        !           711:      to STREAM for the type TYPE.
        !           712: 
        !           713: `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
        !           714:      Define this macro if the target machine requires special output at
        !           715:      the end of the debugging information for a function.  The
        !           716:      definition should be a C statement (sans semicolon) to output the
        !           717:      appropriate information to STREAM.  FUNCTION is the
        !           718:      `FUNCTION_DECL' node for the function.
        !           719: 
        !           720: `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
        !           721:      Define this macro if you need to control the order of output of the
        !           722:      standard data types at the beginning of compilation.  The argument
        !           723:      SYMS is a `tree' which is a chain of all the predefined global
        !           724:      symbols, including names of data types.
        !           725: 
        !           726:      Normally, DBX output starts with definitions of the types for
        !           727:      integers and characters, followed by all the other predefined
        !           728:      types of the particular language in no particular order.
        !           729: 
        !           730:      On some machines, it is necessary to output different particular
        !           731:      types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
        !           732:      output those symbols in the necessary order.  Any predefined types
        !           733:      that you don't explicitly output will be output afterward in no
        !           734:      particular order.
        !           735: 
        !           736:      Be careful not to define this macro so that it works only for C.
        !           737:      There are no global variables to access most of the built-in
        !           738:      types, because another language may have another set of types.
        !           739:      The way to output a particular type is to look through SYMS to see
        !           740:      if you can find it.  Here is an example:
        !           741: 
        !           742:           {
        !           743:             tree decl;
        !           744:             for (decl = syms; decl; decl = TREE_CHAIN (decl))
        !           745:               if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
        !           746:                            "long int"))
        !           747:                 dbxout_symbol (decl);
        !           748:             ...
        !           749:           }
        !           750: 
        !           751:      This does nothing if the expected type does not exist.
        !           752: 
        !           753:      See the function `init_decl_processing' in `c-decl.c' to find the
        !           754:      names to use for all the built-in C types.
        !           755: 
        !           756:      Here is another way of finding a particular type:
        !           757: 
        !           758:           {
        !           759:             tree decl;
        !           760:             for (decl = syms; decl; decl = TREE_CHAIN (decl))
        !           761:               if (TREE_CODE (decl) == TYPE_DECL
        !           762:                   && (TREE_CODE (TREE_TYPE (decl))
        !           763:                       == INTEGER_CST)
        !           764:                   && TYPE_PRECISION (TREE_TYPE (decl)) == 16
        !           765:                   && TYPE_UNSIGNED (TREE_TYPE (decl)))
        !           766:           /* This must be `unsigned short'.  */
        !           767:                 dbxout_symbol (decl);
        !           768:             ...
        !           769:           }
        !           770: 
        !           771: 
        !           772: File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
        !           773: 
        !           774: File Names in DBX Format
        !           775: ------------------------
        !           776: 
        !           777:    This describes file names in DBX format.
        !           778: 
        !           779: `DBX_WORKING_DIRECTORY'
        !           780:      Define this if DBX wants to have the current directory recorded in
        !           781:      each object file.
        !           782: 
        !           783:      Note that the working directory is always recorded if GDB
        !           784:      extensions are enabled.
        !           785: 
        !           786: `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
        !           787:      A C statement to output DBX debugging information to the stdio
        !           788:      stream STREAM which indicates that file NAME is the main source
        !           789:      file--the file specified as the input file for compilation.  This
        !           790:      macro is called only once, at the beginning of compilation.
        !           791: 
        !           792:      This macro need not be defined if the standard form of output for
        !           793:      DBX debugging information is appropriate.
        !           794: 
        !           795: `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
        !           796:      A C statement to output DBX debugging information to the stdio
        !           797:      stream STREAM which indicates that the current directory during
        !           798:      compilation is named NAME.
        !           799: 
        !           800:      This macro need not be defined if the standard form of output for
        !           801:      DBX debugging information is appropriate.
        !           802: 
        !           803: `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
        !           804:      A C statement to output DBX debugging information at the end of
        !           805:      compilation of the main source file NAME.
        !           806: 
        !           807:      If you don't define this macro, nothing special is output at the
        !           808:      end of compilation, which is correct for most machines.
        !           809: 
        !           810: `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
        !           811:      A C statement to output DBX debugging information to the stdio
        !           812:      stream STREAM which indicates that file NAME is the current source
        !           813:      file.  This output is generated each time input shifts to a
        !           814:      different source file as a result of `#include', the end of an
        !           815:      included file, or a `#line' command.
        !           816: 
        !           817:      This macro need not be defined if the standard form of output for
        !           818:      DBX debugging information is appropriate.
        !           819: 
        !           820: 
        !           821: File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
        !           822: 
        !           823: Macros for SDB and DWARF Output
        !           824: -------------------------------
        !           825: 
        !           826:    Here are macros for SDB and DWARF output.
        !           827: 
        !           828: `SDB_DEBUGGING_INFO'
        !           829:      Define this macro if GNU CC should produce COFF-style debugging
        !           830:      output for SDB in response to the `-g' option.
        !           831: 
        !           832: `DWARF_DEBUGGING_INFO'
        !           833:      Define this macro if GNU CC should produce dwarf format debugging
        !           834:      output in response to the `-g' option.
        !           835: 
        !           836: `PUT_SDB_...'
        !           837:      Define these macros to override the assembler syntax for the
        !           838:      special SDB assembler directives.  See `sdbout.c' for a list of
        !           839:      these macros and their arguments.  If the standard syntax is used,
        !           840:      you need not define them yourself.
        !           841: 
        !           842: `SDB_DELIM'
        !           843:      Some assemblers do not support a semicolon as a delimiter, even
        !           844:      between SDB assembler directives.  In that case, define this macro
        !           845:      to be the delimiter to use (usually `\n').  It is not necessary to
        !           846:      define a new set of `PUT_SDB_OP' macros if this is the only change
        !           847:      required.
        !           848: 
        !           849: `SDB_GENERATE_FAKE'
        !           850:      Define this macro to override the usual method of constructing a
        !           851:      dummy name for anonymous structure and union types.  See
        !           852:      `sdbout.c' for more information.
        !           853: 
        !           854: `SDB_ALLOW_UNKNOWN_REFERENCES'
        !           855:      Define this macro to allow references to unknown structure, union,
        !           856:      or enumeration tags to be emitted.  Standard COFF does not allow
        !           857:      handling of unknown references, MIPS ECOFF has support for it.
        !           858: 
        !           859: `SDB_ALLOW_FORWARD_REFERENCES'
        !           860:      Define this macro to allow references to structure, union, or
        !           861:      enumeration tags that have not yet been seen to be handled.  Some
        !           862:      assemblers choke if forward tags are used, while some require it.
        !           863: 
        !           864: 
        !           865: File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Debugging Info,  Up: Target Macros
        !           866: 
        !           867: Cross Compilation and Floating Point
        !           868: ====================================
        !           869: 
        !           870:    While all modern machines use 2's complement representation for
        !           871: integers, there are a variety of representations for floating point
        !           872: numbers.  This means that in a cross-compiler the representation of
        !           873: floating point numbers in the compiled program may be different from
        !           874: that used in the machine doing the compilation.
        !           875: 
        !           876:    Because different representation systems may offer different amounts
        !           877: of range and precision, the cross compiler cannot safely use the host
        !           878: machine's floating point arithmetic.  Therefore, floating point
        !           879: constants must be represented in the target machine's format.  This
        !           880: means that the cross compiler cannot use `atof' to parse a floating
        !           881: point constant; it must have its own special routine to use instead.
        !           882: Also, constant folding must emulate the target machine's arithmetic (or
        !           883: must not be done at all).
        !           884: 
        !           885:    The macros in the following table should be defined only if you are
        !           886: cross compiling between different floating point formats.
        !           887: 
        !           888:    Otherwise, don't define them.  Then default definitions will be set
        !           889: up which use `double' as the data type, `==' to test for equality, etc.
        !           890: 
        !           891:    You don't need to worry about how many times you use an operand of
        !           892: any of these macros.  The compiler never uses operands which have side
        !           893: effects.
        !           894: 
        !           895: `REAL_VALUE_TYPE'
        !           896:      A macro for the C data type to be used to hold a floating point
        !           897:      value in the target machine's format.  Typically this would be a
        !           898:      `struct' containing an array of `int'.
        !           899: 
        !           900: `REAL_VALUES_EQUAL (X, Y)'
        !           901:      A macro for a C expression which compares for equality the two
        !           902:      values, X and Y, both of type `REAL_VALUE_TYPE'.
        !           903: 
        !           904: `REAL_VALUES_LESS (X, Y)'
        !           905:      A macro for a C expression which tests whether X is less than Y,
        !           906:      both values being of type `REAL_VALUE_TYPE' and interpreted as
        !           907:      floating point numbers in the target machine's representation.
        !           908: 
        !           909: `REAL_VALUE_LDEXP (X, SCALE)'
        !           910:      A macro for a C expression which performs the standard library
        !           911:      function `ldexp', but using the target machine's floating point
        !           912:      representation.  Both X and the value of the expression have type
        !           913:      `REAL_VALUE_TYPE'.  The second argument, SCALE, is an integer.
        !           914: 
        !           915: `REAL_VALUE_FIX (X)'
        !           916:      A macro whose definition is a C expression to convert the
        !           917:      target-machine floating point value X to a signed integer.  X has
        !           918:      type `REAL_VALUE_TYPE'.
        !           919: 
        !           920: `REAL_VALUE_UNSIGNED_FIX (X)'
        !           921:      A macro whose definition is a C expression to convert the
        !           922:      target-machine floating point value X to an unsigned integer.  X
        !           923:      has type `REAL_VALUE_TYPE'.
        !           924: 
        !           925: `REAL_VALUE_RNDZINT (X)'
        !           926:      A macro whose definition is a C expression to round the
        !           927:      target-machine floating point value X towards zero to an integer
        !           928:      value (but still as a floating point number).  X has type
        !           929:      `REAL_VALUE_TYPE', and so does the value.
        !           930: 
        !           931: `REAL_VALUE_UNSIGNED_RNDZINT (X)'
        !           932:      A macro whose definition is a C expression to round the
        !           933:      target-machine floating point value X towards zero to an unsigned
        !           934:      integer value (but still represented as a floating point number).
        !           935:      x has type `REAL_VALUE_TYPE', and so does the value.
        !           936: 
        !           937: `REAL_VALUE_ATOF (STRING, MODE)'
        !           938:      A macro for a C expression which converts STRING, an expression of
        !           939:      type `char *', into a floating point number in the target machine's
        !           940:      representation for mode MODE.  The value has type
        !           941:      `REAL_VALUE_TYPE'.
        !           942: 
        !           943: `REAL_INFINITY'
        !           944:      Define this macro if infinity is a possible floating point value,
        !           945:      and therefore division by 0 is legitimate.
        !           946: 
        !           947: `REAL_VALUE_ISINF (X)'
        !           948:      A macro for a C expression which determines whether X, a floating
        !           949:      point value, is infinity.  The value has type `int'.  By default,
        !           950:      this is defined to call `isinf'.
        !           951: 
        !           952: `REAL_VALUE_ISNAN (X)'
        !           953:      A macro for a C expression which determines whether X, a floating
        !           954:      point value, is a "nan" (not-a-number).  The value has type `int'.
        !           955:      By default, this is defined to call `isnan'.
        !           956: 
        !           957:    Define the following additional macros if you want to make floating
        !           958: point constant folding work while cross compiling.  If you don't define
        !           959: them, cross compilation is still possible, but constant folding will
        !           960: not happen for floating point values.
        !           961: 
        !           962: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
        !           963:      A macro for a C statement which calculates an arithmetic operation
        !           964:      of the two floating point values X and Y, both of type
        !           965:      `REAL_VALUE_TYPE' in the target machine's representation, to
        !           966:      produce a result of the same type and representation which is
        !           967:      stored in OUTPUT (which will be a variable).
        !           968: 
        !           969:      The operation to be performed is specified by CODE, a tree code
        !           970:      which will always be one of the following: `PLUS_EXPR',
        !           971:      `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
        !           972: 
        !           973:      The expansion of this macro is responsible for checking for
        !           974:      overflow.  If overflow happens, the macro expansion should execute
        !           975:      the statement `return 0;', which indicates the inability to
        !           976:      perform the arithmetic operation requested.
        !           977: 
        !           978: `REAL_VALUE_NEGATE (X)'
        !           979:      A macro for a C expression which returns the negative of the
        !           980:      floating point value X.  Both X and the value of the expression
        !           981:      have type `REAL_VALUE_TYPE' and are in the target machine's
        !           982:      floating point representation.
        !           983: 
        !           984:      There is no way for this macro to report overflow, since overflow
        !           985:      can't happen in the negation operation.
        !           986: 
        !           987: `REAL_VALUE_TRUNCATE (MODE, X)'
        !           988:      A macro for a C expression which converts the floating point value
        !           989:      X to mode MODE.
        !           990: 
        !           991:      Both X and the value of the expression are in the target machine's
        !           992:      floating point representation and have type `REAL_VALUE_TYPE'.
        !           993:      However, the value should have an appropriate bit pattern to be
        !           994:      output properly as a floating constant whose precision accords
        !           995:      with mode MODE.
        !           996: 
        !           997:      There is no way for this macro to report overflow.
        !           998: 
        !           999: `REAL_VALUE_TO_INT (LOW, HIGH, X)'
        !          1000:      A macro for a C expression which converts a floating point value X
        !          1001:      into a double-precision integer which is then stored into LOW and
        !          1002:      HIGH, two variables of type INT.
        !          1003: 
        !          1004: `REAL_VALUE_FROM_INT (X, LOW, HIGH)'
        !          1005:      A macro for a C expression which converts a double-precision
        !          1006:      integer found in LOW and HIGH, two variables of type INT, into a
        !          1007:      floating point value which is then stored into X.
1.1       root     1008: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.