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