gcc/gcc.info-25

   1 This is Info file gcc.info, produced by Makeinfo version 1.68 from the
   2 input 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 59 Temple Place - Suite 330
   7 Boston, MA 02111-1307 USA
   8
   9    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997 Free
  10 Software Foundation, Inc.
  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
  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.
  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
  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 \1f
  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 reverse order of the
  70 list; destructors in forward 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 \1f
 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 `LD_INIT_SWITCH'
 185      If defined, a C string constant for a switch that tells the linker
 186      that the following symbol is an initialization routine.
 187
 188 `LD_FINI_SWITCH'
 189      If defined, a C string constant for a switch that tells the linker
 190      that the following symbol is a finalization routine.
 191
 192 `INVOKE__main'
 193      If defined, `main' will call `__main' despite the presence of
 194      `INIT_SECTION_ASM_OP'.  This macro should be defined for systems
 195      where the init section is not actually run automatically, but is
 196      still useful for collecting the lists of constructors and
 197      destructors.
 198
 199 `ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)'
 200      Define this macro as a C statement to output on the stream STREAM
 201      the assembler code to arrange to call the function named NAME at
 202      initialization time.
 203
 204      Assume that NAME is the name of a C function generated
 205      automatically by the compiler.  This function takes no arguments.
 206      Use the function `assemble_name' to output the name NAME; this
 207      performs any system-specific syntactic transformations such as
 208      adding an underscore.
 209
 210      If you don't define this macro, nothing special is output to
 211      arrange to call the function.  This is correct when the function
 212      will be called in some other manner--for example, by means of the
 213      `collect2' program, which looks through the symbol table to find
 214      these functions by their names.
 215
 216 `ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)'
 217      This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination
 218      functions rather than initialization functions.
 219
 220    If your system uses `collect2' as the means of processing
 221 constructors, then that program normally uses `nm' to scan an object
 222 file for constructor functions to be called.  On certain kinds of
 223 systems, you can define these macros to make `collect2' work faster
 224 (and, in some cases, make it work at all):
 225
 226 `OBJECT_FORMAT_COFF'
 227      Define this macro if the system uses COFF (Common Object File
 228      Format) object files, so that `collect2' can assume this format
 229      and scan object files directly for dynamic constructor/destructor
 230      functions.
 231
 232 `OBJECT_FORMAT_ROSE'
 233      Define this macro if the system uses ROSE format object files, so
 234      that `collect2' can assume this format and scan object files
 235      directly for dynamic constructor/destructor functions.
 236
 237      These macros are effective only in a native compiler; `collect2' as
 238      part of a cross compiler always uses `nm' for the target machine.
 239
 240 `REAL_NM_FILE_NAME'
 241      Define this macro as a C string constant containing the file name
 242      to use to execute `nm'.  The default is to search the path
 243      normally for `nm'.
 244
 245      If your system supports shared libraries and has a program to list
 246      the dynamic dependencies of a given library or executable, you can
 247      define these macros to enable support for running initialization
 248      and termination functions in shared libraries:
 249
 250 `LDD_SUFFIX'
 251      Define this macro to a C string constant containing the name of the
 252      program which lists dynamic dependencies, like `"ldd"' under SunOS
 253      4.
 254
 255 `PARSE_LDD_OUTPUT (PTR)'
 256      Define this macro to be C code that extracts filenames from the
 257      output of the program denoted by `LDD_SUFFIX'.  PTR is a variable
 258      of type `char *' that points to the beginning of a line of output
 259      from `LDD_SUFFIX'.  If the line lists a dynamic dependency, the
 260      code must advance PTR to the beginning of the filename on that
 261      line.  Otherwise, it must set PTR to `NULL'.
 262
 263 \1f
 264 File: gcc.info,  Node: Instruction Output,  Next: Dispatch Tables,  Prev: Macros for Initialization,  Up: Assembler Format
 265
 266 Output of Assembler Instructions
 267 --------------------------------
 268
 269    This describes assembler instruction output.
 270
 271 `REGISTER_NAMES'
 272      A C initializer containing the assembler's names for the machine
 273      registers, each one as a C string constant.  This is what
 274      translates register numbers in the compiler into assembler
 275      language.
 276
 277 `ADDITIONAL_REGISTER_NAMES'
 278      If defined, a C initializer for an array of structures containing
 279      a name and a register number.  This macro defines additional names
 280      for hard registers, thus allowing the `asm' option in declarations
 281      to refer to registers using alternate names.
 282
 283 `ASM_OUTPUT_OPCODE (STREAM, PTR)'
 284      Define this macro if you are using an unusual assembler that
 285      requires different names for the machine instructions.
 286
 287      The definition is a C statement or statements which output an
 288      assembler instruction opcode to the stdio stream STREAM.  The
 289      macro-operand PTR is a variable of type `char *' which points to
 290      the opcode name in its "internal" form--the form that is written
 291      in the machine description.  The definition should output the
 292      opcode name to STREAM, performing any translation you desire, and
 293      increment the variable PTR to point at the end of the opcode so
 294      that it will not be output twice.
 295
 296      In fact, your macro definition may process less than the entire
 297      opcode name, or more than the opcode name; but if you want to
 298      process text that includes `%'-sequences to substitute operands,
 299      you must take care of the substitution yourself.  Just be sure to
 300      increment PTR over whatever text should not be output normally.
 301
 302      If you need to look at the operand values, they can be found as the
 303      elements of `recog_operand'.
 304
 305      If the macro definition does nothing, the instruction is output in
 306      the usual way.
 307
 308 `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
 309      If defined, a C statement to be executed just prior to the output
 310      of assembler code for INSN, to modify the extracted operands so
 311      they will be output differently.
 312
 313      Here the argument OPVEC is the vector containing the operands
 314      extracted from INSN, and NOPERANDS is the number of elements of
 315      the vector which contain meaningful data for this insn.  The
 316      contents of this vector are what will be used to convert the insn
 317      template into assembler code, so you can change the assembler
 318      output by changing the contents of the vector.
 319
 320      This macro is useful when various assembler syntaxes share a single
 321      file of instruction patterns; by defining this macro differently,
 322      you can cause a large class of instructions to be output
 323      differently (such as with rearranged operands).  Naturally,
 324      variations in assembler syntax affecting individual insn patterns
 325      ought to be handled by writing conditional output routines in
 326      those patterns.
 327
 328      If this macro is not defined, it is equivalent to a null statement.
 329
 330 `FINAL_PRESCAN_LABEL'
 331      If defined, `FINAL_PRESCAN_INSN' will be called on each
 332      `CODE_LABEL'.  In that case, OPVEC will be a null pointer and
 333      NOPERANDS will be zero.
 334
 335 `PRINT_OPERAND (STREAM, X, CODE)'
 336      A C compound statement to output to stdio stream STREAM the
 337      assembler syntax for an instruction operand X.  X is an RTL
 338      expression.
 339
 340      CODE is a value that can be used to specify one of several ways of
 341      printing the operand.  It is used when identical operands must be
 342      printed differently depending on the context.  CODE comes from the
 343      `%' specification that was used to request printing of the
 344      operand.  If the specification was just `%DIGIT' then CODE is 0;
 345      if the specification was `%LTR DIGIT' then CODE is the ASCII code
 346      for LTR.
 347
 348      If X is a register, this macro should print the register's name.
 349      The names can be found in an array `reg_names' whose type is `char
 350      *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.
 351
 352      When the machine description has a specification `%PUNCT' (a `%'
 353      followed by a punctuation character), this macro is called with a
 354      null pointer for X and the punctuation character for CODE.
 355
 356 `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
 357      A C expression which evaluates to true if CODE is a valid
 358      punctuation character for use in the `PRINT_OPERAND' macro.  If
 359      `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
 360      punctuation characters (except for the standard one, `%') are used
 361      in this way.
 362
 363 `PRINT_OPERAND_ADDRESS (STREAM, X)'
 364      A C compound statement to output to stdio stream STREAM the
 365      assembler syntax for an instruction operand that is a memory
 366      reference whose address is X.  X is an RTL expression.
 367
 368      On some machines, the syntax for a symbolic address depends on the
 369      section that the address refers to.  On these machines, define the
 370      macro `ENCODE_SECTION_INFO' to store the information into the
 371      `symbol_ref', and then check for it here.  *Note Assembler
 372      Format::.
 373
 374 `DBR_OUTPUT_SEQEND(FILE)'
 375      A C statement, to be executed after all slot-filler instructions
 376      have been output.  If necessary, call `dbr_sequence_length' to
 377      determine the number of slots filled in a sequence (zero if not
 378      currently outputting a sequence), to decide how many no-ops to
 379      output, or whatever.
 380
 381      Don't define this macro if it has nothing to do, but it is helpful
 382      in reading assembly output if the extent of the delay sequence is
 383      made explicit (e.g. with white space).
 384
 385      Note that output routines for instructions with delay slots must be
 386      prepared to deal with not being output as part of a sequence (i.e.
 387      when the scheduling pass is not run, or when no slot fillers could
 388      be found.)  The variable `final_sequence' is null when not
 389      processing a sequence, otherwise it contains the `sequence' rtx
 390      being output.
 391
 392 `REGISTER_PREFIX'
 393 `LOCAL_LABEL_PREFIX'
 394 `USER_LABEL_PREFIX'
 395 `IMMEDIATE_PREFIX'
 396      If defined, C string expressions to be used for the `%R', `%L',
 397      `%U', and `%I' options of `asm_fprintf' (see `final.c').  These
 398      are useful when a single `md' file must support multiple assembler
 399      formats.  In that case, the various `tm.h' files can define these
 400      macros differently.
 401
 402 `ASSEMBLER_DIALECT'
 403      If your target supports multiple dialects of assembler language
 404      (such as different opcodes), define this macro as a C expression
 405      that gives the numeric index of the assembler language dialect to
 406      use, with zero as the first variant.
 407
 408      If this macro is defined, you may use constructs of the form
 409      `{option0|option1|option2...}' in the output templates of patterns
 410      (*note Output Template::.) or in the first argument of
 411      `asm_fprintf'.  This construct outputs `option0', `option1' or
 412      `option2', etc., if the value of `ASSEMBLER_DIALECT' is zero, one
 413      or two, etc.  Any special characters within these strings retain
 414      their usual meaning.
 415
 416      If you do not define this macro, the characters `{', `|' and `}'
 417      do not have any special meaning when used in templates or operands
 418      to `asm_fprintf'.
 419
 420      Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX',
 421      `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the
 422      variations in assemble language syntax with that mechanism.  Define
 423      `ASSEMBLER_DIALECT' and use the `{option0|option1}' syntax if the
 424      syntax variant are larger and involve such things as different
 425      opcodes or operand order.
 426
 427 `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
 428      A C expression to output to STREAM some assembler code which will
 429      push hard register number REGNO onto the stack.  The code need not
 430      be optimal, since this macro is used only when profiling.
 431
 432 `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
 433      A C expression to output to STREAM some assembler code which will
 434      pop hard register number REGNO off of the stack.  The code need
 435      not be optimal, since this macro is used only when profiling.
 436
 437 \1f
 438 File: gcc.info,  Node: Dispatch Tables,  Next: Exception Region Output,  Prev: Instruction Output,  Up: Assembler Format
 439
 440 Output of Dispatch Tables
 441 -------------------------
 442
 443    This concerns dispatch tables.
 444
 445 `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
 446      A C statement to output to the stdio stream STREAM an assembler
 447      pseudo-instruction to generate a difference between two labels.
 448      VALUE and REL are the numbers of two internal labels.  The
 449      definitions of these labels are output using
 450      `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same
 451      way here.  For example,
 452
 453           fprintf (STREAM, "\t.word L%d-L%d\n",
 454                    VALUE, REL)
 455
 456      You must provide this macro on machines where the addresses in a
 457      dispatch table are relative to the table's own address.  If
 458      defined, GNU CC will also use this macro on all machines when
 459      producing PIC.
 460
 461 `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
 462      This macro should be provided on machines where the addresses in a
 463      dispatch table are absolute.
 464
 465      The definition should be a C statement to output to the stdio
 466      stream STREAM an assembler pseudo-instruction to generate a
 467      reference to a label.  VALUE is the number of an internal label
 468      whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'.  For
 469      example,
 470
 471           fprintf (STREAM, "\t.word L%d\n", VALUE)
 472
 473 `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
 474      Define this if the label before a jump-table needs to be output
 475      specially.  The first three arguments are the same as for
 476      `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
 477      which follows (a `jump_insn' containing an `addr_vec' or
 478      `addr_diff_vec').
 479
 480      This feature is used on system V to output a `swbeg' statement for
 481      the table.
 482
 483      If this macro is not defined, these labels are output with
 484      `ASM_OUTPUT_INTERNAL_LABEL'.
 485
 486 `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
 487      Define this if something special must be output at the end of a
 488      jump-table.  The definition should be a C statement to be executed
 489      after the assembler code for the table is written.  It should write
 490      the appropriate code to stdio stream STREAM.  The argument TABLE
 491      is the jump-table insn, and NUM is the label-number of the
 492      preceding label.
 493
 494      If this macro is not defined, nothing special is output at the end
 495      of the jump-table.
 496
 497 \1f
 498 File: gcc.info,  Node: Exception Region Output,  Next: Alignment Output,  Prev: Dispatch Tables,  Up: Assembler Format
 499
 500 Assembler Commands for Exception Regions
 501 ----------------------------------------
 502
 503    This describes commands marking the start and the end of an exception
 504 region.
 505
 506 `ASM_OUTPUT_EH_REGION_BEG ()'
 507      A C expression to output text to mark the start of an exception
 508      region.
 509
 510      This macro need not be defined on most platforms.
 511
 512 `ASM_OUTPUT_EH_REGION_END ()'
 513      A C expression to output text to mark the end of an exception
 514      region.
 515
 516      This macro need not be defined on most platforms.
 517
 518 `EXCEPTION_SECTION ()'
 519      A C expression to switch to the section in which the main
 520      exception table is to be placed (*note Sections::.).  The default
 521      is a section named `.gcc_except_table' on machines that support
 522      named sections via `ASM_OUTPUT_SECTION_NAME', otherwise if `-fpic'
 523      or `-fPIC' is in effect, the `data_section', otherwise the
 524      `readonly_data_section'.
 525
 526 `EH_FRAME_SECTION_ASM_OP'
 527      If defined, a C string constant for the assembler operation to
 528      switch to the section for exception handling frame unwind
 529      information.  If not defined, GNU CC will provide a default
 530      definition if the target supports named sections.  `crtstuff.c'
 531      uses this macro to switch to the appropriate section.
 532
 533      You should define this symbol if your target supports DWARF 2 frame
 534      unwind information and the default definition does not work.
 535
 536 `OMIT_EH_TABLE ()'
 537      A C expression that is nonzero if the normal exception table output
 538      should be omitted.
 539
 540      This macro need not be defined on most platforms.
 541
 542 `EH_TABLE_LOOKUP ()'
 543      Alternate runtime support for looking up an exception at runtime
 544      and finding the associated handler, if the default method won't
 545      work.
 546
 547      This macro need not be defined on most platforms.
 548
 549 `DOESNT_NEED_UNWINDER'
 550      A C expression that decides whether or not the current function
 551      needs to have a function unwinder generated for it.  See the file
 552      `except.c' for details on when to define this, and how.
 553
 554 `MASK_RETURN_ADDR'
 555      An rtx used to mask the return address found via RETURN_ADDR_RTX,
 556      so that it does not contain any extraneous set bits in it.
 557
 558 `DWARF2_UNWIND_INFO'
 559      Define this macro to 0 if your target supports DWARF 2 frame unwind
 560      information, but it does not yet work with exception handling.
 561      Otherwise, if your target supports this information (if it defines
 562      `INCOMING_RETURN_ADDR_RTX' and either `UNALIGNED_INT_ASM_OP' or
 563      `OBJECT_FORMAT_ELF'), GCC will provide a default definition of 1.
 564
 565      If this macro is defined to 1, the DWARF 2 unwinder will be the
 566      default exception handling mechanism; otherwise, setjmp/longjmp
 567      will be used by default.
 568
 569      If this macro is defined to anything, the DWARF 2 unwinder will be
 570      used instead of inline unwinders and __unwind_function in the
 571      non-setjmp case.
 572
 573 \1f
 574 File: gcc.info,  Node: Alignment Output,  Prev: Exception Region Output,  Up: Assembler Format
 575
 576 Assembler Commands for Alignment
 577 --------------------------------
 578
 579    This describes commands for alignment.
 580
 581 `ASM_OUTPUT_ALIGN_CODE (FILE)'
 582      A C expression to output text to align the location counter in the
 583      way that is desirable at a point in the code that is reached only
 584      by jumping.
 585
 586      This macro need not be defined if you don't want any special
 587      alignment to be done at such a time.  Most machine descriptions do
 588      not currently define the macro.
 589
 590 `ASM_OUTPUT_LOOP_ALIGN (FILE)'
 591      A C expression to output text to align the location counter in the
 592      way that is desirable at the beginning of a loop.
 593
 594      This macro need not be defined if you don't want any special
 595      alignment to be done at such a time.  Most machine descriptions do
 596      not currently define the macro.
 597
 598 `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
 599      A C statement to output to the stdio stream STREAM an assembler
 600      instruction to advance the location counter by NBYTES bytes.
 601      Those bytes should be zero when loaded.  NBYTES will be a C
 602      expression of type `int'.
 603
 604 `ASM_NO_SKIP_IN_TEXT'
 605      Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
 606      text section because it fails put zeros in the bytes that are
 607      skipped.  This is true on many Unix systems, where the pseudo-op
 608      to skip bytes produces no-op instructions rather than zeros when
 609      used in the text section.
 610
 611 `ASM_OUTPUT_ALIGN (STREAM, POWER)'
 612      A C statement to output to the stdio stream STREAM an assembler
 613      command to advance the location counter to a multiple of 2 to the
 614      POWER bytes.  POWER will be a C expression of type `int'.
 615
 616 \1f
 617 File: gcc.info,  Node: Debugging Info,  Next: Cross-compilation,  Prev: Assembler Format,  Up: Target Macros
 618
 619 Controlling Debugging Information Format
 620 ========================================
 621
 622    This describes how to specify debugging information.
 623
 624 * Menu:
 625
 626 * All Debuggers::      Macros that affect all debugging formats uniformly.
 627 * DBX Options::        Macros enabling specific options in DBX format.
 628 * DBX Hooks::          Hook macros for varying DBX format.
 629 * File Names and DBX:: Macros controlling output of file names in DBX format.
 630 * SDB and DWARF::      Macros for SDB (COFF) and DWARF formats.
 631
 632 \1f
 633 File: gcc.info,  Node: All Debuggers,  Next: DBX Options,  Up: Debugging Info
 634
 635 Macros Affecting All Debugging Formats
 636 --------------------------------------
 637
 638    These macros affect all debugging formats.
 639
 640 `DBX_REGISTER_NUMBER (REGNO)'
 641      A C expression that returns the DBX register number for the
 642      compiler register number REGNO.  In simple cases, the value of this
 643      expression may be REGNO itself.  But sometimes there are some
 644      registers that the compiler knows about and DBX does not, or vice
 645      versa.  In such cases, some register may need to have one number in
 646      the compiler and another for DBX.
 647
 648      If two registers have consecutive numbers inside GNU CC, and they
 649      can be used as a pair to hold a multiword value, then they *must*
 650      have consecutive numbers after renumbering with
 651      `DBX_REGISTER_NUMBER'.  Otherwise, debuggers will be unable to
 652      access such a pair, because they expect register pairs to be
 653      consecutive in their own numbering scheme.
 654
 655      If you find yourself defining `DBX_REGISTER_NUMBER' in way that
 656      does not preserve register pairs, then what you must do instead is
 657      redefine the actual register numbering scheme.
 658
 659 `DEBUGGER_AUTO_OFFSET (X)'
 660      A C expression that returns the integer offset value for an
 661      automatic variable having address X (an RTL expression).  The
 662      default computation assumes that X is based on the frame-pointer
 663      and gives the offset from the frame-pointer.  This is required for
 664      targets that produce debugging output for DBX or COFF-style
 665      debugging output for SDB and allow the frame-pointer to be
 666      eliminated when the `-g' options is used.
 667
 668 `DEBUGGER_ARG_OFFSET (OFFSET, X)'
 669      A C expression that returns the integer offset value for an
 670      argument having address X (an RTL expression).  The nominal offset
 671      is OFFSET.
 672
 673 `PREFERRED_DEBUGGING_TYPE'
 674      A C expression that returns the type of debugging output GNU CC
 675      produces when the user specifies `-g' or `-ggdb'.  Define this if
 676      you have arranged for GNU CC to support more than one format of
 677      debugging output.  Currently, the allowable values are `DBX_DEBUG',
 678      `SDB_DEBUG', `DWARF_DEBUG', `DWARF2_DEBUG', and `XCOFF_DEBUG'.
 679
 680      The value of this macro only affects the default debugging output;
 681      the user can always get a specific type of output by using
 682      `-gstabs', `-gcoff', `-gdwarf-1', `-gdwarf-2', or `-gxcoff'.
 683
 684 \1f
 685 File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
 686
 687 Specific Options for DBX Output
 688 -------------------------------
 689
 690    These are specific options for DBX output.
 691
 692 `DBX_DEBUGGING_INFO'
 693      Define this macro if GNU CC should produce debugging output for DBX
 694      in response to the `-g' option.
 695
 696 `XCOFF_DEBUGGING_INFO'
 697      Define this macro if GNU CC should produce XCOFF format debugging
 698      output in response to the `-g' option.  This is a variant of DBX
 699      format.
 700
 701 `DEFAULT_GDB_EXTENSIONS'
 702      Define this macro to control whether GNU CC should by default
 703      generate GDB's extended version of DBX debugging information
 704      (assuming DBX-format debugging information is enabled at all).  If
 705      you don't define the macro, the default is 1: always generate the
 706      extended information if there is any occasion to.
 707
 708 `DEBUG_SYMS_TEXT'
 709      Define this macro if all `.stabs' commands should be output while
 710      in the text section.
 711
 712 `ASM_STABS_OP'
 713      A C string constant naming the assembler pseudo op to use instead
 714      of `.stabs' to define an ordinary debugging symbol.  If you don't
 715      define this macro, `.stabs' is used.  This macro applies only to
 716      DBX debugging information format.
 717
 718 `ASM_STABD_OP'
 719      A C string constant naming the assembler pseudo op to use instead
 720      of `.stabd' to define a debugging symbol whose value is the current
 721      location.  If you don't define this macro, `.stabd' is used.  This
 722      macro applies only to DBX debugging information format.
 723
 724 `ASM_STABN_OP'
 725      A C string constant naming the assembler pseudo op to use instead
 726      of `.stabn' to define a debugging symbol with no name.  If you
 727      don't define this macro, `.stabn' is used.  This macro applies
 728      only to DBX debugging information format.
 729
 730 `DBX_NO_XREFS'
 731      Define this macro if DBX on your system does not support the
 732      construct `xsTAGNAME'.  On some systems, this construct is used to
 733      describe a forward reference to a structure named TAGNAME.  On
 734      other systems, this construct is not supported at all.
 735
 736 `DBX_CONTIN_LENGTH'
 737      A symbol name in DBX-format debugging information is normally
 738      continued (split into two separate `.stabs' directives) when it
 739      exceeds a certain length (by default, 80 characters).  On some
 740      operating systems, DBX requires this splitting; on others,
 741      splitting must not be done.  You can inhibit splitting by defining
 742      this macro with the value zero.  You can override the default
 743      splitting-length by defining this macro as an expression for the
 744      length you desire.
 745
 746 `DBX_CONTIN_CHAR'
 747      Normally continuation is indicated by adding a `\' character to
 748      the end of a `.stabs' string when a continuation follows.  To use
 749      a different character instead, define this macro as a character
 750      constant for the character you want to use.  Do not define this
 751      macro if backslash is correct for your system.
 752
 753 `DBX_STATIC_STAB_DATA_SECTION'
 754      Define this macro if it is necessary to go to the data section
 755      before outputting the `.stabs' pseudo-op for a non-global static
 756      variable.
 757
 758 `DBX_TYPE_DECL_STABS_CODE'
 759      The value to use in the "code" field of the `.stabs' directive for
 760      a typedef.  The default is `N_LSYM'.
 761
 762 `DBX_STATIC_CONST_VAR_CODE'
 763      The value to use in the "code" field of the `.stabs' directive for
 764      a static variable located in the text section.  DBX format does not
 765      provide any "right" way to do this.  The default is `N_FUN'.
 766
 767 `DBX_REGPARM_STABS_CODE'
 768      The value to use in the "code" field of the `.stabs' directive for
 769      a parameter passed in registers.  DBX format does not provide any
 770      "right" way to do this.  The default is `N_RSYM'.
 771
 772 `DBX_REGPARM_STABS_LETTER'
 773      The letter to use in DBX symbol data to identify a symbol as a
 774      parameter passed in registers.  DBX format does not customarily
 775      provide any way to do this.  The default is `'P''.
 776
 777 `DBX_MEMPARM_STABS_LETTER'
 778      The letter to use in DBX symbol data to identify a symbol as a
 779      stack parameter.  The default is `'p''.
 780
 781 `DBX_FUNCTION_FIRST'
 782      Define this macro if the DBX information for a function and its
 783      arguments should precede the assembler code for the function.
 784      Normally, in DBX format, the debugging information entirely
 785      follows the assembler code.
 786
 787 `DBX_LBRAC_FIRST'
 788      Define this macro if the `N_LBRAC' symbol for a block should
 789      precede the debugging information for variables and functions
 790      defined in that block.  Normally, in DBX format, the `N_LBRAC'
 791      symbol comes first.
 792
 793 `DBX_BLOCKS_FUNCTION_RELATIVE'
 794      Define this macro if the value of a symbol describing the scope of
 795      a block (`N_LBRAC' or `N_RBRAC') should be relative to the start
 796      of the enclosing function.  Normally, GNU C uses an absolute
 797      address.
 798
 799 `DBX_USE_BINCL'
 800      Define this macro if GNU C should generate `N_BINCL' and `N_EINCL'
 801      stabs for included header files, as on Sun systems.  This macro
 802      also directs GNU C to output a type number as a pair of a file
 803      number and a type number within the file.  Normally, GNU C does not
 804      generate `N_BINCL' or `N_EINCL' stabs, and it outputs a single
 805      number for a type number.
 806
 807 \1f
 808 File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
 809
 810 Open-Ended Hooks for DBX Format
 811 -------------------------------
 812
 813    These are hooks for DBX format.
 814
 815 `DBX_OUTPUT_LBRAC (STREAM, NAME)'
 816      Define this macro to say how to output to STREAM the debugging
 817      information for the start of a scope level for variable names.  The
 818      argument NAME is the name of an assembler symbol (for use with
 819      `assemble_name') whose value is the address where the scope begins.
 820
 821 `DBX_OUTPUT_RBRAC (STREAM, NAME)'
 822      Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
 823
 824 `DBX_OUTPUT_ENUM (STREAM, TYPE)'
 825      Define this macro if the target machine requires special handling
 826      to output an enumeration type.  The definition should be a C
 827      statement (sans semicolon) to output the appropriate information
 828      to STREAM for the type TYPE.
 829
 830 `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
 831      Define this macro if the target machine requires special output at
 832      the end of the debugging information for a function.  The
 833      definition should be a C statement (sans semicolon) to output the
 834      appropriate information to STREAM.  FUNCTION is the
 835      `FUNCTION_DECL' node for the function.
 836
 837 `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
 838      Define this macro if you need to control the order of output of the
 839      standard data types at the beginning of compilation.  The argument
 840      SYMS is a `tree' which is a chain of all the predefined global
 841      symbols, including names of data types.
 842
 843      Normally, DBX output starts with definitions of the types for
 844      integers and characters, followed by all the other predefined
 845      types of the particular language in no particular order.
 846
 847      On some machines, it is necessary to output different particular
 848      types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
 849      output those symbols in the necessary order.  Any predefined types
 850      that you don't explicitly output will be output afterward in no
 851      particular order.
 852
 853      Be careful not to define this macro so that it works only for C.
 854      There are no global variables to access most of the built-in
 855      types, because another language may have another set of types.
 856      The way to output a particular type is to look through SYMS to see
 857      if you can find it.  Here is an example:
 858
 859           {
 860             tree decl;
 861             for (decl = syms; decl; decl = TREE_CHAIN (decl))
 862               if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
 863                            "long int"))
 864                 dbxout_symbol (decl);
 865             ...
 866           }
 867
 868      This does nothing if the expected type does not exist.
 869
 870      See the function `init_decl_processing' in `c-decl.c' to find the
 871      names to use for all the built-in C types.
 872
 873      Here is another way of finding a particular type:
 874
 875           {
 876             tree decl;
 877             for (decl = syms; decl; decl = TREE_CHAIN (decl))
 878               if (TREE_CODE (decl) == TYPE_DECL
 879                   && (TREE_CODE (TREE_TYPE (decl))
 880                       == INTEGER_CST)
 881                   && TYPE_PRECISION (TREE_TYPE (decl)) == 16
 882                   && TYPE_UNSIGNED (TREE_TYPE (decl)))
 883           /* This must be `unsigned short'.  */
 884                 dbxout_symbol (decl);
 885             ...
 886           }
 887
 888 `NO_DBX_FUNCTION_END'
 889      Some stabs encapsulation formats (in particular ECOFF), cannot
 890      handle the `.stabs "",N_FUN,,0,0,Lscope-function-1' gdb dbx
 891      extention construct.  On those machines, define this macro to turn
 892      this feature off without disturbing the rest of the gdb extensions.
 893
 894 \1f
 895 File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
 896
 897 File Names in DBX Format
 898 ------------------------
 899
 900    This describes file names in DBX format.
 901
 902 `DBX_WORKING_DIRECTORY'
 903      Define this if DBX wants to have the current directory recorded in
 904      each object file.
 905
 906      Note that the working directory is always recorded if GDB
 907      extensions are enabled.
 908
 909 `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
 910      A C statement to output DBX debugging information to the stdio
 911      stream STREAM which indicates that file NAME is the main source
 912      file--the file specified as the input file for compilation.  This
 913      macro is called only once, at the beginning of compilation.
 914
 915      This macro need not be defined if the standard form of output for
 916      DBX debugging information is appropriate.
 917
 918 `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
 919      A C statement to output DBX debugging information to the stdio
 920      stream STREAM which indicates that the current directory during
 921      compilation is named NAME.
 922
 923      This macro need not be defined if the standard form of output for
 924      DBX debugging information is appropriate.
 925
 926 `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
 927      A C statement to output DBX debugging information at the end of
 928      compilation of the main source file NAME.
 929
 930      If you don't define this macro, nothing special is output at the
 931      end of compilation, which is correct for most machines.
 932
 933 `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
 934      A C statement to output DBX debugging information to the stdio
 935      stream STREAM which indicates that file NAME is the current source
 936      file.  This output is generated each time input shifts to a
 937      different source file as a result of `#include', the end of an
 938      included file, or a `#line' command.
 939
 940      This macro need not be defined if the standard form of output for
 941      DBX debugging information is appropriate.
 942
 943 \1f
 944 File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
 945
 946 Macros for SDB and DWARF Output
 947 -------------------------------
 948
 949    Here are macros for SDB and DWARF output.
 950
 951 `SDB_DEBUGGING_INFO'
 952      Define this macro if GNU CC should produce COFF-style debugging
 953      output for SDB in response to the `-g' option.
 954
 955 `DWARF_DEBUGGING_INFO'
 956      Define this macro if GNU CC should produce dwarf format debugging
 957      output in response to the `-g' option.
 958
 959 `DWARF2_DEBUGGING_INFO'
 960      Define this macro if GNU CC should produce dwarf version 2 format
 961      debugging output in response to the `-g' option.
 962
 963      To support optional call frame debugging information, you must also
 964      define `INCOMING_RETURN_ADDR_RTX' and either set
 965      `RTX_FRAME_RELATED_P' on the prologue insns if you use RTL for the
 966      prologue, or call `dwarf2out_def_cfa' and `dwarf2out_reg_save' as
 967      appropriate from `FUNCTION_PROLOGUE' if you don't.
 968
 969 `PUT_SDB_...'
 970      Define these macros to override the assembler syntax for the
 971      special SDB assembler directives.  See `sdbout.c' for a list of
 972      these macros and their arguments.  If the standard syntax is used,
 973      you need not define them yourself.
 974
 975 `SDB_DELIM'
 976      Some assemblers do not support a semicolon as a delimiter, even
 977      between SDB assembler directives.  In that case, define this macro
 978      to be the delimiter to use (usually `\n').  It is not necessary to
 979      define a new set of `PUT_SDB_OP' macros if this is the only change
 980      required.
 981
 982 `SDB_GENERATE_FAKE'
 983      Define this macro to override the usual method of constructing a
 984      dummy name for anonymous structure and union types.  See
 985      `sdbout.c' for more information.
 986
 987 `SDB_ALLOW_UNKNOWN_REFERENCES'
 988      Define this macro to allow references to unknown structure, union,
 989      or enumeration tags to be emitted.  Standard COFF does not allow
 990      handling of unknown references, MIPS ECOFF has support for it.
 991
 992 `SDB_ALLOW_FORWARD_REFERENCES'
 993      Define this macro to allow references to structure, union, or
 994      enumeration tags that have not yet been seen to be handled.  Some
 995      assemblers choke if forward tags are used, while some require it.
 996
 997 \1f
 998 File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Debugging Info,  Up: Target Macros
 999
1000 Cross Compilation and Floating Point
1001 ====================================
1002
1003    While all modern machines use 2's complement representation for
1004 integers, there are a variety of representations for floating point
1005 numbers.  This means that in a cross-compiler the representation of
1006 floating point numbers in the compiled program may be different from
1007 that used in the machine doing the compilation.
1008
1009    Because different representation systems may offer different amounts
1010 of range and precision, the cross compiler cannot safely use the host
1011 machine's floating point arithmetic.  Therefore, floating point
1012 constants must be represented in the target machine's format.  This
1013 means that the cross compiler cannot use `atof' to parse a floating
1014 point constant; it must have its own special routine to use instead.
1015 Also, constant folding must emulate the target machine's arithmetic (or
1016 must not be done at all).
1017
1018    The macros in the following table should be defined only if you are
1019 cross compiling between different floating point formats.
1020
1021    Otherwise, don't define them.  Then default definitions will be set
1022 up which use `double' as the data type, `==' to test for equality, etc.
1023
1024    You don't need to worry about how many times you use an operand of
1025 any of these macros.  The compiler never uses operands which have side
1026 effects.
1027
1028 `REAL_VALUE_TYPE'
1029      A macro for the C data type to be used to hold a floating point
1030      value in the target machine's format.  Typically this would be a
1031      `struct' containing an array of `int'.
1032
1033 `REAL_VALUES_EQUAL (X, Y)'
1034      A macro for a C expression which compares for equality the two
1035      values, X and Y, both of type `REAL_VALUE_TYPE'.
1036
1037 `REAL_VALUES_LESS (X, Y)'
1038      A macro for a C expression which tests whether X is less than Y,
1039      both values being of type `REAL_VALUE_TYPE' and interpreted as
1040      floating point numbers in the target machine's representation.
1041
1042 `REAL_VALUE_LDEXP (X, SCALE)'
1043      A macro for a C expression which performs the standard library
1044      function `ldexp', but using the target machine's floating point
1045      representation.  Both X and the value of the expression have type
1046      `REAL_VALUE_TYPE'.  The second argument, SCALE, is an integer.
1047
1048 `REAL_VALUE_FIX (X)'
1049      A macro whose definition is a C expression to convert the
1050      target-machine floating point value X to a signed integer.  X has
1051      type `REAL_VALUE_TYPE'.
1052
1053 `REAL_VALUE_UNSIGNED_FIX (X)'
1054      A macro whose definition is a C expression to convert the
1055      target-machine floating point value X to an unsigned integer.  X
1056      has type `REAL_VALUE_TYPE'.
1057
1058 `REAL_VALUE_RNDZINT (X)'
1059      A macro whose definition is a C expression to round the
1060      target-machine floating point value X towards zero to an integer
1061      value (but still as a floating point number).  X has type
1062      `REAL_VALUE_TYPE', and so does the value.
1063
1064 `REAL_VALUE_UNSIGNED_RNDZINT (X)'
1065      A macro whose definition is a C expression to round the
1066      target-machine floating point value X towards zero to an unsigned
1067      integer value (but still represented as a floating point number).
1068      X has type `REAL_VALUE_TYPE', and so does the value.
1069
1070 `REAL_VALUE_ATOF (STRING, MODE)'
1071      A macro for a C expression which converts STRING, an expression of
1072      type `char *', into a floating point number in the target machine's
1073      representation for mode MODE.  The value has type
1074      `REAL_VALUE_TYPE'.
1075
1076 `REAL_INFINITY'
1077      Define this macro if infinity is a possible floating point value,
1078      and therefore division by 0 is legitimate.
1079
1080 `REAL_VALUE_ISINF (X)'
1081      A macro for a C expression which determines whether X, a floating
1082      point value, is infinity.  The value has type `int'.  By default,
1083      this is defined to call `isinf'.
1084
1085 `REAL_VALUE_ISNAN (X)'
1086      A macro for a C expression which determines whether X, a floating
1087      point value, is a "nan" (not-a-number).  The value has type `int'.
1088      By default, this is defined to call `isnan'.
1089
1090    Define the following additional macros if you want to make floating
1091 point constant folding work while cross compiling.  If you don't define
1092 them, cross compilation is still possible, but constant folding will
1093 not happen for floating point values.
1094
1095 `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
1096      A macro for a C statement which calculates an arithmetic operation
1097      of the two floating point values X and Y, both of type
1098      `REAL_VALUE_TYPE' in the target machine's representation, to
1099      produce a result of the same type and representation which is
1100      stored in OUTPUT (which will be a variable).
1101
1102      The operation to be performed is specified by CODE, a tree code
1103      which will always be one of the following: `PLUS_EXPR',
1104      `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
1105
1106      The expansion of this macro is responsible for checking for
1107      overflow.  If overflow happens, the macro expansion should execute
1108      the statement `return 0;', which indicates the inability to
1109      perform the arithmetic operation requested.
1110
1111 `REAL_VALUE_NEGATE (X)'
1112      A macro for a C expression which returns the negative of the
1113      floating point value X.  Both X and the value of the expression
1114      have type `REAL_VALUE_TYPE' and are in the target machine's
1115      floating point representation.
1116
1117      There is no way for this macro to report overflow, since overflow
1118      can't happen in the negation operation.
1119
1120 `REAL_VALUE_TRUNCATE (MODE, X)'
1121      A macro for a C expression which converts the floating point value
1122      X to mode MODE.
1123
1124      Both X and the value of the expression are in the target machine's
1125      floating point representation and have type `REAL_VALUE_TYPE'.
1126      However, the value should have an appropriate bit pattern to be
1127      output properly as a floating constant whose precision accords
1128      with mode MODE.
1129
1130      There is no way for this macro to report overflow.
1131
1132 `REAL_VALUE_TO_INT (LOW, HIGH, X)'
1133      A macro for a C expression which converts a floating point value X
1134      into a double-precision integer which is then stored into LOW and
1135      HIGH, two variables of type INT.
1136
1137 `REAL_VALUE_FROM_INT (X, LOW, HIGH, MODE)'
1138      A macro for a C expression which converts a double-precision
1139      integer found in LOW and HIGH, two variables of type INT, into a
1140      floating point value which is then stored into X.  The value is in
1141      the target machine's representation for mode MODE and has the type
1142      `REAL_VALUE_TYPE'.
1143