home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / gcc / gcc.info-22 (.txt) < prev    next >
GNU Info File  |  1995-06-16  |  50KB  |  881 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.55 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  5. Boston, MA 02111-1307 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software
  7. Foundation, Inc.
  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.    Permission is granted to copy and distribute modified versions of
  12. this manual under the conditions for verbatim copying, provided also
  13. that the sections entitled "GNU General Public License," "Funding for
  14. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  15. included exactly as in the original, and provided that the entire
  16. resulting derived work is distributed under the terms of a permission
  17. notice identical to this one.
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the above conditions for modified
  20. versions, except that the sections entitled "GNU General Public
  21. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  22. `Look And Feel'", and this permission notice, may be included in
  23. translations approved by the Free Software Foundation instead of in the
  24. original English.
  25. File: gcc.info,  Node: Library Calls,  Next: Addressing Modes,  Prev: Trampolines,  Up: Target Macros
  26. Implicit Calls to Library Routines
  27. ==================================
  28.    Here is an explanation of implicit calls to library routines.
  29. `MULSI3_LIBCALL'
  30.      A C string constant giving the name of the function to call for
  31.      multiplication of one signed full-word by another.  If you do not
  32.      define this macro, the default name is used, which is `__mulsi3',
  33.      a function defined in `libgcc.a'.
  34. `DIVSI3_LIBCALL'
  35.      A C string constant giving the name of the function to call for
  36.      division of one signed full-word by another.  If you do not define
  37.      this macro, the default name is used, which is `__divsi3', a
  38.      function defined in `libgcc.a'.
  39. `UDIVSI3_LIBCALL'
  40.      A C string constant giving the name of the function to call for
  41.      division of one unsigned full-word by another.  If you do not
  42.      define this macro, the default name is used, which is `__udivsi3',
  43.      a function defined in `libgcc.a'.
  44. `MODSI3_LIBCALL'
  45.      A C string constant giving the name of the function to call for the
  46.      remainder in division of one signed full-word by another.  If you
  47.      do not define this macro, the default name is used, which is
  48.      `__modsi3', a function defined in `libgcc.a'.
  49. `UMODSI3_LIBCALL'
  50.      A C string constant giving the name of the function to call for the
  51.      remainder in division of one unsigned full-word by another.  If
  52.      you do not define this macro, the default name is used, which is
  53.      `__umodsi3', a function defined in `libgcc.a'.
  54. `MULDI3_LIBCALL'
  55.      A C string constant giving the name of the function to call for
  56.      multiplication of one signed double-word by another.  If you do not
  57.      define this macro, the default name is used, which is `__muldi3',
  58.      a function defined in `libgcc.a'.
  59. `DIVDI3_LIBCALL'
  60.      A C string constant giving the name of the function to call for
  61.      division of one signed double-word by another.  If you do not
  62.      define this macro, the default name is used, which is `__divdi3', a
  63.      function defined in `libgcc.a'.
  64. `UDIVDI3_LIBCALL'
  65.      A C string constant giving the name of the function to call for
  66.      division of one unsigned full-word by another.  If you do not
  67.      define this macro, the default name is used, which is `__udivdi3',
  68.      a function defined in `libgcc.a'.
  69. `MODDI3_LIBCALL'
  70.      A C string constant giving the name of the function to call for the
  71.      remainder in division of one signed double-word by another.  If
  72.      you do not define this macro, the default name is used, which is
  73.      `__moddi3', a function defined in `libgcc.a'.
  74. `UMODDI3_LIBCALL'
  75.      A C string constant giving the name of the function to call for the
  76.      remainder in division of one unsigned full-word by another.  If
  77.      you do not define this macro, the default name is used, which is
  78.      `__umoddi3', a function defined in `libgcc.a'.
  79. `INIT_TARGET_OPTABS'
  80.      Define this macro as a C statement that declares additional library
  81.      routines renames existing ones. `init_optabs' calls this macro
  82.      after initializing all the normal library routines.
  83. `TARGET_EDOM'
  84.      The value of `EDOM' on the target machine, as a C integer constant
  85.      expression.  If you don't define this macro, GNU CC does not
  86.      attempt to deposit the value of `EDOM' into `errno' directly.
  87.      Look in `/usr/include/errno.h' to find the value of `EDOM' on your
  88.      system.
  89.      If you do not define `TARGET_EDOM', then compiled code reports
  90.      domain errors by calling the library function and letting it
  91.      report the error.  If mathematical functions on your system use
  92.      `matherr' when there is an error, then you should leave
  93.      `TARGET_EDOM' undefined so that `matherr' is used normally.
  94. `GEN_ERRNO_RTX'
  95.      Define this macro as a C expression to create an rtl expression
  96.      that refers to the global "variable" `errno'.  (On certain systems,
  97.      `errno' may not actually be a variable.)  If you don't define this
  98.      macro, a reasonable default is used.
  99. `TARGET_MEM_FUNCTIONS'
  100.      Define this macro if GNU CC should generate calls to the System V
  101.      (and ANSI C) library functions `memcpy' and `memset' rather than
  102.      the BSD functions `bcopy' and `bzero'.
  103. `LIBGCC_NEEDS_DOUBLE'
  104.      Define this macro if only `float' arguments cannot be passed to
  105.      library routines (so they must be converted to `double').  This
  106.      macro affects both how library calls are generated and how the
  107.      library routines in `libgcc1.c' accept their arguments.  It is
  108.      useful on machines where floating and fixed point arguments are
  109.      passed differently, such as the i860.
  110. `FLOAT_ARG_TYPE'
  111.      Define this macro to override the type used by the library
  112.      routines to pick up arguments of type `float'.  (By default, they
  113.      use a union of `float' and `int'.)
  114.      The obvious choice would be `float'--but that won't work with
  115.      traditional C compilers that expect all arguments declared as
  116.      `float' to arrive as `double'.  To avoid this conversion, the
  117.      library routines ask for the value as some other type and then
  118.      treat it as a `float'.
  119.      On some systems, no other type will work for this.  For these
  120.      systems, you must use `LIBGCC_NEEDS_DOUBLE' instead, to force
  121.      conversion of the values `double' before they are passed.
  122. `FLOATIFY (PASSED-VALUE)'
  123.      Define this macro to override the way library routines redesignate
  124.      a `float' argument as a `float' instead of the type it was passed
  125.      as.  The default is an expression which takes the `float' field of
  126.      the union.
  127. `FLOAT_VALUE_TYPE'
  128.      Define this macro to override the type used by the library
  129.      routines to return values that ought to have type `float'.  (By
  130.      default, they use `int'.)
  131.      The obvious choice would be `float'--but that won't work with
  132.      traditional C compilers gratuitously convert values declared as
  133.      `float' into `double'.
  134. `INTIFY (FLOAT-VALUE)'
  135.      Define this macro to override the way the value of a
  136.      `float'-returning library routine should be packaged in order to
  137.      return it.  These functions are actually declared to return type
  138.      `FLOAT_VALUE_TYPE' (normally `int').
  139.      These values can't be returned as type `float' because traditional
  140.      C compilers would gratuitously convert the value to a `double'.
  141.      A local variable named `intify' is always available when the macro
  142.      `INTIFY' is used.  It is a union of a `float' field named `f' and
  143.      a field named `i' whose type is `FLOAT_VALUE_TYPE' or `int'.
  144.      If you don't define this macro, the default definition works by
  145.      copying the value through that union.
  146. `nongcc_SI_type'
  147.      Define this macro as the name of the data type corresponding to
  148.      `SImode' in the system's own C compiler.
  149.      You need not define this macro if that type is `long int', as it
  150.      usually is.
  151. `nongcc_word_type'
  152.      Define this macro as the name of the data type corresponding to the
  153.      word_mode in the system's own C compiler.
  154.      You need not define this macro if that type is `long int', as it
  155.      usually is.
  156. `perform_...'
  157.      Define these macros to supply explicit C statements to carry out
  158.      various arithmetic operations on types `float' and `double' in the
  159.      library routines in `libgcc1.c'.  See that file for a full list of
  160.      these macros and their arguments.
  161.      On most machines, you don't need to define any of these macros,
  162.      because the C compiler that comes with the system takes care of
  163.      doing them.
  164. `NEXT_OBJC_RUNTIME'
  165.      Define this macro to generate code for Objective C message sending
  166.      using the calling convention of the NeXT system.  This calling
  167.      convention involves passing the object, the selector and the
  168.      method arguments all at once to the method-lookup library function.
  169.      The default calling convention passes just the object and the
  170.      selector to the lookup function, which returns a pointer to the
  171.      method.
  172. File: gcc.info,  Node: Addressing Modes,  Next: Condition Code,  Prev: Library Calls,  Up: Target Macros
  173. Addressing Modes
  174. ================
  175.    This is about addressing modes.
  176. `HAVE_POST_INCREMENT'
  177.      Define this macro if the machine supports post-increment
  178.      addressing.
  179. `HAVE_PRE_INCREMENT'
  180. `HAVE_POST_DECREMENT'
  181. `HAVE_PRE_DECREMENT'
  182.      Similar for other kinds of addressing.
  183. `CONSTANT_ADDRESS_P (X)'
  184.      A C expression that is 1 if the RTX X is a constant which is a
  185.      valid address.  On most machines, this can be defined as
  186.      `CONSTANT_P (X)', but a few machines are more restrictive in which
  187.      constant addresses are supported.
  188.      `CONSTANT_P' accepts integer-values expressions whose values are
  189.      not explicitly known, such as `symbol_ref', `label_ref', and
  190.      `high' expressions and `const' arithmetic expressions, in addition
  191.      to `const_int' and `const_double' expressions.
  192. `MAX_REGS_PER_ADDRESS'
  193.      A number, the maximum number of registers that can appear in a
  194.      valid memory address.  Note that it is up to you to specify a
  195.      value equal to the maximum number that `GO_IF_LEGITIMATE_ADDRESS'
  196.      would ever accept.
  197. `GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)'
  198.      A C compound statement with a conditional `goto LABEL;' executed
  199.      if X (an RTX) is a legitimate memory address on the target machine
  200.      for a memory operand of mode MODE.
  201.      It usually pays to define several simpler macros to serve as
  202.      subroutines for this one.  Otherwise it may be too complicated to
  203.      understand.
  204.      This macro must exist in two variants: a strict variant and a
  205.      non-strict one.  The strict variant is used in the reload pass.  It
  206.      must be defined so that any pseudo-register that has not been
  207.      allocated a hard register is considered a memory reference.  In
  208.      contexts where some kind of register is required, a pseudo-register
  209.      with no hard register must be rejected.
  210.      The non-strict variant is used in other passes.  It must be
  211.      defined to accept all pseudo-registers in every context where some
  212.      kind of register is required.
  213.      Compiler source files that want to use the strict variant of this
  214.      macro define the macro `REG_OK_STRICT'.  You should use an `#ifdef
  215.      REG_OK_STRICT' conditional to define the strict variant in that
  216.      case and the non-strict variant otherwise.
  217.      Subroutines to check for acceptable registers for various purposes
  218.      (one for base registers, one for index registers, and so on) are
  219.      typically among the subroutines used to define
  220.      `GO_IF_LEGITIMATE_ADDRESS'.  Then only these subroutine macros
  221.      need have two variants; the higher levels of macros may be the
  222.      same whether strict or not.
  223.      Normally, constant addresses which are the sum of a `symbol_ref'
  224.      and an integer are stored inside a `const' RTX to mark them as
  225.      constant.  Therefore, there is no need to recognize such sums
  226.      specifically as legitimate addresses.  Normally you would simply
  227.      recognize any `const' as legitimate.
  228.      Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant
  229.      sums that are not marked with  `const'.  It assumes that a naked
  230.      `plus' indicates indexing.  If so, then you *must* reject such
  231.      naked constant sums as illegitimate addresses, so that none of
  232.      them will be given to `PRINT_OPERAND_ADDRESS'.
  233.      On some machines, whether a symbolic address is legitimate depends
  234.      on the section that the address refers to.  On these machines,
  235.      define the macro `ENCODE_SECTION_INFO' to store the information
  236.      into the `symbol_ref', and then check for it here.  When you see a
  237.      `const', you will have to look inside it to find the `symbol_ref'
  238.      in order to determine the section.  *Note Assembler Format::.
  239.      The best way to modify the name string is by adding text to the
  240.      beginning, with suitable punctuation to prevent any ambiguity.
  241.      Allocate the new name in `saveable_obstack'.  You will have to
  242.      modify `ASM_OUTPUT_LABELREF' to remove and decode the added text
  243.      and output the name accordingly, and define `STRIP_NAME_ENCODING'
  244.      to access the original name string.
  245.      You can check the information stored here into the `symbol_ref' in
  246.      the definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
  247.      `PRINT_OPERAND_ADDRESS'.
  248. `REG_OK_FOR_BASE_P (X)'
  249.      A C expression that is nonzero if X (assumed to be a `reg' RTX) is
  250.      valid for use as a base register.  For hard registers, it should
  251.      always accept those which the hardware permits and reject the
  252.      others.  Whether the macro accepts or rejects pseudo registers
  253.      must be controlled by `REG_OK_STRICT' as described above.  This
  254.      usually requires two variant definitions, of which `REG_OK_STRICT'
  255.      controls the one actually used.
  256. `REG_OK_FOR_INDEX_P (X)'
  257.      A C expression that is nonzero if X (assumed to be a `reg' RTX) is
  258.      valid for use as an index register.
  259.      The difference between an index register and a base register is
  260.      that the index register may be scaled.  If an address involves the
  261.      sum of two registers, neither one of them scaled, then either one
  262.      may be labeled the "base" and the other the "index"; but whichever
  263.      labeling is used must fit the machine's constraints of which
  264.      registers may serve in each capacity.  The compiler will try both
  265.      labelings, looking for one that is valid, and will reload one or
  266.      both registers only if neither labeling works.
  267. `LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)'
  268.      A C compound statement that attempts to replace X with a valid
  269.      memory address for an operand of mode MODE.  WIN will be a C
  270.      statement label elsewhere in the code; the macro definition may use
  271.           GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);
  272.      to avoid further processing if the address has become legitimate.
  273.      X will always be the result of a call to `break_out_memory_refs',
  274.      and OLDX will be the operand that was given to that function to
  275.      produce X.
  276.      The code generated by this macro should not alter the substructure
  277.      of X.  If it transforms X into a more legitimate form, it should
  278.      assign X (which will always be a C variable) a new value.
  279.      It is not necessary for this macro to come up with a legitimate
  280.      address.  The compiler has standard ways of doing so in all cases.
  281.      In fact, it is safe for this macro to do nothing.  But often a
  282.      machine-dependent strategy can generate better code.
  283. `GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)'
  284.      A C statement or compound statement with a conditional `goto
  285.      LABEL;' executed if memory address X (an RTX) can have different
  286.      meanings depending on the machine mode of the memory reference it
  287.      is used for or if the address is valid for some modes but not
  288.      others.
  289.      Autoincrement and autodecrement addresses typically have
  290.      mode-dependent effects because the amount of the increment or
  291.      decrement is the size of the operand being addressed.  Some
  292.      machines have other mode-dependent addresses.  Many RISC machines
  293.      have no mode-dependent addresses.
  294.      You may assume that ADDR is a valid address for the machine.
  295. `LEGITIMATE_CONSTANT_P (X)'
  296.      A C expression that is nonzero if X is a legitimate constant for
  297.      an immediate operand on the target machine.  You can assume that X
  298.      satisfies `CONSTANT_P', so you need not check this.  In fact, `1'
  299.      is a suitable definition for this macro on machines where anything
  300.      `CONSTANT_P' is valid.
  301. File: gcc.info,  Node: Condition Code,  Next: Costs,  Prev: Addressing Modes,  Up: Target Macros
  302. Condition Code Status
  303. =====================
  304.    This describes the condition code status.
  305.    The file `conditions.h' defines a variable `cc_status' to describe
  306. how the condition code was computed (in case the interpretation of the
  307. condition code depends on the instruction that it was set by).  This
  308. variable contains the RTL expressions on which the condition code is
  309. currently based, and several standard flags.
  310.    Sometimes additional machine-specific flags must be defined in the
  311. machine description header file.  It can also add additional
  312. machine-specific information by defining `CC_STATUS_MDEP'.
  313. `CC_STATUS_MDEP'
  314.      C code for a data type which is used for declaring the `mdep'
  315.      component of `cc_status'.  It defaults to `int'.
  316.      This macro is not used on machines that do not use `cc0'.
  317. `CC_STATUS_MDEP_INIT'
  318.      A C expression to initialize the `mdep' field to "empty".  The
  319.      default definition does nothing, since most machines don't use the
  320.      field anyway.  If you want to use the field, you should probably
  321.      define this macro to initialize it.
  322.      This macro is not used on machines that do not use `cc0'.
  323. `NOTICE_UPDATE_CC (EXP, INSN)'
  324.      A C compound statement to set the components of `cc_status'
  325.      appropriately for an insn INSN whose body is EXP.  It is this
  326.      macro's responsibility to recognize insns that set the condition
  327.      code as a byproduct of other activity as well as those that
  328.      explicitly set `(cc0)'.
  329.      This macro is not used on machines that do not use `cc0'.
  330.      If there are insns that do not set the condition code but do alter
  331.      other machine registers, this macro must check to see whether they
  332.      invalidate the expressions that the condition code is recorded as
  333.      reflecting.  For example, on the 68000, insns that store in address
  334.      registers do not set the condition code, which means that usually
  335.      `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns.
  336.      But suppose that the previous insn set the condition code based
  337.      on location `a4@(102)' and the current insn stores a new value in
  338.      `a4'.  Although the condition code is not changed by this, it will
  339.      no longer be true that it reflects the contents of `a4@(102)'.
  340.      Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this case
  341.      to say that nothing is known about the condition code value.
  342.      The definition of `NOTICE_UPDATE_CC' must be prepared to deal with
  343.      the results of peephole optimization: insns whose patterns are
  344.      `parallel' RTXs containing various `reg', `mem' or constants which
  345.      are just the operands.  The RTL structure of these insns is not
  346.      sufficient to indicate what the insns actually do.  What
  347.      `NOTICE_UPDATE_CC' should do when it sees one is just to run
  348.      `CC_STATUS_INIT'.
  349.      A possible definition of `NOTICE_UPDATE_CC' is to call a function
  350.      that looks at an attribute (*note Insn Attributes::.) named, for
  351.      example, `cc'.  This avoids having detailed information about
  352.      patterns in two places, the `md' file and in `NOTICE_UPDATE_CC'.
  353. `EXTRA_CC_MODES'
  354.      A list of names to be used for additional modes for condition code
  355.      values in registers (*note Jump Patterns::.).  These names are
  356.      added to `enum machine_mode' and all have class `MODE_CC'.  By
  357.      convention, they should start with `CC' and end with `mode'.
  358.      You should only define this macro if your machine does not use
  359.      `cc0' and only if additional modes are required.
  360. `EXTRA_CC_NAMES'
  361.      A list of C strings giving the names for the modes listed in
  362.      `EXTRA_CC_MODES'.  For example, the Sparc defines this macro and
  363.      `EXTRA_CC_MODES' as
  364.           #define EXTRA_CC_MODES CC_NOOVmode, CCFPmode, CCFPEmode
  365.           #define EXTRA_CC_NAMES "CC_NOOV", "CCFP", "CCFPE"
  366.      This macro is not required if `EXTRA_CC_MODES' is not defined.
  367. `SELECT_CC_MODE (OP, X, Y)'
  368.      Returns a mode from class `MODE_CC' to be used when comparison
  369.      operation code OP is applied to rtx X and Y.  For example, on the
  370.      Sparc, `SELECT_CC_MODE' is defined as (see *note Jump Patterns::.
  371.      for a description of the reason for this definition)
  372.           #define SELECT_CC_MODE(OP,X,Y) \
  373.             (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT          \
  374.              ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode)    \
  375.              : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS    \
  376.                  || GET_CODE (X) == NEG) \
  377.                 ? CC_NOOVmode : CCmode))
  378.      You need not define this macro if `EXTRA_CC_MODES' is not defined.
  379. `CANONICALIZE_COMPARISON (CODE, OP0, OP1)'
  380.      One some machines not all possible comparisons are defined, but
  381.      you can convert an invalid comparison into a valid one.  For
  382.      example, the Alpha does not have a `GT' comparison, but you can
  383.      use an `LT' comparison instead and swap the order of the operands.
  384.      On such machines, define this macro to be a C statement to do any
  385.      required conversions.  CODE is the initial comparison code and OP0
  386.      and OP1 are the left and right operands of the comparison,
  387.      respectively.  You should modify CODE, OP0, and OP1 as required.
  388.      GNU CC will not assume that the comparison resulting from this
  389.      macro is valid but will see if the resulting insn matches a
  390.      pattern in the `md' file.
  391.      You need not define this macro if it would never change the
  392.      comparison code or operands.
  393. `REVERSIBLE_CC_MODE (MODE)'
  394.      A C expression whose value is one if it is always safe to reverse a
  395.      comparison whose mode is MODE.  If `SELECT_CC_MODE' can ever
  396.      return MODE for a floating-point inequality comparison, then
  397.      `REVERSIBLE_CC_MODE (MODE)' must be zero.
  398.      You need not define this macro if it would always returns zero or
  399.      if the floating-point format is anything other than
  400.      `IEEE_FLOAT_FORMAT'.  For example, here is the definition used on
  401.      the Sparc, where floating-point inequality comparisons are always
  402.      given `CCFPEmode':
  403.           #define REVERSIBLE_CC_MODE(MODE)  ((MODE) != CCFPEmode)
  404. File: gcc.info,  Node: Costs,  Next: Sections,  Prev: Condition Code,  Up: Target Macros
  405. Describing Relative Costs of Operations
  406. =======================================
  407.    These macros let you describe the relative speed of various
  408. operations on the target machine.
  409. `CONST_COSTS (X, CODE, OUTER_CODE)'
  410.      A part of a C `switch' statement that describes the relative costs
  411.      of constant RTL expressions.  It must contain `case' labels for
  412.      expression codes `const_int', `const', `symbol_ref', `label_ref'
  413.      and `const_double'.  Each case must ultimately reach a `return'
  414.      statement to return the relative cost of the use of that kind of
  415.      constant value in an expression.  The cost may depend on the
  416.      precise value of the constant, which is available for examination
  417.      in X, and the rtx code of the expression in which it is contained,
  418.      found in OUTER_CODE.
  419.      CODE is the expression code--redundant, since it can be obtained
  420.      with `GET_CODE (X)'.
  421. `RTX_COSTS (X, CODE, OUTER_CODE)'
  422.      Like `CONST_COSTS' but applies to nonconstant RTL expressions.
  423.      This can be used, for example, to indicate how costly a multiply
  424.      instruction is.  In writing this macro, you can use the construct
  425.      `COSTS_N_INSNS (N)' to specify a cost equal to N fast
  426.      instructions.  OUTER_CODE is the code of the expression in which X
  427.      is contained.
  428.      This macro is optional; do not define it if the default cost
  429.      assumptions are adequate for the target machine.
  430. `ADDRESS_COST (ADDRESS)'
  431.      An expression giving the cost of an addressing mode that contains
  432.      ADDRESS.  If not defined, the cost is computed from the ADDRESS
  433.      expression and the `CONST_COSTS' values.
  434.      For most CISC machines, the default cost is a good approximation
  435.      of the true cost of the addressing mode.  However, on RISC
  436.      machines, all instructions normally have the same length and
  437.      execution time.  Hence all addresses will have equal costs.
  438.      In cases where more than one form of an address is known, the form
  439.      with the lowest cost will be used.  If multiple forms have the
  440.      same, lowest, cost, the one that is the most complex will be used.
  441.      For example, suppose an address that is equal to the sum of a
  442.      register and a constant is used twice in the same basic block.
  443.      When this macro is not defined, the address will be computed in a
  444.      register and memory references will be indirect through that
  445.      register.  On machines where the cost of the addressing mode
  446.      containing the sum is no higher than that of a simple indirect
  447.      reference, this will produce an additional instruction and
  448.      possibly require an additional register.  Proper specification of
  449.      this macro eliminates this overhead for such machines.
  450.      Similar use of this macro is made in strength reduction of loops.
  451.      ADDRESS need not be valid as an address.  In such a case, the cost
  452.      is not relevant and can be any value; invalid addresses need not be
  453.      assigned a different cost.
  454.      On machines where an address involving more than one register is as
  455.      cheap as an address computation involving only one register,
  456.      defining `ADDRESS_COST' to reflect this can cause two registers to
  457.      be live over a region of code where only one would have been if
  458.      `ADDRESS_COST' were not defined in that manner.  This effect should
  459.      be considered in the definition of this macro.  Equivalent costs
  460.      should probably only be given to addresses with different numbers
  461.      of registers on machines with lots of registers.
  462.      This macro will normally either not be defined or be defined as a
  463.      constant.
  464. `REGISTER_MOVE_COST (FROM, TO)'
  465.      A C expression for the cost of moving data from a register in class
  466.      FROM to one in class TO.  The classes are expressed using the
  467.      enumeration values such as `GENERAL_REGS'.  A value of 4 is the
  468.      default; other values are interpreted relative to that.
  469.      It is not required that the cost always equal 2 when FROM is the
  470.      same as TO; on some machines it is expensive to move between
  471.      registers if they are not general registers.
  472.      If reload sees an insn consisting of a single `set' between two
  473.      hard registers, and if `REGISTER_MOVE_COST' applied to their
  474.      classes returns a value of 2, reload does not check to ensure that
  475.      the constraints of the insn are met.  Setting a cost of other than
  476.      2 will allow reload to verify that the constraints are met.  You
  477.      should do this if the `movM' pattern's constraints do not allow
  478.      such copying.
  479. `MEMORY_MOVE_COST (M)'
  480.      A C expression for the cost of moving data of mode M between a
  481.      register and memory.  A value of 2 is the default; this cost is
  482.      relative to those in `REGISTER_MOVE_COST'.
  483.      If moving between registers and memory is more expensive than
  484.      between two registers, you should define this macro to express the
  485.      relative cost.
  486. `BRANCH_COST'
  487.      A C expression for the cost of a branch instruction.  A value of 1
  488.      is the default; other values are interpreted relative to that.
  489.    Here are additional macros which do not specify precise relative
  490. costs, but only that certain actions are more expensive than GNU CC
  491. would ordinarily expect.
  492. `SLOW_BYTE_ACCESS'
  493.      Define this macro as a C expression which is nonzero if accessing
  494.      less than a word of memory (i.e. a `char' or a `short') is no
  495.      faster than accessing a word of memory, i.e., if such access
  496.      require more than one instruction or if there is no difference in
  497.      cost between byte and (aligned) word loads.
  498.      When this macro is not defined, the compiler will access a field by
  499.      finding the smallest containing object; when it is defined, a
  500.      fullword load will be used if alignment permits.  Unless bytes
  501.      accesses are faster than word accesses, using word accesses is
  502.      preferable since it may eliminate subsequent memory access if
  503.      subsequent accesses occur to other fields in the same word of the
  504.      structure, but to different bytes.
  505. `SLOW_ZERO_EXTEND'
  506.      Define this macro if zero-extension (of a `char' or `short' to an
  507.      `int') can be done faster if the destination is a register that is
  508.      known to be zero.
  509.      If you define this macro, you must have instruction patterns that
  510.      recognize RTL structures like this:
  511.           (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)
  512.      and likewise for `HImode'.
  513. `SLOW_UNALIGNED_ACCESS'
  514.      Define this macro to be the value 1 if unaligned accesses have a
  515.      cost many times greater than aligned accesses, for example if they
  516.      are emulated in a trap handler.
  517.      When this macro is non-zero, the compiler will act as if
  518.      `STRICT_ALIGNMENT' were non-zero when generating code for block
  519.      moves.  This can cause significantly more instructions to be
  520.      produced.  Therefore, do not set this macro non-zero if unaligned
  521.      accesses only add a cycle or two to the time for a memory access.
  522.      If the value of this macro is always zero, it need not be defined.
  523. `DONT_REDUCE_ADDR'
  524.      Define this macro to inhibit strength reduction of memory
  525.      addresses.  (On some machines, such strength reduction seems to do
  526.      harm rather than good.)
  527. `MOVE_RATIO'
  528.      The number of scalar move insns which should be generated instead
  529.      of a string move insn or a library call.  Increasing the value
  530.      will always make code faster, but eventually incurs high cost in
  531.      increased code size.
  532.      If you don't define this, a reasonable default is used.
  533. `NO_FUNCTION_CSE'
  534.      Define this macro if it is as good or better to call a constant
  535.      function address than to call an address kept in a register.
  536. `NO_RECURSIVE_FUNCTION_CSE'
  537.      Define this macro if it is as good or better for a function to call
  538.      itself with an explicit address than to call an address kept in a
  539.      register.
  540. `ADJUST_COST (INSN, LINK, DEP_INSN, COST)'
  541.      A C statement (sans semicolon) to update the integer variable COST
  542.      based on the relationship between INSN that is dependent on
  543.      DEP_INSN through the dependence LINK.  The default is to make no
  544.      adjustment to COST.  This can be used for example to specify to
  545.      the scheduler that an output- or anti-dependence does not incur
  546.      the same cost as a data-dependence.
  547. File: gcc.info,  Node: Sections,  Next: PIC,  Prev: Costs,  Up: Target Macros
  548. Dividing the Output into Sections (Texts, Data, ...)
  549. ====================================================
  550.    An object file is divided into sections containing different types of
  551. data.  In the most common case, there are three sections: the "text
  552. section", which holds instructions and read-only data; the "data
  553. section", which holds initialized writable data; and the "bss section",
  554. which holds uninitialized data.  Some systems have other kinds of
  555. sections.
  556.    The compiler must tell the assembler when to switch sections.  These
  557. macros control what commands to output to tell the assembler this.  You
  558. can also define additional sections.
  559. `TEXT_SECTION_ASM_OP'
  560.      A C expression whose value is a string containing the assembler
  561.      operation that should precede instructions and read-only data.
  562.      Normally `".text"' is right.
  563. `DATA_SECTION_ASM_OP'
  564.      A C expression whose value is a string containing the assembler
  565.      operation to identify the following data as writable initialized
  566.      data.  Normally `".data"' is right.
  567. `SHARED_SECTION_ASM_OP'
  568.      if defined, a C expression whose value is a string containing the
  569.      assembler operation to identify the following data as shared data.
  570.      If not defined, `DATA_SECTION_ASM_OP' will be used.
  571. `INIT_SECTION_ASM_OP'
  572.      if defined, a C expression whose value is a string containing the
  573.      assembler operation to identify the following data as
  574.      initialization code.  If not defined, GNU CC will assume such a
  575.      section does not exist.
  576. `EXTRA_SECTIONS'
  577.      A list of names for sections other than the standard two, which are
  578.      `in_text' and `in_data'.  You need not define this macro on a
  579.      system with no other sections (that GCC needs to use).
  580. `EXTRA_SECTION_FUNCTIONS'
  581.      One or more functions to be defined in `varasm.c'.  These
  582.      functions should do jobs analogous to those of `text_section' and
  583.      `data_section', for your additional sections.  Do not define this
  584.      macro if you do not define `EXTRA_SECTIONS'.
  585. `READONLY_DATA_SECTION'
  586.      On most machines, read-only variables, constants, and jump tables
  587.      are placed in the text section.  If this is not the case on your
  588.      machine, this macro should be defined to be the name of a function
  589.      (either `data_section' or a function defined in `EXTRA_SECTIONS')
  590.      that switches to the section to be used for read-only items.
  591.      If these items should be placed in the text section, this macro
  592.      should not be defined.
  593. `SELECT_SECTION (EXP, RELOC)'
  594.      A C statement or statements to switch to the appropriate section
  595.      for output of EXP.  You can assume that EXP is either a `VAR_DECL'
  596.      node or a constant of some sort.  RELOC indicates whether the
  597.      initial value of EXP requires link-time relocations.  Select the
  598.      section by calling `text_section' or one of the alternatives for
  599.      other sections.
  600.      Do not define this macro if you put all read-only variables and
  601.      constants in the read-only data section (usually the text section).
  602. `SELECT_RTX_SECTION (MODE, RTX)'
  603.      A C statement or statements to switch to the appropriate section
  604.      for output of RTX in mode MODE.  You can assume that RTX is some
  605.      kind of constant in RTL.  The argument MODE is redundant except in
  606.      the case of a `const_int' rtx.  Select the section by calling
  607.      `text_section' or one of the alternatives for other sections.
  608.      Do not define this macro if you put all constants in the read-only
  609.      data section.
  610. `JUMP_TABLES_IN_TEXT_SECTION'
  611.      Define this macro if jump tables (for `tablejump' insns) should be
  612.      output in the text section, along with the assembler instructions.
  613.      Otherwise, the readonly data section is used.
  614.      This macro is irrelevant if there is no separate readonly data
  615.      section.
  616. `ENCODE_SECTION_INFO (DECL)'
  617.      Define this macro if references to a symbol must be treated
  618.      differently depending on something about the variable or function
  619.      named by the symbol (such as what section it is in).
  620.      The macro definition, if any, is executed immediately after the
  621.      rtl for DECL has been created and stored in `DECL_RTL (DECL)'.
  622.      The value of the rtl will be a `mem' whose address is a
  623.      `symbol_ref'.
  624.      The usual thing for this macro to do is to record a flag in the
  625.      `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
  626.      name string in the `symbol_ref' (if one bit is not enough
  627.      information).
  628. `STRIP_NAME_ENCODING (VAR, SYM_NAME)'
  629.      Decode SYM_NAME and store the real name part in VAR, sans the
  630.      characters that encode section info.  Define this macro if
  631.      `ENCODE_SECTION_INFO' alters the symbol's name string.
  632. File: gcc.info,  Node: PIC,  Next: Assembler Format,  Prev: Sections,  Up: Target Macros
  633. Position Independent Code
  634. =========================
  635.    This section describes macros that help implement generation of
  636. position independent code.  Simply defining these macros is not enough
  637. to generate valid PIC; you must also add support to the macros
  638. `GO_IF_LEGITIMATE_ADDRESS' and `PRINT_OPERAND_ADDRESS', as well as
  639. `LEGITIMIZE_ADDRESS'.  You must modify the definition of `movsi' to do
  640. something appropriate when the source operand contains a symbolic
  641. address.  You may also need to alter the handling of switch statements
  642. so that they use relative addresses.
  643. `PIC_OFFSET_TABLE_REGNUM'
  644.      The register number of the register used to address a table of
  645.      static data addresses in memory.  In some cases this register is
  646.      defined by a processor's "application binary interface" (ABI).
  647.      When this macro is defined, RTL is generated for this register
  648.      once, as with the stack pointer and frame pointer registers.  If
  649.      this macro is not defined, it is up to the machine-dependent files
  650.      to allocate such a register (if necessary).
  651. `PIC_OFFSET_TABLE_REG_CALL_CLOBBERED'
  652.      Define this macro if the register defined by
  653.      `PIC_OFFSET_TABLE_REGNUM' is clobbered by calls.  Do not define
  654.      this macro if `PPIC_OFFSET_TABLE_REGNUM' is not defined.
  655. `FINALIZE_PIC'
  656.      By generating position-independent code, when two different
  657.      programs (A and B) share a common library (libC.a), the text of
  658.      the library can be shared whether or not the library is linked at
  659.      the same address for both programs.  In some of these
  660.      environments, position-independent code requires not only the use
  661.      of different addressing modes, but also special code to enable the
  662.      use of these addressing modes.
  663.      The `FINALIZE_PIC' macro serves as a hook to emit these special
  664.      codes once the function is being compiled into assembly code, but
  665.      not before.  (It is not done before, because in the case of
  666.      compiling an inline function, it would lead to multiple PIC
  667.      prologues being included in functions which used inline functions
  668.      and were compiled to assembly language.)
  669. `LEGITIMATE_PIC_OPERAND_P (X)'
  670.      A C expression that is nonzero if X is a legitimate immediate
  671.      operand on the target machine when generating position independent
  672.      code.  You can assume that X satisfies `CONSTANT_P', so you need
  673.      not check this.  You can also assume FLAG_PIC is true, so you need
  674.      not check it either.  You need not define this macro if all
  675.      constants (including `SYMBOL_REF') can be immediate operands when
  676.      generating position independent code.
  677. File: gcc.info,  Node: Assembler Format,  Next: Debugging Info,  Prev: PIC,  Up: Target Macros
  678. Defining the Output Assembler Language
  679. ======================================
  680.    This section describes macros whose principal purpose is to describe
  681. how to write instructions in assembler language-rather than what the
  682. instructions do.
  683. * Menu:
  684. * File Framework::       Structural information for the assembler file.
  685. * Data Output::          Output of constants (numbers, strings, addresses).
  686. * Uninitialized Data::   Output of uninitialized variables.
  687. * Label Output::         Output and generation of labels.
  688. * Initialization::       General principles of initialization
  689.                and termination routines.
  690. * Macros for Initialization::
  691.              Specific macros that control the handling of
  692.                initialization and termination routines.
  693. * Instruction Output::   Output of actual instructions.
  694. * Dispatch Tables::      Output of jump tables.
  695. * Alignment Output::     Pseudo ops for alignment and skipping data.
  696. File: gcc.info,  Node: File Framework,  Next: Data Output,  Up: Assembler Format
  697. The Overall Framework of an Assembler File
  698. ------------------------------------------
  699.    This describes the overall framework of an assembler file.
  700. `ASM_FILE_START (STREAM)'
  701.      A C expression which outputs to the stdio stream STREAM some
  702.      appropriate text to go at the start of an assembler file.
  703.      Normally this macro is defined to output a line containing
  704.      `#NO_APP', which is a comment that has no effect on most
  705.      assemblers but tells the GNU assembler that it can save time by not
  706.      checking for certain assembler constructs.
  707.      On systems that use SDB, it is necessary to output certain
  708.      commands; see `attasm.h'.
  709. `ASM_FILE_END (STREAM)'
  710.      A C expression which outputs to the stdio stream STREAM some
  711.      appropriate text to go at the end of an assembler file.
  712.      If this macro is not defined, the default is to output nothing
  713.      special at the end of the file.  Most systems don't require any
  714.      definition.
  715.      On systems that use SDB, it is necessary to output certain
  716.      commands; see `attasm.h'.
  717. `ASM_IDENTIFY_GCC (FILE)'
  718.      A C statement to output assembler commands which will identify the
  719.      object file as having been compiled with GNU CC (or another GNU
  720.      compiler).
  721.      If you don't define this macro, the string `gcc_compiled.:' is
  722.      output.  This string is calculated to define a symbol which, on
  723.      BSD systems, will never be defined for any other reason.  GDB
  724.      checks for the presence of this symbol when reading the symbol
  725.      table of an executable.
  726.      On non-BSD systems, you must arrange communication with GDB in
  727.      some other fashion.  If GDB is not used on your system, you can
  728.      define this macro with an empty body.
  729. `ASM_COMMENT_START'
  730.      A C string constant describing how to begin a comment in the target
  731.      assembler language.  The compiler assumes that the comment will
  732.      end at the end of the line.
  733. `ASM_APP_ON'
  734.      A C string constant for text to be output before each `asm'
  735.      statement or group of consecutive ones.  Normally this is
  736.      `"#APP"', which is a comment that has no effect on most assemblers
  737.      but tells the GNU assembler that it must check the lines that
  738.      follow for all valid assembler constructs.
  739. `ASM_APP_OFF'
  740.      A C string constant for text to be output after each `asm'
  741.      statement or group of consecutive ones.  Normally this is
  742.      `"#NO_APP"', which tells the GNU assembler to resume making the
  743.      time-saving assumptions that are valid for ordinary compiler
  744.      output.
  745. `ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
  746.      A C statement to output COFF information or DWARF debugging
  747.      information which indicates that filename NAME is the current
  748.      source file to the stdio stream STREAM.
  749.      This macro need not be defined if the standard form of output for
  750.      the file format in use is appropriate.
  751. `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
  752.      A C statement to output DBX or SDB debugging information before
  753.      code for line number LINE of the current source file to the stdio
  754.      stream STREAM.
  755.      This macro need not be defined if the standard form of debugging
  756.      information for the debugger in use is appropriate.
  757. `ASM_OUTPUT_IDENT (STREAM, STRING)'
  758.      A C statement to output something to the assembler file to handle a
  759.      `#ident' directive containing the text STRING.  If this macro is
  760.      not defined, nothing is output for a `#ident' directive.
  761. `ASM_OUTPUT_SECTION_NAME (STREAM, DECL, NAME)'
  762.      A C statement to output something to the assembler file to switch
  763.      to section NAME for object DECL which is either a `FUNCTION_DECL',
  764.      a `VAR_DECL' or `NULL_TREE'.  Some target formats do not support
  765.      arbitrary sections.  Do not define this macro in such cases.
  766.      At present this macro is only used to support section attributes.
  767.      When this macro is undefined, section attributes are disabled.
  768. `OBJC_PROLOGUE'
  769.      A C statement to output any assembler statements which are
  770.      required to precede any Objective C object definitions or message
  771.      sending.  The statement is executed only when compiling an
  772.      Objective C program.
  773. File: gcc.info,  Node: Data Output,  Next: Uninitialized Data,  Prev: File Framework,  Up: Assembler Format
  774. Output of Data
  775. --------------
  776.    This describes data output.
  777. `ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
  778. `ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
  779. `ASM_OUTPUT_FLOAT (STREAM, VALUE)'
  780. `ASM_OUTPUT_THREE_QUARTER_FLOAT (STREAM, VALUE)'
  781. `ASM_OUTPUT_SHORT_FLOAT (STREAM, VALUE)'
  782. `ASM_OUTPUT_BYTE_FLOAT (STREAM, VALUE)'
  783.      A C statement to output to the stdio stream STREAM an assembler
  784.      instruction to assemble a floating-point constant of `TFmode',
  785.      `DFmode', `SFmode', `TQFmode', `HFmode', or `QFmode',
  786.      respectively, whose value is VALUE.  VALUE will be a C expression
  787.      of type `REAL_VALUE_TYPE'.  Macros such as
  788.      `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these
  789.      definitions.
  790. `ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)'
  791. `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
  792. `ASM_OUTPUT_INT (STREAM, EXP)'
  793. `ASM_OUTPUT_SHORT (STREAM, EXP)'
  794. `ASM_OUTPUT_CHAR (STREAM, EXP)'
  795.      A C statement to output to the stdio stream STREAM an assembler
  796.      instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes,
  797.      respectively, whose value is VALUE.  The argument EXP will be an
  798.      RTL expression which represents a constant value.  Use
  799.      `output_addr_const (STREAM, EXP)' to output this value as an
  800.      assembler expression.
  801.      For sizes larger than `UNITS_PER_WORD', if the action of a macro
  802.      would be identical to repeatedly calling the macro corresponding to
  803.      a size of `UNITS_PER_WORD', once for each word, you need not define
  804.      the macro.
  805. `ASM_OUTPUT_BYTE (STREAM, VALUE)'
  806.      A C statement to output to the stdio stream STREAM an assembler
  807.      instruction to assemble a single byte containing the number VALUE.
  808. `ASM_BYTE_OP'
  809.      A C string constant giving the pseudo-op to use for a sequence of
  810.      single-byte constants.  If this macro is not defined, the default
  811.      is `"byte"'.
  812. `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
  813.      A C statement to output to the stdio stream STREAM an assembler
  814.      instruction to assemble a string constant containing the LEN bytes
  815.      at PTR.  PTR will be a C expression of type `char *' and LEN a C
  816.      expression of type `int'.
  817.      If the assembler has a `.ascii' pseudo-op as found in the Berkeley
  818.      Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'.
  819. `ASM_OUTPUT_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)'
  820.      A C statement to output assembler commands to define the start of
  821.      the constant pool for a function.  FUNNAME is a string giving the
  822.      name of the function.  Should the return type of the function be
  823.      required, it can be obtained via FUNDECL.  SIZE is the size, in
  824.      bytes, of the constant pool that will be written immediately after
  825.      this call.
  826.      If no constant-pool prefix is required, the usual case, this macro
  827.      need not be defined.
  828. `ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)'
  829.      A C statement (with or without semicolon) to output a constant in
  830.      the constant pool, if it needs special treatment.  (This macro
  831.      need not do anything for RTL expressions that can be output
  832.      normally.)
  833.      The argument FILE is the standard I/O stream to output the
  834.      assembler code on.  X is the RTL expression for the constant to
  835.      output, and MODE is the machine mode (in case X is a `const_int').
  836.      ALIGN is the required alignment for the value X; you should
  837.      output an assembler directive to force this much alignment.
  838.      The argument LABELNO is a number to use in an internal label for
  839.      the address of this pool entry.  The definition of this macro is
  840.      responsible for outputting the label definition at the proper
  841.      place.  Here is how to do this:
  842.           ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO);
  843.      When you output a pool entry specially, you should end with a
  844.      `goto' to the label JUMPTO.  This will prevent the same pool entry
  845.      from being output a second time in the usual manner.
  846.      You need not define this macro if it would do nothing.
  847. `IS_ASM_LOGICAL_LINE_SEPARATOR (C)'
  848.      Define this macro as a C expression which is nonzero if C is used
  849.      as a logical line separator by the assembler.
  850.      If you do not define this macro, the default is that only the
  851.      character `;' is treated as a logical line separator.
  852. `ASM_OPEN_PAREN'
  853. `ASM_CLOSE_PAREN'
  854.      These macros are defined as C string constant, describing the
  855.      syntax in the assembler for grouping arithmetic expressions.  The
  856.      following definitions are correct for most assemblers:
  857.           #define ASM_OPEN_PAREN "("
  858.           #define ASM_CLOSE_PAREN ")"
  859.    These macros are provided by `real.h' for writing the definitions of
  860. `ASM_OUTPUT_DOUBLE' and the like:
  861. `REAL_VALUE_TO_TARGET_SINGLE (X, L)'
  862. `REAL_VALUE_TO_TARGET_DOUBLE (X, L)'
  863. `REAL_VALUE_TO_TARGET_LONG_DOUBLE (X, L)'
  864.      These translate X, of type `REAL_VALUE_TYPE', to the target's
  865.      floating point representation, and store its bit pattern in the
  866.      array of `long int' whose address is L.  The number of elements in
  867.      the output array is determined by the size of the desired target
  868.      floating point data type: 32 bits of it go in each `long int' array
  869.      element.  Each array element holds 32 bits of the result, even if
  870.      `long int' is wider than 32 bits on the host machine.
  871.      The array element values are designed so that you can print them
  872.      out using `fprintf' in the order they should appear in the target
  873.      machine's memory.
  874. `REAL_VALUE_TO_DECIMAL (X, FORMAT, STRING)'
  875.      This macro converts X, of type `REAL_VALUE_TYPE', to a decimal
  876.      number and stores it as a string into STRING.  You must pass, as
  877.      STRING, the address of a long enough block of space to hold the
  878.      result.
  879.      The argument FORMAT is a `printf'-specification that serves as a
  880.      suggestion for how to format the output string.
  881.