Return to gcc.info-18 CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/gcc.info-18, revision 1.1.1.2

1.1.1.2 ! root        1: This is Info file gcc.info, produced by Makeinfo-1.49 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:    Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc.
                      7: 
                      8:    Permission is granted to make and distribute verbatim copies of this
                      9: manual provided the copyright notice and this permission notice are
                     10: preserved on all copies.
                     11: 
                     12:    Permission is granted to copy and distribute modified versions of
                     13: this manual under the conditions for verbatim copying, provided also
1.1.1.2 ! root       14: that the sections entitled "GNU General Public License" and "Protect
        !            15: Your Freedom--Fight `Look And Feel'" are included exactly as in the
        !            16: original, and provided that the entire resulting derived work is
        !            17: distributed under the terms of a permission notice identical to this
        !            18: one.
1.1       root       19: 
                     20:    Permission is granted to copy and distribute translations of this
                     21: manual into another language, under the above conditions for modified
                     22: versions, except that the sections entitled "GNU General Public
1.1.1.2 ! root       23: License" and "Protect Your Freedom--Fight `Look And Feel'", and this
        !            24: permission notice, may be included in translations approved by the Free
        !            25: Software Foundation instead of in the original English.
1.1       root       26: 
                     27: 
1.1.1.2 ! root       28: File: gcc.info,  Node: Instruction Output,  Next: Dispatch Tables,  Prev: Macros for Initialization,  Up: Assembler Format
1.1       root       29: 
1.1.1.2 ! root       30: Output of Assembler Instructions
        !            31: --------------------------------
        !            32: 
        !            33: `REGISTER_NAMES'
        !            34:      A C initializer containing the assembler's names for the machine
        !            35:      registers, each one as a C string constant.  This is what
        !            36:      translates register numbers in the compiler into assembler
        !            37:      language.
        !            38: 
        !            39: `ADDITIONAL_REGISTER_NAMES'
        !            40:      If defined, a C initializer for an array of structures containing
        !            41:      a name and a register number.  This macro defines additional names
        !            42:      for hard registers, thus allowing the `asm' option in declarations
        !            43:      to refer to registers using alternate names.
        !            44: 
        !            45: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
        !            46:      Define this macro if you are using an unusual assembler that
        !            47:      requires different names for the machine instructions.
        !            48: 
        !            49:      The definition is a C statement or statements which output an
        !            50:      assembler instruction opcode to the stdio stream STREAM.  The
        !            51:      macro-operand PTR is a variable of type `char *' which points to
        !            52:      the opcode name in its "internal" form--the form that is written
        !            53:      in the machine description.  The definition should output the
        !            54:      opcode name to STREAM, performing any translation you desire, and
        !            55:      increment the variable PTR to point at the end of the opcode so
        !            56:      that it will not be output twice.
        !            57: 
        !            58:      In fact, your macro definition may process less than the entire
        !            59:      opcode name, or more than the opcode name; but if you want to
        !            60:      process text that includes `%'-sequences to substitute operands,
        !            61:      you must take care of the substitution yourself.  Just be sure to
        !            62:      increment PTR over whatever text should not be output normally.
        !            63: 
        !            64:      If you need to look at the operand values, they can be found as the
        !            65:      elements of `recog_operand'.
        !            66: 
        !            67:      If the macro definition does nothing, the instruction is output in
        !            68:      the usual way.
        !            69: 
        !            70: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
        !            71:      If defined, a C statement to be executed just prior to the output
        !            72:      of assembler code for INSN, to modify the extracted operands so
        !            73:      they will be output differently.
        !            74: 
        !            75:      Here the argument OPVEC is the vector containing the operands
        !            76:      extracted from INSN, and NOPERANDS is the number of elements of
        !            77:      the vector which contain meaningful data for this insn. The
        !            78:      contents of this vector are what will be used to convert the insn
        !            79:      template into assembler code, so you can change the assembler
        !            80:      output by changing the contents of the vector.
        !            81: 
        !            82:      This macro is useful when various assembler syntaxes share a single
        !            83:      file of instruction patterns; by defining this macro differently,
        !            84:      you can cause a large class of instructions to be output
        !            85:      differently (such as with rearranged operands).  Naturally,
        !            86:      variations in assembler syntax affecting individual insn patterns
        !            87:      ought to be handled by writing conditional output routines in
        !            88:      those patterns.
        !            89: 
        !            90:      If this macro is not defined, it is equivalent to a null statement.
        !            91: 
        !            92: `PRINT_OPERAND (STREAM, X, CODE)'
        !            93:      A C compound statement to output to stdio stream STREAM the
        !            94:      assembler syntax for an instruction operand X.  X is an RTL
        !            95:      expression.
        !            96: 
        !            97:      CODE is a value that can be used to specify one of several ways of
        !            98:      printing the operand.  It is used when identical operands must be
        !            99:      printed differently depending on the context.  CODE comes from the
        !           100:      `%' specification that was used to request printing of the
        !           101:      operand.  If the specification was just `%DIGIT' then CODE is 0;
        !           102:      if the specification was `%LTR DIGIT' then CODE is the ASCII code
        !           103:      for LTR.
        !           104: 
        !           105:      If X is a register, this macro should print the register's name.
        !           106:      The names can be found in an array `reg_names' whose type is `char
        !           107:      *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.
        !           108: 
        !           109:      When the machine description has a specification `%PUNCT' (a `%'
        !           110:      followed by a punctuation character), this macro is called with a
        !           111:      null pointer for X and the punctuation character for CODE.
        !           112: 
        !           113: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
        !           114:      A C expression which evaluates to true if CODE is a valid
        !           115:      punctuation character for use in the `PRINT_OPERAND' macro.  If
        !           116:      `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
        !           117:      punctuation characters (except for the standard one, `%') are used
        !           118:      in this way.
        !           119: 
        !           120: `PRINT_OPERAND_ADDRESS (STREAM, X)'
        !           121:      A C compound statement to output to stdio stream STREAM the
        !           122:      assembler syntax for an instruction operand that is a memory
        !           123:      reference whose address is X.  X is an RTL expression.
        !           124: 
        !           125:      On some machines, the syntax for a symbolic address depends on the
        !           126:      section that the address refers to.  On these machines, define the
        !           127:      macro `ENCODE_SECTION_INFO' to store the information into the
        !           128:      `symbol_ref', and then check for it here.  *Note Assembler
        !           129:      Format::.
        !           130: 
        !           131: `DBR_OUTPUT_SEQEND(FILE)'
        !           132:      A C statement, to be executed after all slot-filler instructions
        !           133:      have been output.  If necessary, call `dbr_sequence_length' to
        !           134:      determine the number of slots filled in a sequence (zero if not
        !           135:      currently outputting a sequence), to decide how many no-ops to
        !           136:      output, or whatever.
        !           137: 
        !           138:      Don't define this macro if it has nothing to do, but it is helpful
        !           139:      in reading assembly output if the extent of the delay sequence is
        !           140:      made explicit (e.g. with white space).
        !           141: 
        !           142:      Note that output routines for instructions with delay slots must be
        !           143:      prepared to deal with not being output as part of a sequence (i.e.
        !           144:      when the scheduling pass is not run, or when no slot fillers could
        !           145:      be found.)  The variable `final_sequence' is null when not
        !           146:      processing a sequence, otherwise it contains the `sequence' rtx
        !           147:      being output.
        !           148: 
        !           149: `REGISTER_PREFIX'
        !           150: `LOCAL_LABEL_PREFIX'
        !           151: `USER_LABEL_PREFIX'
        !           152: `IMMEDIATE_PREFIX'
        !           153:      If defined, C string expressions to be used for the `%R', `%L',
        !           154:      `%U', and `%I' options of `asm_fprintf' (see `final.c').  These
        !           155:      are useful when a single `md' file must support multiple assembler
        !           156:      formats.  In that case, the various `tm.h' files can define these
        !           157:      macros differently.
        !           158: 
        !           159: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
        !           160:      A C expression to output to STREAM some assembler code which will
        !           161:      push hard register number REGNO onto the stack. The code need not
        !           162:      be optimal, since this macro is used only when profiling.
        !           163: 
        !           164: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
        !           165:      A C expression to output to STREAM some assembler code which will
        !           166:      pop hard register number REGNO off of the stack. The code need not
        !           167:      be optimal, since this macro is used only when profiling.
        !           168: 
        !           169: 
        !           170: File: gcc.info,  Node: Dispatch Tables,  Next: Alignment Output,  Prev: Instruction Output,  Up: Assembler Format
        !           171: 
        !           172: Output of Dispatch Tables
        !           173: -------------------------
        !           174: 
        !           175: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
        !           176:      This macro should be provided on machines where the addresses in a
        !           177:      dispatch table are relative to the table's own address.
        !           178: 
        !           179:      The definition should be a C statement to output to the stdio
        !           180:      stream STREAM an assembler pseudo-instruction to generate a
        !           181:      difference between two labels.  VALUE and REL are the numbers of
        !           182:      two internal labels.  The definitions of these labels are output
        !           183:      using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
        !           184:      same way here.  For example,
        !           185: 
        !           186:           fprintf (STREAM, "\t.word L%d-L%d\n",
        !           187:                    VALUE, REL)
        !           188: 
        !           189: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
        !           190:      This macro should be provided on machines where the addresses in a
        !           191:      dispatch table are absolute.
        !           192: 
        !           193:      The definition should be a C statement to output to the stdio
        !           194:      stream STREAM an assembler pseudo-instruction to generate a
        !           195:      reference to a label.  VALUE is the number of an internal label
        !           196:      whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For
        !           197:      example,
        !           198: 
        !           199:           fprintf (STREAM, "\t.word L%d\n", VALUE)
        !           200: 
        !           201: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
        !           202:      Define this if the label before a jump-table needs to be output
        !           203:      specially.  The first three arguments are the same as for
        !           204:      `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
        !           205:      which follows (a `jump_insn' containing an `addr_vec' or
        !           206:      `addr_diff_vec').
        !           207: 
        !           208:      This feature is used on system V to output a `swbeg' statement for
        !           209:      the table.
        !           210: 
        !           211:      If this macro is not defined, these labels are output with
        !           212:      `ASM_OUTPUT_INTERNAL_LABEL'.
        !           213: 
        !           214: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
        !           215:      Define this if something special must be output at the end of a
        !           216:      jump-table.  The definition should be a C statement to be executed
        !           217:      after the assembler code for the table is written.  It should write
        !           218:      the appropriate code to stdio stream STREAM.  The argument TABLE
        !           219:      is the jump-table insn, and NUM is the label-number of the
        !           220:      preceding label.
        !           221: 
        !           222:      If this macro is not defined, nothing special is output at the end
        !           223:      of the jump-table.
        !           224: 
        !           225: 
        !           226: File: gcc.info,  Node: Alignment Output,  Prev: Dispatch Tables,  Up: Assembler Format
        !           227: 
        !           228: Assembler Commands for Alignment
        !           229: --------------------------------
        !           230: 
        !           231: `ASM_OUTPUT_ALIGN_CODE (FILE)'
        !           232:      A C expression to output text to align the location counter in the
        !           233:      way that is desirable at a point in the code that is reached only
        !           234:      by jumping.
        !           235: 
        !           236:      This macro need not be defined if you don't want any special
        !           237:      alignment to be done at such a time.  Most machine descriptions do
        !           238:      not currently define the macro.
        !           239: 
        !           240: `ASM_OUTPUT_LOOP_ALIGN (FILE)'
        !           241:      A C expression to output text to align the location counter in the
        !           242:      way that is desirable at the beginning of a loop.
        !           243: 
        !           244:      This macro need not be defined if you don't want any special
        !           245:      alignment to be done at such a time.  Most machine descriptions do
        !           246:      not currently define the macro.
        !           247: 
        !           248: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
        !           249:      A C statement to output to the stdio stream STREAM an assembler
        !           250:      instruction to advance the location counter by NBYTES bytes. Those
        !           251:      bytes should be zero when loaded.  NBYTES will be a C expression
        !           252:      of type `int'.
        !           253: 
        !           254: `ASM_NO_SKIP_IN_TEXT'
        !           255:      Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
        !           256:      text section because it fails put zeros in the bytes that are
        !           257:      skipped. This is true on many Unix systems, where the pseudo--op
        !           258:      to skip bytes produces no-op instructions rather than zeros when
        !           259:      used in the text section.
        !           260: 
        !           261: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
        !           262:      A C statement to output to the stdio stream STREAM an assembler
        !           263:      command to advance the location counter to a multiple of 2 to the
        !           264:      POWER bytes.  POWER will be a C expression of type `int'.
        !           265: 
        !           266: 
        !           267: File: gcc.info,  Node: Debugging Info,  Next: Cross-compilation,  Prev: Assembler Format,  Up: Target Macros
        !           268: 
        !           269: Controlling Debugging Information Format
        !           270: ========================================
1.1       root      271: 
                    272: * Menu:
                    273: 
1.1.1.2 ! root      274: * All Debuggers::      Macros that affect all debugging formats uniformly.
        !           275: * DBX Options::        Macros enabling specific options in DBX format.
        !           276: * DBX Hooks::          Hook macros for varying DBX format.
        !           277: * File Names and DBX:: Macros controlling output of file names in DBX format.
        !           278: * SDB and DWARF::      Macros for SDB (COFF) and DWARF formats.
        !           279: 
        !           280: 
        !           281: File: gcc.info,  Node: All Debuggers,  Next: DBX Options,  Up: Debugging Info
        !           282: 
        !           283: Macros Affecting All Debugging Formats
        !           284: --------------------------------------
        !           285: 
        !           286: `DBX_REGISTER_NUMBER (REGNO)'
        !           287:      A C expression that returns the DBX register number for the
        !           288:      compiler register number REGNO.  In simple cases, the value of this
        !           289:      expression may be REGNO itself.  But sometimes there are some
        !           290:      registers that the compiler knows about and DBX does not, or vice
        !           291:      versa.  In such cases, some register may need to have one number in
        !           292:      the compiler and another for DBX.
        !           293: 
        !           294:      If two registers have consecutive numbers inside GNU CC, and they
        !           295:      can be used as a pair to hold a multiword value, then they *must*
        !           296:      have consecutive numbers after renumbering with
        !           297:      `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to
        !           298:      access such a pair, because they expect register pairs to be
        !           299:      consecutive in their own numbering scheme.
        !           300: 
        !           301:      If you find yourself defining `DBX_REGISTER_NUMBER' in way that
        !           302:      does not preserve register pairs, then what you must do instead is
        !           303:      redefine the actual register numbering scheme.
        !           304: 
        !           305: `DEBUGGER_AUTO_OFFSET (X)'
        !           306:      A C expression that returns the integer offset value for an
        !           307:      automatic variable having address X (an RTL expression).  The
        !           308:      default computation assumes that X is based on the frame-pointer
        !           309:      and gives the offset from the frame-pointer.  This is required for
        !           310:      targets that produce debugging output for DBX or COFF-style
        !           311:      debugging output for SDB and allow the frame-pointer to be
        !           312:      eliminated when the `-g' options is used.
        !           313: 
        !           314: `DEBUGGER_ARG_OFFSET (OFFSET, X)'
        !           315:      A C expression that returns the integer offset value for an
        !           316:      argument having address X (an RTL expression).  The nominal offset
        !           317:      is OFFSET.
        !           318: 
        !           319: 
        !           320: File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
        !           321: 
        !           322: Specific Options for DBX Output
        !           323: -------------------------------
        !           324: 
        !           325: `DBX_DEBUGGING_INFO'
        !           326:      Define this macro if GNU CC should produce debugging output for DBX
        !           327:      in response to the `-g' option.
        !           328: 
        !           329: `XCOFF_DEBUGGING_INFO'
        !           330:      Define this macro if GNU CC should produce XCOFF format debugging
        !           331:      output in response to the `-g' option.  This is a variant of DBX
        !           332:      format.
        !           333: 
        !           334: `DEFAULT_GDB_EXTENSIONS'
        !           335:      Define this macro to control whether GNU CC should by default
        !           336:      generate GDB's extended version of DBX debugging information
        !           337:      (assuming DBX-format debugging information is enabled at all).  If
        !           338:      you don't define the macro, the default is 1: always generate the
        !           339:      extended information if there is any occasion to.
        !           340: 
        !           341: `DEBUG_SYMS_TEXT'
        !           342:      Define this macro if all `.stabs' commands should be output while
        !           343:      in the text section.
        !           344: 
        !           345: `ASM_STABS_OP'
        !           346:      A C string constant naming the assembler pseudo op to use instead
        !           347:      of `.stabs' to define an ordinary debugging symbol.  If you don't
        !           348:      define this macro, `.stabs' is used.  This macro applies only to
        !           349:      DBX debugging information format.
        !           350: 
        !           351: `ASM_STABD_OP'
        !           352:      A C string constant naming the assembler pseudo op to use instead
        !           353:      of `.stabd' to define a debugging symbol whose value is the current
        !           354:      location.  If you don't define this macro, `.stabd' is used. This
        !           355:      macro applies only to DBX debugging information format.
        !           356: 
        !           357: `ASM_STABN_OP'
        !           358:      A C string constant naming the assembler pseudo op to use instead
        !           359:      of `.stabn' to define a debugging symbol with no name.  If you
        !           360:      don't define this macro, `.stabn' is used.  This macro applies
        !           361:      only to DBX debugging information format.
        !           362: 
        !           363: `DBX_NO_XREFS'
        !           364:      Define this macro if DBX on your system does not support the
        !           365:      construct `xsTAGNAME'.  On some systems, this construct is used to
        !           366:      describe a forward reference to a structure named TAGNAME. On
        !           367:      other systems, this construct is not supported at all.
        !           368: 
        !           369: `DBX_CONTIN_LENGTH'
        !           370:      A symbol name in DBX-format debugging information is normally
        !           371:      continued (split into two separate `.stabs' directives) when it
        !           372:      exceeds a certain length (by default, 80 characters).  On some
        !           373:      operating systems, DBX requires this splitting; on others,
        !           374:      splitting must not be done.  You can inhibit splitting by defining
        !           375:      this macro with the value zero.  You can override the default
        !           376:      splitting-length by defining this macro as an expression for the
        !           377:      length you desire.
        !           378: 
        !           379: `DBX_CONTIN_CHAR'
        !           380:      Normally continuation is indicated by adding a `\' character to
        !           381:      the end of a `.stabs' string when a continuation follows.  To use
        !           382:      a different character instead, define this macro as a character
        !           383:      constant for the character you want to use.  Do not define this
        !           384:      macro if backslash is correct for your system.
        !           385: 
        !           386: `DBX_STATIC_STAB_DATA_SECTION'
        !           387:      Define this macro if it is necessary to go to the data section
        !           388:      before outputting the `.stabs' pseudo-op for a non-global static
        !           389:      variable.
        !           390: 
        !           391: `DBX_TYPE_DECL_STABS_CODE'
        !           392:      The value to use in the "code" field of the `.stabs' directive for
        !           393:      a typedef.  The default is `N_LSYM'.
        !           394: 
        !           395: `DBX_STATIC_CONST_VAR_CODE'
        !           396:      The value to use in the "code" field of the `.stabs' directive for
        !           397:      a static variable located in the text section.  DBX format does not
        !           398:      provide any "right" way to do this.  The default is `N_FUN'.
        !           399: 
        !           400: `DBX_REGPARM_STABS_CODE'
        !           401:      The value to use in the "code" field of the `.stabs' directive for
        !           402:      a parameter passed in registers.  DBX format does not provide any
        !           403:      "right" way to do this.  The default is `N_RSYM'.
        !           404: 
        !           405: `DBX_REGPARM_STABS_LETTER'
        !           406:      The letter to use in DBX symbol data to identify a symbol as a
        !           407:      parameter passed in registers.  DBX format does not customarily
        !           408:      provide any way to do this.  The default is `'P''.
        !           409: 
        !           410: `DBX_MEMPARM_STABS_LETTER'
        !           411:      The letter to use in DBX symbol data to identify a symbol as a
        !           412:      stack parameter.  The default is `'p''.
        !           413: 
        !           414: `DBX_FUNCTION_FIRST'
        !           415:      Define this macro if the DBX information for a function and its
        !           416:      arguments should precede the assembler code for the function. 
        !           417:      Normally, in DBX format, the debugging information entirely
        !           418:      follows the assembler code.
        !           419: 
        !           420: `DBX_LBRAC_FIRST'
        !           421:      Define this macro if the `N_LBRAC' symbol for a block should
        !           422:      precede the debugging information for variables and functions
        !           423:      defined in that block.  Normally, in DBX format, the `N_LBRAC'
        !           424:      symbol comes first.
        !           425: 
        !           426: 
        !           427: File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
        !           428: 
        !           429: Open-Ended Hooks for DBX Format
        !           430: -------------------------------
        !           431: 
        !           432: `DBX_OUTPUT_LBRAC (STREAM, NAME)'
        !           433:      Define this macro to say how to output to STREAM the debugging
        !           434:      information for the start of a scope level for variable names.  The
        !           435:      argument NAME is the name of an assembler symbol (for use with
        !           436:      `assemble_name') whose value is the address where the scope begins.
        !           437: 
        !           438: `DBX_OUTPUT_RBRAC (STREAM, NAME)'
        !           439:      Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
        !           440: 
        !           441: `DBX_OUTPUT_ENUM (STREAM, TYPE)'
        !           442:      Define this macro if the target machine requires special handling
        !           443:      to output an enumeration type.  The definition should be a C
        !           444:      statement (sans semicolon) to output the appropriate information
        !           445:      to STREAM for the type TYPE.
        !           446: 
        !           447: `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
        !           448:      Define this macro if the target machine requires special output at
        !           449:      the end of the debugging information for a function.  The
        !           450:      definition should be a C statement (sans semicolon) to output the
        !           451:      appropriate information to STREAM.  FUNCTION is the
        !           452:      `FUNCTION_DECL' node for the function.
        !           453: 
        !           454: `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
        !           455:      Define this macro if you need to control the order of output of the
        !           456:      standard data types at the beginning of compilation.  The argument
        !           457:      SYMS is a `tree' which is a chain of all the predefined global
        !           458:      symbols, including names of data types.
        !           459: 
        !           460:      Normally, DBX output starts with definitions of the types for
        !           461:      integers and characters, followed by all the other predefined
        !           462:      types of the particular language in no particular order.
        !           463: 
        !           464:      On some machines, it is necessary to output different particular
        !           465:      types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
        !           466:      output those symbols in the necessary order.  Any predefined types
        !           467:      that you don't explicitly output will be output afterward in no
        !           468:      particular order.
        !           469: 
        !           470:      Be careful not to define this macro so that it works only for C. 
        !           471:      There are no global variables to access most of the built-in
        !           472:      types, because another language may have another set of types. 
        !           473:      The way to output a particular type is to look through SYMS to see
        !           474:      if you can find it. Here is an example:
        !           475: 
        !           476:           {
        !           477:             tree decl;
        !           478:             for (decl = syms; decl; decl = TREE_CHAIN (decl))
        !           479:               if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "long int"))
        !           480:                 dbxout_symbol (decl);
        !           481:             ...
        !           482:           }
        !           483: 
        !           484:      This does nothing if the expected type does not exist.
        !           485: 
        !           486:      See the function `init_decl_processing' in source file `c-decl.c'
        !           487:      to find the names to use for all the built-in C types.
        !           488: 
        !           489:      Here is another way of finding a particular type:
        !           490: 
        !           491:           {
        !           492:             tree decl;
        !           493:             for (decl = syms; decl; decl = TREE_CHAIN (decl))
        !           494:               if (TREE_CODE (decl) == TYPE_DECL
        !           495:                   && TREE_CODE (TREE_TYPE (decl)) == INTEGER_CST
        !           496:                   && TYPE_PRECISION (TREE_TYPE (decl)) == 16
        !           497:                   && TYPE_UNSIGNED (TREE_TYPE (decl)))
        !           498:                 /* This must be `unsigned short'.  */
        !           499:                 dbxout_symbol (decl);
        !           500:             ...
        !           501:           }
        !           502: 
        !           503: 
        !           504: File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
        !           505: 
        !           506: File Names in DBX Format
        !           507: ------------------------
        !           508: 
        !           509: `DBX_WORKING_DIRECTORY'
        !           510:      Define this if DBX wants to have the current directory recorded in
        !           511:      each object file.
        !           512: 
        !           513:      Note that the working directory is always recorded if GDB
        !           514:      extensions are enabled.
        !           515: 
        !           516: `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
        !           517:      A C statement to output DBX debugging information to the stdio
        !           518:      stream STREAM which indicates that file NAME is the main source
        !           519:      file--the file specified as the input file for compilation. This
        !           520:      macro is called only once, at the beginning of compilation.
        !           521: 
        !           522:      This macro need not be defined if the standard form of output for
        !           523:      DBX debugging information is appropriate.
        !           524: 
        !           525: `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
        !           526:      A C statement to output DBX debugging information to the stdio
        !           527:      stream STREAM which indicates that the current directory during
        !           528:      compilation is named NAME.
        !           529: 
        !           530:      This macro need not be defined if the standard form of output for
        !           531:      DBX debugging information is appropriate.
        !           532: 
        !           533: `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
        !           534:      A C statement to output DBX debugging information at the end of
        !           535:      compilation of the main source file NAME.
        !           536: 
        !           537:      If you don't define this macro, nothing special is output at the
        !           538:      end of compilation, which is correct for most machines.
        !           539: 
        !           540: `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
        !           541:      A C statement to output DBX debugging information to the stdio
        !           542:      stream STREAM which indicates that file NAME is the current source
        !           543:      file.  This output is generated each time input shifts to a
        !           544:      different source file as a result of `#include', the end of an
        !           545:      included file, or a `#line' command.
        !           546: 
        !           547:      This macro need not be defined if the standard form of output for
        !           548:      DBX debugging information is appropriate.
        !           549: 
        !           550: 
        !           551: File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
        !           552: 
        !           553: Macros for SDB and DWARF Output
        !           554: -------------------------------
        !           555: 
        !           556: `SDB_DEBUGGING_INFO'
        !           557:      Define this macro if GNU CC should produce COFF-style debugging
        !           558:      output for SDB in response to the `-g' option.
        !           559: 
        !           560: `DWARF_DEBUGGING_INFO'
        !           561:      Define this macro if GNU CC should produce dwarf format debugging
        !           562:      output in response to the `-g' option.
        !           563: 
        !           564: `PUT_SDB_...'
        !           565:      Define these macros to override the assembler syntax for the
        !           566:      special SDB assembler directives.  See `sdbout.c' for a list of
        !           567:      these macros and their arguments.  If the standard syntax is used,
        !           568:      you need not define them yourself.
        !           569: 
        !           570: `SDB_DELIM'
        !           571:      Some assemblers do not support a semicolon as a delimiter, even
        !           572:      between SDB assembler directives.  In that case, define this macro
        !           573:      to be the delimiter to use (usually `\n').  It is not necessary to
        !           574:      define a new set of `PUT_SDB_OP' macros if this is the only change
        !           575:      required.
        !           576: 
        !           577: `SDB_GENERATE_FAKE'
        !           578:      Define this macro to override the usual method of constructing a
        !           579:      dummy name for anonymous structure and union types.  See
        !           580:      `sdbout.c' for more information.
        !           581: 
        !           582: `SDB_ALLOW_UNKNOWN_REFERENCES'
        !           583:      Define this macro to allow references to unknown structure, union,
        !           584:      or enumeration tags to be emitted.  Standard COFF does not allow
        !           585:      handling of unknown references, MIPS ECOFF has support for it.
        !           586: 
        !           587: `SDB_ALLOW_FORWARD_REFERENCES'
        !           588:      Define this macro to allow references to structure, union, or
        !           589:      enumeration tags that have not yet been seen to be handled.  Some
        !           590:      assemblers choke if forward tags are used, while some require it.
        !           591: 
        !           592: 
        !           593: File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Debugging Info,  Up: Target Macros
        !           594: 
        !           595: Cross Compilation and Floating Point Format
        !           596: ===========================================
        !           597: 
        !           598:    While all modern machines use 2's complement representation for
        !           599: integers, there are a variety of representations for floating point
        !           600: numbers.  This means that in a cross-compiler the representation of
        !           601: floating point numbers in the compiled program may be different from
        !           602: that used in the machine doing the compilation.
        !           603: 
        !           604:    Because different representation systems may offer different amounts
        !           605: of range and precision, the cross compiler cannot safely use the host
        !           606: machine's floating point arithmetic.  Therefore, floating point
        !           607: constants must be represented in the target machine's format.  This
        !           608: means that the cross compiler cannot use `atof' to parse a floating
        !           609: point constant; it must have its own special routine to use instead. 
        !           610: Also, constant folding must emulate the target machine's arithmetic (or
        !           611: must not be done at all).
        !           612: 
        !           613:    The macros in the following table should be defined only if you are
        !           614: cross compiling between different floating point formats.
        !           615: 
        !           616:    Otherwise, don't define them. Then default definitions will be set
        !           617: up which use `double' as the data type, `==' to test for equality, etc.
        !           618: 
        !           619:    You don't need to worry about how many times you use an operand of
        !           620: any of these macros.  The compiler never uses operands which have side
        !           621: effects.
        !           622: 
        !           623: `REAL_VALUE_TYPE'
        !           624:      A macro for the C data type to be used to hold a floating point
        !           625:      value in the target machine's format.  Typically this would be a
        !           626:      `struct' containing an array of `int'.
        !           627: 
        !           628: `REAL_VALUES_EQUAL (X, Y)'
        !           629:      A macro for a C expression which compares for equality the two
        !           630:      values, X and Y, both of type `REAL_VALUE_TYPE'.
        !           631: 
        !           632: `REAL_VALUES_LESS (X, Y)'
        !           633:      A macro for a C expression which tests whether X is less than Y,
        !           634:      both values being of type `REAL_VALUE_TYPE' and interpreted as
        !           635:      floating point numbers in the target machine's representation.
        !           636: 
        !           637: `REAL_VALUE_LDEXP (X, SCALE)'
        !           638:      A macro for a C expression which performs the standard library
        !           639:      function `ldexp', but using the target machine's floating point
        !           640:      representation.  Both X and the value of the expression have type
        !           641:      `REAL_VALUE_TYPE'.  The second argument, SCALE, is an integer.
        !           642: 
        !           643: `REAL_VALUE_FIX (X)'
        !           644:      A macro whose definition is a C expression to convert the
        !           645:      target-machine floating point value X to a signed integer.  X has
        !           646:      type `REAL_VALUE_TYPE'.
        !           647: 
        !           648: `REAL_VALUE_UNSIGNED_FIX (X)'
        !           649:      A macro whose definition is a C expression to convert the
        !           650:      target-machine floating point value X to an unsigned integer.  X
        !           651:      has type `REAL_VALUE_TYPE'.
        !           652: 
        !           653: `REAL_VALUE_FIX_TRUNCATE (X)'
        !           654:      A macro whose definition is a C expression to convert the
        !           655:      target-machine floating point value X to a signed integer,
        !           656:      rounding toward 0. X has type `REAL_VALUE_TYPE'.
        !           657: 
        !           658: `REAL_VALUE_UNSIGNED_FIX_TRUNCATE (X)'
        !           659:      A macro whose definition is a C expression to convert the
        !           660:      target-machine floating point value X to an unsigned integer,
        !           661:      rounding toward 0. X has type `REAL_VALUE_TYPE'.
        !           662: 
        !           663: `REAL_VALUE_ATOF (STRING)'
        !           664:      A macro for a C expression which converts STRING, an expression of
        !           665:      type `char *', into a floating point number in the target
        !           666:      machine's representation.  The value has type `REAL_VALUE_TYPE'.
        !           667: 
        !           668: `REAL_INFINITY'
        !           669:      Define this macro if infinity is a possible floating point value,
        !           670:      and therefore division by 0 is legitimate.
        !           671: 
        !           672: `REAL_VALUE_ISINF (X)'
        !           673:      A macro for a C expression which determines whether X, a floating
        !           674:      point value, is infinity.  The value has type `int'. By default,
        !           675:      this is defined to call `isinf'.
        !           676: 
        !           677: `REAL_VALUE_ISNAN (X)'
        !           678:      A macro for a C expression which determines whether X, a floating
        !           679:      point value, is a "nan" (not-a-number).  The value has type `int'.
        !           680:       By default, this is defined to call `isnan'.
        !           681: 
        !           682:    Define the following additional macros if you want to make floating
        !           683: point constant folding work while cross compiling.  If you don't define
        !           684: them, cross compilation is still possible, but constant folding will
        !           685: not happen for floating point values.
        !           686: 
        !           687: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
        !           688:      A macro for a C statement which calculates an arithmetic operation
        !           689:      of the two floating point values X and Y, both of type
        !           690:      `REAL_VALUE_TYPE' in the target machine's representation, to
        !           691:      produce a result of the same type and representation which is
        !           692:      stored in OUTPUT (which will be a variable).
        !           693: 
        !           694:      The operation to be performed is specified by CODE, a tree code
        !           695:      which will always be one of the following: `PLUS_EXPR',
        !           696:      `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
        !           697: 
        !           698:      The expansion of this macro is responsible for checking for
        !           699:      overflow. If overflow happens, the macro expansion should execute
        !           700:      the statement `return 0;', which indicates the inability to
        !           701:      perform the arithmetic operation requested.
        !           702: 
        !           703: `REAL_VALUE_NEGATE (X)'
        !           704:      A macro for a C expression which returns the negative of the
        !           705:      floating point value X.  Both X and the value of the expression
        !           706:      have type `REAL_VALUE_TYPE' and are in the target machine's
        !           707:      floating point representation.
        !           708: 
        !           709:      There is no way for this macro to report overflow, since overflow
        !           710:      can't happen in the negation operation.
        !           711: 
        !           712: `REAL_VALUE_TRUNCATE (MODE, X)'
        !           713:      A macro for a C expression which converts the floating point value
        !           714:      X to mode MODE.
        !           715: 
        !           716:      Both X and the value of the expression have type `REAL_VALUE_TYPE'
        !           717:      and are in the target machine's floating point representation. 
        !           718:      However, the value should have an appropriate bit pattern to be
        !           719:      output properly as a floating constant whose precision accords
        !           720:      with mode MODE.
        !           721: 
        !           722:      There is no way for this macro to report overflow.
        !           723: 
        !           724: `REAL_VALUE_TO_INT (LOW, HIGH, X)'
        !           725:      A macro for a C expression which converts a floating point value X
        !           726:      into a double-precision integer which is then stored into LOW and
        !           727:      HIGH, two variables of type INT.
        !           728: 
        !           729: `REAL_VALUE_FROM_INT (X, LOW, HIGH)'
        !           730:      A macro for a C expression which converts a double-precision
        !           731:      integer found in LOW and HIGH, two variables of type INT, into a
        !           732:      floating point value which is then stored into X.
        !           733: 
        !           734: 
        !           735: File: gcc.info,  Node: Misc,  Prev: Cross-compilation,  Up: Target Macros
        !           736: 
        !           737: Miscellaneous Parameters
        !           738: ========================
        !           739: 
        !           740: `PREDICATE_CODES'
        !           741:      Optionally define this if you have added predicates to
        !           742:      `MACHINE.c'.  This macro is called within an initializer of an
        !           743:      array of structures.  The first field in the structure is the name
        !           744:      of a predicate and the second field is an array of rtl codes.  For
        !           745:      each predicate, list all rtl codes that can be in expressions
        !           746:      matched by the predicate.  The list should have a trailing comma. 
        !           747:      Here is an example of two entries in the list for a typical RISC
        !           748:      machine:
        !           749: 
        !           750:           #define PREDICATE_CODES \
        !           751:             {"gen_reg_rtx_operand", {SUBREG, REG}},  \
        !           752:             {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
        !           753: 
        !           754:      Defining this macro does not affect the generated code (however,
        !           755:      incorrect definitions that omit an rtl code that may be matched by
        !           756:      the predicate can cause the compiler to malfunction).  Instead, it
        !           757:      allows the table built by `genrecog' to be more compact and
        !           758:      efficient, thus speeding up the compiler.  The most important
        !           759:      predicates to include in the list specified by this macro are
        !           760:      thoses used in the most insn patterns.
        !           761: 
        !           762: `CASE_VECTOR_MODE'
        !           763:      An alias for a machine mode name.  This is the machine mode that
        !           764:      elements of a jump-table should have.
        !           765: 
        !           766: `CASE_VECTOR_PC_RELATIVE'
        !           767:      Define this macro if jump-tables should contain relative addresses.
        !           768: 
        !           769: `CASE_DROPS_THROUGH'
        !           770:      Define this if control falls through a `case' insn when the index
        !           771:      value is out of range.  This means the specified default-label is
        !           772:      actually ignored by the `case' insn proper.
        !           773: 
        !           774: `CASE_VALUES_THRESHOLD'
        !           775:      Define this to be the smallest number of different values for
        !           776:      which it is best to use a jump-table instead of a tree of
        !           777:      conditional branches. The default is four for machines with a
        !           778:      `casesi' instruction and five otherwise.  This is best for most
        !           779:      machines.
        !           780: 
        !           781: `BYTE_LOADS_ZERO_EXTEND'
        !           782:      Define this macro if an instruction to load a value narrower than a
        !           783:      word from memory into a register also zero-extends the value to
        !           784:      the whole register.
        !           785: 
        !           786: `BYTE_LOADS_SIGN_EXTEND'
        !           787:      Define this macro if an instruction to load a value narrower than a
        !           788:      word from memory into a register also sign-extends the value to
        !           789:      the whole register.
        !           790: 
        !           791: `IMPLICIT_FIX_EXPR'
        !           792:      An alias for a tree code that should be used by default for
        !           793:      conversion of floating point values to fixed point.  Normally,
        !           794:      `FIX_ROUND_EXPR' is used.
        !           795: 
        !           796: `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
        !           797:      Define this macro if the same instructions that convert a floating
        !           798:      point number to a signed fixed point number also convert validly
        !           799:      to an unsigned one.
        !           800: 
        !           801: `EASY_DIV_EXPR'
        !           802:      An alias for a tree code that is the easiest kind of division to
        !           803:      compile code for in the general case.  It may be `TRUNC_DIV_EXPR',
        !           804:      `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'.  These four
        !           805:      division operators differ in how they round the result to an
        !           806:      integer.  `EASY_DIV_EXPR' is used when it is permissible to use
        !           807:      any of those kinds of division and the choice should be made on
        !           808:      the basis of efficiency.
        !           809: 
        !           810: `MOVE_MAX'
        !           811:      The maximum number of bytes that a single instruction can move
        !           812:      quickly from memory to memory.
        !           813: 
        !           814: `SHIFT_COUNT_TRUNCATED'
        !           815:      Defining this macro causes the compiler to omit a sign-extend,
        !           816:      zero-extend, or bitwise `and' instruction that truncates the count
        !           817:      of a shift operation to a width equal to the number of bits needed
        !           818:      to represent the size of the object being shifted.  On machines
        !           819:      that have instructions that act on bitfields at variable
        !           820:      positions, which may include `bit test' instructions, defining
        !           821:      `SHIFT_COUNT_TRUNCATED' also enables deletion of truncations of
        !           822:      the values that serve as arguments to bitfield instructions.
        !           823: 
        !           824:      If both types of instructions truncate the count (for shifts) and
        !           825:      position (for bitfield operations), or if no variable-position
        !           826:      bitfield instructions exist, you should define this macro.
        !           827: 
        !           828:      However, on some machines, such as the 80386 and the 680x0,
        !           829:      truncation only applies to shift operations and not the (real or
        !           830:      pretended) bitfield operations.  Do not define
        !           831:      `SHIFT_COUNT_TRUNCATED' on such machines.  Instead, add patterns
        !           832:      to the `md' file that include the implied truncation of the shift
        !           833:      instructions.
        !           834: 
        !           835: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
        !           836:      A C expression which is nonzero if on this machine it is safe to
        !           837:      "convert" an integer of INPREC bits to one of OUTPREC bits (where
        !           838:      OUTPREC is smaller than INPREC) by merely operating on it as if it
        !           839:      had only OUTPREC bits.
        !           840: 
        !           841:      On many machines, this expression can be 1.
        !           842: 
        !           843:      It is reported that suboptimal code can result when
        !           844:      `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
        !           845:      which `MODES_TIEABLE_P' is 0.  If this is the case, making
        !           846:      `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve things.
        !           847: 
        !           848: `STORE_FLAG_VALUE'
        !           849:      A C expression describing the value returned by a comparison
        !           850:      operator with an integral mode and stored by a store-flag
        !           851:      instruction (`sCOND') when the condition is true.  This
        !           852:      description must apply to *all* the `sCOND' patterns and all the
        !           853:      comparison operators whose results have a `MODE_INT' mode.
        !           854: 
        !           855:      A value of 1 or -1 means that the instruction implementing the
        !           856:      comparison operator returns exactly 1 or -1 when the comparison is
        !           857:      true and 0 when the comparison is false.  Otherwise, the value
        !           858:      indicates which bits of the result are guaranteed to be 1 when the
        !           859:      comparison is true.  This value is interpreted in the mode of the
        !           860:      comparison operation, which is given by the mode of the first
        !           861:      operand in the `sCOND' pattern.  Either the low bit or the sign
        !           862:      bit of `STORE_FLAG_VALUE' be on.  Presently, only those bits are
        !           863:      used by the compiler.
        !           864: 
        !           865:      If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will
        !           866:      generate code that depends only on the specified bits.  It can also
        !           867:      replace comparison operators with equivalent operations if they
        !           868:      cause the required bits to be set, even if the remaining bits are
        !           869:      undefined. For example, on a machine whose comparison operators
        !           870:      return an `SImode' value and where `STORE_FLAG_VALUE' is defined as
        !           871:      `0x80000000', saying that just the sign bit is relevant, the
        !           872:      expression
        !           873: 
        !           874:           (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0))
        !           875: 
        !           876:      can be converted to
        !           877: 
        !           878:           (ashift:SI X (const_int N))
        !           879: 
        !           880:      where N is the appropriate shift count to move the bit being
        !           881:      tested into the sign bit.
        !           882: 
        !           883:      There is no way to describe a machine that always sets the
        !           884:      low-order bit for a true value, but does not guarantee the value
        !           885:      of any other bits, but we do not know of any machine that has such
        !           886:      an instruction.  If you are trying to port GNU CC to such a
        !           887:      machine, include an instruction to perform a logical-and of the
        !           888:      result with 1 in the pattern for the comparison operators and let
        !           889:      us know (*note Bug Reporting::.).
        !           890: 
        !           891:      Often, a machine will have multiple instructions that obtain a
        !           892:      value from a comparison (or the condition codes).  Here are rules
        !           893:      to guide the choice of value for `STORE_FLAG_VALUE', and hence the
        !           894:      instructions to be used:
        !           895: 
        !           896:         * Use the shortest sequence that yields a valid definition for
        !           897:           `STORE_FLAG_VALUE'.  It is more efficient for the compiler to
        !           898:           "normalize" the value (convert it to, e.g., 1 or 0) than for
        !           899:           the comparison operators to do so because there may be
        !           900:           opportunities to combine the normalization with other
        !           901:           operations.
        !           902: 
        !           903:         * For equal-length sequences, use a value of 1 or -1, with -1
        !           904:           being slightly preferred on machines with expensive jumps and
        !           905:           1 preferred on other machines.
        !           906: 
        !           907:         * As a second choice, choose a value of `0x80000001' if
        !           908:           instructions exist that set both the sign and low-order bits
        !           909:           but do not define the others.
        !           910: 
        !           911:         * Otherwise, use a value of `0x80000000'.
        !           912: 
        !           913:      You need not define `STORE_FLAG_VALUE' if the machine has no
        !           914:      store-flag instructions.
        !           915: 
        !           916: `FLOAT_STORE_FLAG_VALUE'
        !           917:      A C expression that gives a non-zero floating point value that is
        !           918:      returned when comparison operators with floating-point results are
        !           919:      true. Define this macro on machine that have comparison operations
        !           920:      that return floating-point values.  If there are no such
        !           921:      operations, do not define this macro.
        !           922: 
        !           923: `Pmode'
        !           924:      An alias for the machine mode for pointers.  Normally the
        !           925:      definition can be
        !           926: 
        !           927:           #define Pmode SImode
        !           928: 
        !           929: `FUNCTION_MODE'
        !           930:      An alias for the machine mode used for memory references to
        !           931:      functions being called, in `call' RTL expressions.  On most
        !           932:      machines this should be `QImode'.
        !           933: 
        !           934: `INTEGRATE_THRESHOLD (DECL)'
        !           935:      A C expression for the maximum number of instructions above which
        !           936:      the function DECL should not be inlined.  DECL is a
        !           937:      `FUNCTION_DECL' node.
        !           938: 
        !           939:      The default definition of this macro is 64 plus 8 times the number
        !           940:      of arguments that the function accepts.  Some people think a larger
        !           941:      threshold should be used on RISC machines.
        !           942: 
        !           943: `SCCS_DIRECTIVE'
        !           944:      Define this if the preprocessor should ignore `#sccs' directives
        !           945:      and print no error message.
        !           946: 
        !           947: `HANDLE_PRAGMA (STREAM)'
        !           948:      Define this macro if you want to implement any pragmas.  If
        !           949:      defined, it should be a C statement to be executed when `#pragma'
        !           950:      is seen.  The argument STREAM is the stdio input stream from which
        !           951:      the source text can be read.
        !           952: 
        !           953:      It is generally a bad idea to implement new uses of `#pragma'.  The
        !           954:      only reason to define this macro is for compatibility with other
        !           955:      compilers that do support `#pragma' for the sake of any user
        !           956:      programs which already use it.
        !           957: 
        !           958: `DOLLARS_IN_IDENTIFIERS'
        !           959:      Define this macro to control use of the character `$' in identifier
        !           960:      names.  The value should be 0, 1, or 2.  0 means `$' is not allowed
        !           961:      by default; 1 means it is allowed by default if `-traditional' is
        !           962:      used; 2 means it is allowed by default provided `-ansi' is not
        !           963:      used. 1 is the default; there is no need to define this macro in
        !           964:      that case.
        !           965: 
        !           966: `NO_DOLLAR_IN_LABEL'
        !           967:      Define this macro if the assembler does not accept the character
        !           968:      `$' in label names.  By default constructors and destructors in
        !           969:      G++ have `$' in the identifiers.  If this macro is defined, `.' is
        !           970:      used instead.
        !           971: 
        !           972: `DEFAULT_MAIN_RETURN'
        !           973:      Define this macro if the target system expects every program's
        !           974:      `main' function to return a standard "success" value by default
        !           975:      (if no other value is explicitly returned).
        !           976: 
        !           977:      The definition should be a C statement (sans semicolon) to
        !           978:      generate the appropriate rtl instructions.  It is used only when
        !           979:      compiling the end of `main'.
        !           980: 
        !           981: `HAVE_ATEXIT'
        !           982:      Define this if the target system supports the function `atexit'
        !           983:      from the ANSI C standard.  If this is not defined, and
        !           984:      `INIT_SECTION_ASM_OP' is not defined, a default `exit' function
        !           985:      will be provided to support C++.
        !           986: 
        !           987: `EXIT_BODY'
        !           988:      Define this if your `exit' function needs to do something besides
        !           989:      calling an external function `_cleanup' before terminating with
        !           990:      `_exit'.  The `EXIT_BODY' macro is only needed if netiher
        !           991:      `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined.
        !           992: 
        !           993: 
        !           994: File: gcc.info,  Node: Config,  Next: Index,  Prev: Target Macros,  Up: Top
        !           995: 
        !           996: The Configuration File
        !           997: **********************
        !           998: 
        !           999:    The configuration file `xm-MACHINE.h' contains macro definitions
        !          1000: that describe the machine and system on which the compiler is running,
        !          1001: unlike the definitions in `MACHINE.h', which describe the machine for
        !          1002: which the compiler is producing output.  Most of the values in
        !          1003: `xm-MACHINE.h' are actually the same on all machines that GNU CC runs
        !          1004: on, so large parts of all configuration files are identical.  But there
        !          1005: are some macros that vary:
        !          1006: 
        !          1007: `USG'
        !          1008:      Define this macro if the host system is System V.
        !          1009: 
        !          1010: `VMS'
        !          1011:      Define this macro if the host system is VMS.
        !          1012: 
        !          1013: `FAILURE_EXIT_CODE'
        !          1014:      A C expression for the status code to be returned when the compiler
        !          1015:      exits after serious errors.
        !          1016: 
        !          1017: `SUCCESS_EXIT_CODE'
        !          1018:      A C expression for the status code to be returned when the compiler
        !          1019:      exits without serious errors.
        !          1020: 
        !          1021: `HOST_WORDS_BIG_ENDIAN'
        !          1022:      Defined if the host machine stores words of multi-word values in
        !          1023:      big-endian order.  (GNU CC does not depend on the host byte
        !          1024:      ordering within a word.)
        !          1025: 
        !          1026: `HOST_FLOAT_FORMAT'
        !          1027:      A numeric code distinguishing the floating point format for the
        !          1028:      host machine.  See `TARGET_FLOAT_FORMAT' in *Note Storage Layout::
        !          1029:      for the alternatives and default.
        !          1030: 
        !          1031: `HOST_BITS_PER_CHAR'
        !          1032:      A C expression for the number of bits in `char' on the host
        !          1033:      machine.
        !          1034: 
        !          1035: `HOST_BITS_PER_SHORT'
        !          1036:      A C expression for the number of bits in `short' on the host
        !          1037:      machine.
        !          1038: 
        !          1039: `HOST_BITS_PER_INT'
        !          1040:      A C expression for the number of bits in `int' on the host machine.
        !          1041: 
        !          1042: `HOST_BITS_PER_LONG'
        !          1043:      A C expression for the number of bits in `long' on the host
        !          1044:      machine.
        !          1045: 
        !          1046: `ONLY_INT_FIELDS'
        !          1047:      Define this macro to indicate that the host compiler only supports
        !          1048:      `int' bit fields, rather than other integral types, including
        !          1049:      `enum', as do most C compilers.
        !          1050: 
        !          1051: `EXECUTABLE_SUFFIX'
        !          1052:      Define this macro if the host system uses a naming convention for
        !          1053:      executable files that involves a common suffix (such as, in some
        !          1054:      systems, `.exe') that must be mentioned explicitly when you run
        !          1055:      the program.
        !          1056: 
        !          1057: `OBSTACK_CHUNK_SIZE'
        !          1058:      A C expression for the size of ordinary obstack chunks. If you
        !          1059:      don't define this, a usually-reasonable default is used.
        !          1060: 
        !          1061: `OBSTACK_CHUNK_ALLOC'
        !          1062:      The function used to allocate obstack chunks. If you don't define
        !          1063:      this, `xmalloc' is used.
        !          1064: 
        !          1065: `OBSTACK_CHUNK_FREE'
        !          1066:      The function used to free obstack chunks. If you don't define
        !          1067:      this, `free' is used.
        !          1068: 
        !          1069: `USE_C_ALLOCA'
        !          1070:      Define this macro to indicate that the compiler is running with the
        !          1071:      `alloca' implemented in C.  This version of `alloca' can be found
        !          1072:      in the file `alloca.c'; to use it, you must also alter the
        !          1073:      `Makefile' variable `ALLOCA'.  (This is done automatically for the
        !          1074:      systems on which we know it is needed.)
        !          1075: 
        !          1076:      If you do define this macro, you should probably do it as follows:
        !          1077: 
        !          1078:           #ifndef __GNUC__
        !          1079:           #define USE_C_ALLOCA
        !          1080:           #else
        !          1081:           #define alloca __builtin_alloca
        !          1082:           #endif
        !          1083: 
        !          1084:      so that when the compiler is compiled with GNU CC it uses the more
        !          1085:      efficient built-in `alloca' function.
        !          1086: 
        !          1087: `FUNCTION_CONVERSION_BUG'
        !          1088:      Define this macro to indicate that the host compiler does not
        !          1089:      properly handle converting a function value to a
        !          1090:      pointer-to-function when it is used in an expression.
        !          1091: 
        !          1092: `HAVE_VPRINTF'
        !          1093:      Define this if the library function `vprintf' is available on your
        !          1094:      system.
        !          1095: 
        !          1096: `MULTIBYTE_CHARS'
        !          1097:      Define this macro to enable support for multibyte characters in the
        !          1098:      input to GNU CC.  This requires that the host system support the
        !          1099:      ANSI C library functions for converting multibyte characters to
        !          1100:      wide characters.
        !          1101: 
        !          1102: `HAVE_PUTENV'
        !          1103:      Define this if the library function `putenv' is available on your
        !          1104:      system.
        !          1105: 
        !          1106: `NO_SYS_SIGLIST'
        !          1107:      Define this if your system *does not* provide the variable
        !          1108:      `sys_siglist'.
        !          1109: 
        !          1110: `USE_PROTOTYPES'
        !          1111:      Define this to be 1 if you know that the host compiler supports
        !          1112:      prototypes, even if it doesn't define __STDC__, or define it to be
        !          1113:      0 if you do not want any prototypes used in compiling GNU CC.  If
        !          1114:      `USE_PROTOTYPES' is not defined, it will be determined
        !          1115:      automatically whether your compiler supports prototypes by
        !          1116:      checking if `__STDC__' is defined.
        !          1117: 
        !          1118: `NO_MD_PROTOTYPES'
        !          1119:      Define this if you wish suppression of prototypes generated from
        !          1120:      the machine description file, but to use other prototypes within
        !          1121:      GNU CC.  If `USE_PROTOTYPES' is defined to be 0, or the host
        !          1122:      compiler does not support prototypes, this macro has no effect.
        !          1123: 
        !          1124: `MD_CALL_PROTOTYPES'
        !          1125:      Define this if you wish to generate prototypes for the `gen_call'
        !          1126:      or `gen_call_value' functions generated from the machine
        !          1127:      description file.  If `USE_PROTOTYPES' is defined to be 0, or the
        !          1128:      host compiler does not support prototypes, or `NO_MD_PROTOTYPES'
        !          1129:      is defined, this macro has no effect.  As soon as all of the
        !          1130:      machine descriptions are modified to have the appropriate number
        !          1131:      of arguments, this macro will be removed.
        !          1132: 
        !          1133:      Some systems do provide this variable, but with a different name
        !          1134:      such as `_sys_siglist'.  On these systems, you can define
        !          1135:      `sys_siglist' as a macro which expands into the name actually
        !          1136:      provided.
        !          1137: 
        !          1138: `NO_STAB_H'
        !          1139:      Define this if your system does not have the include file
        !          1140:      `stab.h'.  If `USG' is defined, `NO_STAB_H' is assumed.
1.1       root     1141: 
1.1.1.2 ! root     1142:    In addition, configuration files for system V define `bcopy',
        !          1143: `bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
        !          1144: when compiled with GNU CC, in order to take advantage of the benefit of
        !          1145: GNU CC's built-in `alloca'.
1.1       root     1146: 
1.1.1.2 ! root     1147: 

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