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 / config / a29k.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  38KB  |  1,434 lines
  1. /* Subroutines used for code generation on AMD Am29000.
  2.    Copyright (C) 1987, 1988, 1990, 1991, 1992 Free Software Foundation, Inc.
  3.    Contributed by Richard Kenner (kenner@nyu.edu)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include <stdio.h>
  22. #include "config.h"
  23. #include "rtl.h"
  24. #include "regs.h"
  25. #include "hard-reg-set.h"
  26. #include "real.h"
  27. #include "insn-config.h"
  28. #include "conditions.h"
  29. #include "insn-flags.h"
  30. #include "output.h"
  31. #include "insn-attr.h"
  32. #include "flags.h"
  33. #include "recog.h"
  34. #include "expr.h"
  35. #include "obstack.h"
  36. #include "tree.h"
  37. #include "reload.h"
  38.  
  39. #define min(A,B)    ((A) < (B) ? (A) : (B))
  40.  
  41. /* This gives the size in words of the register stack for the current
  42.    procedure.  */
  43.  
  44. static int a29k_regstack_size;
  45.  
  46. /* This points to the last insn of the insn prologue.  It is set when
  47.    an insn without a filled delay slot is found near the start of the
  48.    function.  */
  49.  
  50. static char *a29k_last_prologue_insn;
  51.  
  52. /* This points to the first insn that will be in the epilogue.  It is null if
  53.    no epilogue is required.  */
  54.  
  55. static char *a29k_first_epilogue_insn;
  56.  
  57. /* This is nonzero if a a29k_first_epilogue_insn was put in a delay slot.  It
  58.    indicates that an intermediate label needs to be written.  */
  59.  
  60. static int a29k_first_epilogue_insn_used;
  61.  
  62. /* Location to hold the name of the current function.  We need this prolog to
  63.    contain the tag words prior to the declaration.  So the name must be stored
  64.    away.  */
  65.  
  66. char *a29k_function_name;
  67.  
  68. /* Mapping of registers to debug register numbers.  The only change is
  69.    for the frame pointer and the register numbers used for the incoming
  70.    arguments.  */
  71.  
  72. int a29k_debug_reg_map[FIRST_PSEUDO_REGISTER];
  73.  
  74. /* Save information from a "cmpxx" operation until the branch or scc is
  75.    emitted.  */
  76.  
  77. rtx a29k_compare_op0, a29k_compare_op1;
  78. int a29k_compare_fp_p;
  79.  
  80. /* Gives names for registers.  */
  81. extern char *reg_names[];
  82.  
  83. /* Returns 1 if OP is a 8-bit constant. */
  84.  
  85. int
  86. cint_8_operand (op, mode)
  87.      register rtx op;
  88.      enum machine_mode mode;
  89. {
  90.   return GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffffff00) == 0;
  91. }
  92.  
  93. /* Returns 1 if OP is a 16-bit constant.  */
  94.  
  95. int
  96. cint_16_operand (op, mode)
  97.      rtx op;
  98.      enum machine_mode mode;
  99. {
  100.   return GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffff0000) == 0;
  101. }
  102.  
  103. /* Returns 1 if OP is a constant that cannot be moved in a single insn.  */
  104.  
  105. int
  106. long_const_operand (op, mode)
  107.      register rtx op;
  108.      enum machine_mode mode;
  109. {
  110.   if (! CONSTANT_P (op))
  111.     return 0;
  112.  
  113.   if (TARGET_29050 && GET_CODE (op) == CONST_INT
  114.       && (INTVAL (op) & 0xffff) == 0)
  115.     return 0;
  116.  
  117.   return (GET_CODE (op) != CONST_INT
  118.       || ((INTVAL (op) & 0xffff0000) != 0
  119.           && (INTVAL (op) & 0xffff0000) != 0xffff0000
  120.           && INTVAL (op) != 0x80000000));
  121. }
  122.  
  123. /* The following four functions detect constants of 0, 8, 16, and 24 used as
  124.    a position in ZERO_EXTRACT operations.  They can either be the appropriate
  125.    constant integer or a shift (which will be produced by combine).  */
  126.  
  127. static int
  128. shift_constant_operand (op, mode, val)
  129.      rtx op;
  130.      enum machine_mode mode;
  131.      int val;
  132. {
  133.   return ((GET_CODE (op) == CONST_INT && INTVAL (op) == val)
  134.       || (GET_CODE (op) == ASHIFT
  135.           && GET_CODE (XEXP (op, 0)) == CONST_INT
  136.           && INTVAL (XEXP (op, 0)) == val / 8
  137.           && GET_CODE (XEXP (op, 1)) == CONST_INT
  138.           && INTVAL (XEXP (op, 1)) == 3));
  139. }
  140.  
  141. int
  142. const_0_operand (op, mode)
  143.      rtx op;
  144.      enum machine_mode mode;
  145. {
  146.   return shift_constant_operand (op, mode, 0);
  147. }
  148.  
  149. int
  150. const_8_operand (op, mode)
  151.      rtx op;
  152.      enum machine_mode mode;
  153. {
  154.   return shift_constant_operand (op, mode, 8);
  155. }
  156.  
  157. int
  158. const_16_operand (op, mode)
  159.      rtx op;
  160.      enum machine_mode mode;
  161. {
  162.   return shift_constant_operand (op, mode, 16);
  163. }
  164.  
  165. int
  166. const_24_operand (op, mode)
  167.      rtx op;
  168.      enum machine_mode mode;
  169. {
  170.   return shift_constant_operand (op, mode, 24);
  171. }
  172.  
  173. /* Returns 1 if OP is a floating-point constant of the proper mode.  */
  174.  
  175. int
  176. float_const_operand (op, mode)
  177.      rtx op;
  178.      enum machine_mode mode;
  179. {
  180.   return GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == mode;
  181. }
  182.  
  183. /* Returns 1 if OP is a floating-point constant of the proper mode or a
  184.    general-purpose register.  */
  185.  
  186. int
  187. gpc_reg_or_float_constant_operand (op, mode)
  188.      rtx op;
  189.      enum machine_mode mode;
  190. {
  191.   return float_const_operand (op, mode) || gpc_reg_operand (op, mode);
  192. }
  193.  
  194. /* Returns 1 if OP is an integer constant of the proper mode or a
  195.    general-purpose register.  */
  196.  
  197. int
  198. gpc_reg_or_integer_constant_operand (op, mode)
  199.      rtx op;
  200.      enum machine_mode mode;
  201. {
  202.   return ((GET_MODE (op) == VOIDmode
  203.        && (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE))
  204.       || gpc_reg_operand (op, mode));
  205. }
  206.      
  207. /* Returns 1 if OP is a special machine register.  */
  208.  
  209. int
  210. spec_reg_operand (op, mode)
  211.      rtx op;
  212.      enum machine_mode mode;
  213. {
  214.   if (GET_CODE (op) != REG || GET_MODE (op) != mode)
  215.     return 0;
  216.  
  217.   switch (GET_MODE_CLASS (mode))
  218.     {
  219.     case MODE_PARTIAL_INT:
  220.       return REGNO (op) >= R_BP && REGNO (op) <= R_CR;
  221.     case MODE_INT:
  222.       return REGNO (op) >= R_Q && REGNO (op) <= R_EXO;
  223.     detault:
  224.       return 0;
  225.     }
  226. }
  227.  
  228. /* Returns 1 if OP is an accumulator register.  */
  229.  
  230. int
  231. accum_reg_operand (op, mode)
  232.      rtx op;
  233.      enum machine_mode mode;
  234. {
  235.   return (GET_CODE (op) == REG
  236.       && REGNO (op) >= R_ACC (0) && REGNO (op) <= R_ACC (3));
  237. }
  238.  
  239. /* Returns 1 if OP is a normal data register.  */
  240.  
  241. int
  242. gpc_reg_operand (op, mode)
  243.      rtx op;
  244.      enum machine_mode mode;
  245. {
  246.   int regno;
  247.  
  248.   if (GET_MODE (op) != mode && mode != VOIDmode)
  249.     return 0;
  250.  
  251.   if (GET_CODE (op) == REG)
  252.     regno = REGNO (op);
  253.   else if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
  254.     {
  255.       regno = REGNO (SUBREG_REG (op));
  256.       if (regno < FIRST_PSEUDO_REGISTER)
  257.     regno += SUBREG_WORD (op);
  258.     }
  259.   else
  260.     return 0;
  261.  
  262.   return regno >= FIRST_PSEUDO_REGISTER || regno < R_BP;
  263. }
  264.  
  265. /* Returns 1 if OP is either an 8-bit constant integer or a general register.
  266.    If a register, it must be in the proper mode unless MODE is VOIDmode.  */
  267.  
  268. int
  269. srcb_operand (op, mode)
  270.       register rtx op;
  271.       enum machine_mode mode;
  272. {
  273.   if (GET_CODE (op) == CONST_INT
  274.       && (mode == QImode
  275.       || (INTVAL (op) & 0xffffff00) == 0))
  276.     return 1;
  277.  
  278.   if (GET_MODE (op) != mode && mode != VOIDmode)
  279.     return 0;
  280.  
  281.   return gpc_reg_operand (op, mode);
  282. }
  283.  
  284. /* Return 1 if OP is either an immediate or a general register.  This is used
  285.    for the input operand of mtsr/mtrsim.  */
  286.  
  287. int
  288. gpc_reg_or_immediate_operand (op, mode)
  289.      rtx op;
  290.      enum machine_mode mode;
  291. {
  292.   return gpc_reg_operand (op, mode) || immediate_operand (op, mode);
  293. }
  294.  
  295. /* Return 1 if OP can be used as the second operand of and AND insn.  This
  296.    includes srcb_operand and a constant whose complement fits in 8 bits.  */
  297.  
  298. int
  299. and_operand (op, mode)
  300.      rtx op;
  301.      enum machine_mode mode;
  302. {
  303.   return (srcb_operand (op, mode)
  304.       || (GET_CODE (op) == CONST_INT
  305.           && ((unsigned) ((~ INTVAL (op)) & GET_MODE_MASK (mode)) < 256)));
  306. }
  307.  
  308. /* Return 1 if OP can be used as the second operand of an ADD insn.
  309.    This is the same as above, except we use negative, rather than
  310.    complement.   */
  311.  
  312. int
  313. add_operand (op, mode)
  314.      rtx op;
  315.      enum machine_mode mode;
  316. {
  317.   return (srcb_operand (op, mode)
  318.       || (GET_CODE (op) == CONST_INT
  319.           && ((unsigned) ((- INTVAL (op)) & GET_MODE_MASK (mode)) < 256)));
  320. }
  321.  
  322. /* Return 1 if OP is a valid address in a CALL_INSN.  These are a SYMBOL_REF
  323.    to the current function, all SYMBOL_REFs if TARGET_SMALL_MEMORY, or
  324.    a sufficiently-smal