home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / info / gcc.info-23 (.txt) < prev    next >
GNU Info File  |  1994-12-22  |  25KB  |  455 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 675 Massachusetts Avenue
  5. Cambridge, MA 02139 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation,
  7.    Permission is granted to make and distribute verbatim copies of this
  8. manual provided the copyright notice and this permission notice are
  9. preserved on all copies.
  10.    Permission is granted to copy and distribute modified versions of
  11. this manual under the conditions for verbatim copying, provided also
  12. that the sections entitled "GNU General Public License," "Funding for
  13. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  14. included exactly as in the original, and provided that the entire
  15. resulting derived work is distributed under the terms of a permission
  16. notice identical to this one.
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that the sections entitled "GNU General Public
  20. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  21. `Look And Feel'", and this permission notice, may be included in
  22. translations approved by the Free Software Foundation instead of in the
  23. original English.
  24. File: gcc.info,  Node: Misc,  Prev: Cross-compilation,  Up: Target Macros
  25. Miscellaneous Parameters
  26. ========================
  27.    Here are several miscellaneous parameters.
  28. `PREDICATE_CODES'
  29.      Define this if you have defined special-purpose predicates in the
  30.      file `MACHINE.c'.  This macro is called within an initializer of an
  31.      array of structures.  The first field in the structure is the name
  32.      of a predicate and the second field is an array of rtl codes.  For
  33.      each predicate, list all rtl codes that can be in expressions
  34.      matched by the predicate.  The list should have a trailing comma.
  35.      Here is an example of two entries in the list for a typical RISC
  36.      machine:
  37.           #define PREDICATE_CODES \
  38.             {"gen_reg_rtx_operand", {SUBREG, REG}},  \
  39.             {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
  40.      Defining this macro does not affect the generated code (however,
  41.      incorrect definitions that omit an rtl code that may be matched by
  42.      the predicate can cause the compiler to malfunction).  Instead, it
  43.      allows the table built by `genrecog' to be more compact and
  44.      efficient, thus speeding up the compiler.  The most important
  45.      predicates to include in the list specified by this macro are
  46.      thoses used in the most insn patterns.
  47. `CASE_VECTOR_MODE'
  48.      An alias for a machine mode name.  This is the machine mode that
  49.      elements of a jump-table should have.
  50. `CASE_VECTOR_PC_RELATIVE'
  51.      Define this macro if jump-tables should contain relative addresses.
  52. `CASE_DROPS_THROUGH'
  53.      Define this if control falls through a `case' insn when the index
  54.      value is out of range.  This means the specified default-label is
  55.      actually ignored by the `case' insn proper.
  56. `CASE_VALUES_THRESHOLD'
  57.      Define this to be the smallest number of different values for
  58.      which it is best to use a jump-table instead of a tree of
  59.      conditional branches.  The default is four for machines with a
  60.      `casesi' instruction and five otherwise.  This is best for most
  61.      machines.
  62. `WORD_REGISTER_OPERATIONS'
  63.      Define this macro if operations between registers with integral
  64.      mode smaller than a word are always performed on the entire
  65.      register.  Most RISC machines have this property and most CISC
  66.      machines do not.
  67. `LOAD_EXTEND_OP (MODE)'
  68.      Define this macro to be a C expression indicating when insns that
  69.      read memory in MODE, an integral mode narrower than a word, set the
  70.      bits outside of MODE to be either the sign-extension or the
  71.      zero-extension of the data read.  Return `SIGN_EXTEND' for values
  72.      of MODE for which the insn sign-extends, `ZERO_EXTEND' for which
  73.      it zero-extends, and `NIL' for other modes.
  74.      This macro is not called with MODE non-integral or with a width
  75.      greater than or equal to `BITS_PER_WORD', so you may return any
  76.      value in this case.  Do not define this macro if it would always
  77.      return `NIL'.  On machines where this macro is defined, you will
  78.      normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'.
  79. `IMPLICIT_FIX_EXPR'
  80.      An alias for a tree code that should be used by default for
  81.      conversion of floating point values to fixed point.  Normally,
  82.      `FIX_ROUND_EXPR' is used.
  83. `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
  84.      Define this macro if the same instructions that convert a floating
  85.      point number to a signed fixed point number also convert validly
  86.      to an unsigned one.
  87. `EASY_DIV_EXPR'
  88.      An alias for a tree code that is the easiest kind of division to
  89.      compile code for in the general case.  It may be `TRUNC_DIV_EXPR',
  90.      `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'.  These four
  91.      division operators differ in how they round the result to an
  92.      integer.  `EASY_DIV_EXPR' is used when it is permissible to use
  93.      any of those kinds of division and the choice should be made on
  94.      the basis of efficiency.
  95. `MOVE_MAX'
  96.      The maximum number of bytes that a single instruction can move
  97.      quickly from memory to memory.
  98. `MAX_MOVE_MAX'
  99.      The maximum number of bytes that a single instruction can move
  100.      quickly from memory to memory.  If this is undefined, the default
  101.      is `MOVE_MAX'.  Otherwise, it is the constant value that is the
  102.      largest value that `MOVE_MAX' can have at run-time.
  103. `SHIFT_COUNT_TRUNCATED'
  104.      A C expression that is nonzero if on this machine the number of
  105.      bits actually used for the count of a shift operation is equal to
  106.      the number of bits needed to represent the size of the object
  107.      being shifted.  When this macro is non-zero, the compiler will
  108.      assume that it is safe to omit a sign-extend, zero-extend, and
  109.      certain bitwise `and' instructions that truncates the count of a
  110.      shift operation.  On machines that have instructions that act on
  111.      bitfields at variable positions, which may include `bit test'
  112.      instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
  113.      deletion of truncations of the values that serve as arguments to
  114.      bitfield instructions.
  115.      If both types of instructions truncate the count (for shifts) and
  116.      position (for bitfield operations), or if no variable-position
  117.      bitfield instructions exist, you should define this macro.
  118.      However, on some machines, such as the 80386 and the 680x0,
  119.      truncation only applies to shift operations and not the (real or
  120.      pretended) bitfield operations.  Define `SHIFT_COUNT_TRUNCATED' to
  121.      be zero on such machines.  Instead, add patterns to the `md' file
  122.      that include the implied truncation of the shift instructions.
  123.      You need not define this macro if it would always have the value
  124.      of zero.
  125. `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
  126.      A C expression which is nonzero if on this machine it is safe to
  127.      "convert" an integer of INPREC bits to one of OUTPREC bits (where
  128.      OUTPREC is smaller than INPREC) by merely operating on it as if it
  129.      had only OUTPREC bits.
  130.      On many machines, this expression can be 1.
  131.      When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for
  132.      modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result.
  133.      If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in
  134.      such cases may improve things.
  135. `STORE_FLAG_VALUE'
  136.      A C expression describing the value returned by a comparison
  137.      operator with an integral mode and stored by a store-flag
  138.      instruction (`sCOND') when the condition is true.  This
  139.      description must apply to *all* the `sCOND' patterns and all the
  140.      comparison operators whose results have a `MODE_INT' mode.
  141.      A value of 1 or -1 means that the instruction implementing the
  142.      comparison operator returns exactly 1 or -1 when the comparison is
  143.      true and 0 when the comparison is false.  Otherwise, the value
  144.