home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / expr.h < prev    next >
C/C++ Source or Header  |  1994-02-06  |  23KB  |  685 lines
  1. /* Definitions for code generation pass of GNU compiler.
  2.    Copyright (C) 1987, 1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. #ifndef __STDC__
  22. #ifndef const
  23. #define const
  24. #endif
  25. #endif
  26.  
  27. /* The default branch cost is 1.  */
  28. #ifndef BRANCH_COST
  29. #define BRANCH_COST 1
  30. #endif
  31.  
  32. /* The default is that we do not promote the mode of an object.  */
  33. #ifndef PROMOTE_MODE
  34. #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)
  35. #endif
  36.  
  37. /* Macros to access the slots of a QUEUED rtx.
  38.    Here rather than in rtl.h because only the expansion pass
  39.    should ever encounter a QUEUED.  */
  40.  
  41. /* The variable for which an increment is queued.  */
  42. #define QUEUED_VAR(P) XEXP (P, 0)
  43. /* If the increment has been emitted, this is the insn
  44.    that does the increment.  It is zero before the increment is emitted.  */
  45. #define QUEUED_INSN(P) XEXP (P, 1)
  46. /* If a pre-increment copy has been generated, this is the copy
  47.    (it is a temporary reg).  Zero if no copy made yet.  */
  48. #define QUEUED_COPY(P) XEXP (P, 2)
  49. /* This is the body to use for the insn to do the increment.
  50.    It is used to emit the increment.  */
  51. #define QUEUED_BODY(P) XEXP (P, 3)
  52. /* Next QUEUED in the queue.  */
  53. #define QUEUED_NEXT(P) XEXP (P, 4)
  54.  
  55. /* This is the 4th arg to `expand_expr'.
  56.    EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
  57.    EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
  58.    EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
  59.     is a constant that is not a legitimate address.  */
  60. enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
  61.               EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER};
  62.  
  63. /* List of labels that must never be deleted.  */
  64. extern rtx forced_labels;
  65.  
  66. /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
  67.    So we can mark them all live at the end of the function, if stupid.  */
  68. extern rtx save_expr_regs;
  69.  
  70. extern int current_function_calls_alloca;
  71. extern int current_function_outgoing_args_size;
  72.  
  73. /* This is the offset from the arg pointer to the place where the first
  74.    anonymous arg can be found, if there is one.  */
  75. extern rtx current_function_arg_offset_rtx;
  76.  
  77. /* This is nonzero if the current function uses the constant pool.  */
  78. extern int current_function_uses_const_pool;
  79.  
  80. /* This is nonzero if the current function uses pic_offset_table_rtx.  */
  81. extern int current_function_uses_pic_offset_table;
  82.  
  83. /* The arg pointer hard register, or the pseudo into which it was copied.  */
  84. extern rtx current_function_internal_arg_pointer;
  85.  
  86. /* Nonzero means stack pops must not be deferred, and deferred stack
  87.    pops must not be output.  It is nonzero inside a function call,
  88.    inside a conditional expression, inside a statement expression,
  89.    and in other cases as well.  */
  90. extern int inhibit_defer_pop;
  91.  
  92. /* Number of function calls seen so far in current function.  */
  93.  
  94. extern int function_call_count;
  95.  
  96. /* RTX for stack slot that holds the current handler for nonlocal gotos.
  97.    Zero when function does not have nonlocal labels.  */
  98.  
  99. extern rtx nonlocal_goto_handler_slot;
  100.  
  101. /* RTX for stack slot that holds the stack pointer value to restore
  102.    for a nonlocal goto.
  103.    Zero when function does not have nonlocal labels.  */
  104.  
  105. extern rtx nonlocal_goto_stack_level;
  106.  
  107. /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
  108.    (labels to which there can be nonlocal gotos from nested functions)
  109.    in this function.  */
  110.  
  111. #ifdef TREE_CODE   /* Don't lose if tree.h not included.  */
  112. extern tree nonlocal_labels;
  113. #endif
  114.  
  115. #define NO_DEFER_POP (inhibit_defer_pop += 1)
  116. #define OK_DEFER_POP (inhibit_defer_pop -= 1)
  117.  
  118. /* Number of units that we should eventually pop off the stack.
  119.    These are the arguments to function calls that have already returned.  */
  120. extern int pending_stack_adjust;
  121.  
  122. /* A list of all cleanups which belong to the arguments of
  123.    function calls being expanded by expand_call.  */
  124. #ifdef TREE_CODE   /* Don't lose if tree.h not included.  */
  125. extern tree cleanups_this_call;
  126. #endif
  127.  
  128. #ifdef TREE_CODE /* Don't lose if tree.h not included.  */
  129. /* Structure to record the size of a sequence of arguments
  130.    as the sum of a tree-expression and a constant.  */
  131.  
  132. struct args_size
  133. {
  134.   int constant;
  135.   tree var;
  136. };
  137. #endif
  138.  
  139. /* Add the value of the tree INC to the `struct args_size' TO.  */
  140.  
  141. #define ADD_PARM_SIZE(TO, INC)    \
  142. { tree inc = (INC);                \
  143.   if (TREE_CODE (inc) == INTEGER_CST)        \
  144.     (TO).constant += TREE_INT_CST_LOW (inc);    \
  145.   else if ((TO).var == 0)            \
  146.     (TO).var = inc;                \
  147.   else                        \
  148.     (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); }
  149.  
  150. #define SUB_PARM_SIZE(TO, DEC)    \
  151. { tree dec = (DEC);                \
  152.   if (TREE_CODE (dec) == INTEGER_CST)        \
  153.     (TO).constant -= TREE_INT_CST_LOW (dec);    \
  154.   else if ((TO).var == 0)            \
  155.     (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \
  156.   else                        \
  157.     (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
  158.  
  159. /* Convert the implicit sum in a `struct args_size' into an rtx.  */
  160. #define ARGS_SIZE_RTX(SIZE)                        \
  161. ((SIZE).var == 0 ? GEN_INT ((SIZE).constant)    \
  162.  : expand_expr (size_binop (PLUS_EXPR, (SIZE).var,            \
  163.                 size_int ((SIZE).constant)),        \
  164.         NULL_RTX, VOIDmode, 0))
  165.  
  166. /* Convert the implicit sum in a `struct args_size' into a tree.  */
  167. #define ARGS_SIZE_TREE(SIZE)                        \
  168. ((SIZE).var == 0 ? size_int ((SIZE).constant)                \
  169.  : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant)))
  170.  
  171. /* Supply a default definition for FUNCTION_ARG_PADDING:
  172.    usually pad upward, but pad short args downward on
  173.    big-endian machines.  */
  174.  
  175. enum direction {none, upward, downward};  /* Value has this type.  */
  176.  
  177. #ifndef FUNCTION_ARG_PADDING
  178. #if BYTES_BIG_ENDIAN
  179. #define FUNCTION_ARG_PADDING(MODE, TYPE)                \
  180.   (((MODE) == BLKmode                            \
  181.     ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST        \
  182.        && int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT)    \
  183.     : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY)                \
  184.    ? downward : upward)
  185. #else
  186. #define FUNCTION_ARG_PADDING(MODE, TYPE) upward
  187. #endif
  188. #endif
  189.  
  190. /* Supply a default definition for FUNCTION_ARG_BOUNDARY.  Normally, we let
  191.    FUNCTION_ARG_PADDING, which also pads the length, handle any needed
  192.    alignment.  */
  193.   
  194. #ifndef FUNCTION_ARG_BOUNDARY
  195. #define FUNCTION_ARG_BOUNDARY(MODE, TYPE)    PARM_BOUNDARY
  196. #endif
  197.  
  198. /* Nonzero if we do not know how to pass TYPE solely in registers.
  199.    We cannot do so in the following cases:
  200.  
  201.    - if the type has variable size
  202.    - if the type is marked as addressable (it is required to be constructed
  203.      into the stack)
  204.    - if the padding and mode of the type is such that a copy into a register
  205.      would put it into the wrong part of the register
  206.    - when STRICT_ALIGNMENT and the type is BLKmode and is is not
  207.      aligned to a boundary corresponding to what can be loaded into a
  208.      register.  */
  209.  
  210. #define MUST_PASS_IN_STACK_BAD_ALIGN(MODE,TYPE)            \
  211.   (STRICT_ALIGNMENT && MODE == BLKmode                    \
  212.    && TYPE_ALIGN (TYPE) < (BIGGEST_ALIGNMENT < BITS_PER_WORD    \
  213.                ? BIGGEST_ALIGNMENT : BITS_PER_WORD))
  214.   
  215. /* Which padding can't be supported depends on the byte endianness.  */
  216.  
  217. /* A value in a register is implicitly padded at the most significant end.
  218.    On a big-endian machine, that is the lower end in memory.
  219.    So a value padded in memory at the upper end can't go in a register.
  220.    For a little-endian machine, the reverse is true.  */
  221.  
  222. #if BYTES_BIG_ENDIAN
  223. #define MUST_PASS_IN_STACK_BAD_PADDING    upward
  224. #else
  225. #define MUST_PASS_IN_STACK_BAD_PADDING    downward
  226. #endif
  227.  
  228. #define MUST_PASS_IN_STACK(MODE,TYPE)            \
  229.   ((TYPE) != 0                        \
  230.    && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST    \
  231.