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 / rs6000.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  50KB  |  1,805 lines
  1. /* Subroutines used for code generation on IBM RS/6000.
  2.    Copyright (C) 1991 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.  
  38. extern char *language_string;
  39.  
  40. #define min(A,B)    ((A) < (B) ? (A) : (B))
  41. #define max(A,B)    ((A) > (B) ? (A) : (B))
  42.  
  43. /* Set to non-zero by "fix" operation to indicate that itrunc and
  44.    uitrunc must be defined.  */
  45.  
  46. int rs6000_trunc_used;
  47.  
  48. /* Set to non-zero once they have been defined.  */
  49.  
  50. static int trunc_defined;
  51.  
  52. /* Save information from a "cmpxx" operation until the branch or scc is
  53.    emitted.  */
  54.  
  55. rtx rs6000_compare_op0, rs6000_compare_op1;
  56. int rs6000_compare_fp_p;
  57.  
  58. /* Return non-zero if this function is known to have a null epilogue.  */
  59.  
  60. int
  61. direct_return ()
  62. {
  63.   return (reload_completed
  64.       && first_reg_to_save () == 32
  65.       && first_fp_reg_to_save () == 64
  66.       && ! regs_ever_live[65]
  67.       && ! rs6000_pushes_stack ());
  68. }
  69.  
  70. /* Returns 1 always.  */
  71.  
  72. int
  73. any_operand (op, mode)
  74.      register rtx op;
  75.      enum machine_mode mode;
  76. {
  77.   return 1;
  78. }
  79.  
  80. /* Return 1 if OP is a constant that can fit in a D field.  */
  81.  
  82. int
  83. short_cint_operand (op, mode)
  84.      register rtx op;
  85.      enum machine_mode mode;
  86. {
  87.   return (GET_CODE (op) == CONST_INT
  88.       && (unsigned) (INTVAL (op) + 0x8000) < 0x10000);
  89. }
  90.  
  91. /* Similar for a unsigned D field.  */
  92.  
  93. int
  94. u_short_cint_operand (op, mode)
  95.      register rtx op;
  96.      enum machine_mode mode;
  97. {
  98.   return (GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffff0000) == 0);
  99. }
  100.  
  101. /* Return 1 if OP is a CONST_INT that cannot fit in a signed D field.  */
  102.  
  103. int
  104. non_short_cint_operand (op, mode)
  105.      register rtx op;
  106.      enum machine_mode mode;
  107. {
  108.   return (GET_CODE (op) == CONST_INT
  109.       && (unsigned) (INTVAL (op) + 0x8000) >= 0x10000);
  110. }
  111.  
  112. /* Returns 1 if OP is a register that is not special (i.e., not MQ,
  113.    ctr, or lr).  */
  114.  
  115. int
  116. gpc_reg_operand (op, mode)
  117.      register rtx op;
  118.      enum machine_mode mode;
  119. {
  120.   return (register_operand (op, mode)
  121.       && (GET_CODE (op) != REG || REGNO (op) >= 67 || REGNO (op) < 64));
  122. }
  123.  
  124. /* Returns 1 if OP is either a pseudo-register or a register denoting a
  125.    CR field.  */
  126.  
  127. int
  128. cc_reg_operand (op, mode)
  129.      register rtx op;
  130.      enum machine_mode mode;
  131. {
  132.   return (register_operand (op, mode)
  133.       && (GET_CODE (op) != REG
  134.           || REGNO (op) >= FIRST_PSEUDO_REGISTER
  135.           || CR_REGNO_P (REGNO (op))));
  136. }
  137.  
  138. /* Returns 1 if OP is either a constant integer valid for a D-field or a
  139.    non-special register.  If a register, it must be in the proper mode unless
  140.    MODE is VOIDmode.  */
  141.  
  142. int
  143. reg_or_short_operand (op, mode)
  144.       register rtx op;
  145.       enum machine_mode mode;
  146. {
  147.   if (GET_CODE (op) == CONST_INT)
  148.     return short_cint_operand (op, mode);
  149.  
  150.   return gpc_reg_operand (op, mode);
  151. }
  152.  
  153. /* Similar, except check if the negation of the constant would be valid for
  154.    a D-field.  */
  155.  
  156. int
  157. reg_or_neg_short_operand (op, mode)
  158.       register rtx op;
  159.       enum machine_mode mode;
  160. {
  161.   if (GET_CODE (op) == CONST_INT)
  162.     return CONST_OK_FOR_LETTER_P (INTVAL (op), 'P');
  163.  
  164.   return gpc_reg_operand (op, mode);
  165. }
  166.  
  167. /* Return 1 if the operand is either a register or an integer whose high-order
  168.    16 bits are zero.  */
  169.  
  170. int
  171. reg_or_u_short_operand (op, mode)
  172.      register rtx op;
  173.      enum machine_mode mode;
  174. {
  175.   if (GET_CODE (op) == CONST_INT
  176.       && (INTVAL (op) & 0xffff0000) == 0)
  177.     return 1;
  178.  
  179.   return gpc_reg_operand (op, mode);
  180. }
  181.  
  182. /* Return 1 is the operand is either a non-special register or ANY
  183.    constant integer.  */
  184.  
  185. int
  186. reg_or_cint_operand (op, mode)
  187.     register rtx op;
  188.     enum machine_mode mode;
  189. {
  190.      return GET_CODE (op) == CONST_INT || gpc_reg_operand (op, mode);
  191. }
  192.  
  193. /* Return 1 if the operand is a CONST_DOUBLE and it can be put into a
  194.    register with one instruction per word.  For SFmode, this means  that
  195.    the low 16-bits are zero.  For DFmode, it means the low 16-bits of
  196.    the first word are zero and the high 16 bits of the second word
  197.    are zero (usually all bits in the low-order word will be zero).
  198.  
  199.    We only do this if we can safely read CONST_DOUBLE_{LOW,HIGH}.  */
  200.  
  201. int
  202. easy_fp_constant (op, mode)
  203.      register rtx op;
  204.      register enum machine_mode mode;
  205. {
  206.   rtx low, high;
  207.  
  208.   if (GET_CODE (op) != CONST_DOUBLE
  209.       || GET_MODE (op) != mode
  210.       || GET_MODE_CLASS (mode) != MODE_FLOAT)
  211.     return 0;
  212.  
  213.   high = operand_subword (op, 0, 0, mode);
  214.   low = operand_subword (op, 1, 0, mode);
  215.  
  216.   if (high == 0 || GET_CODE (high) != CONST_INT || (INTVAL (high) & 0xffff))
  217.     return 0;
  218.  
  219.   return (mode == SFmode
  220.       || (low != 0 && GET_CODE (low) == CONST_INT
  221.           && (INTVAL (low) & 0xffff0000) == 0));
  222. }
  223.       
  224. /* Return 1 if the operand is either a floating-point register, a pseudo
  225.    register, or memory.  */
  226.  
  227. int
  228. fp_reg_or_mem_operand (op, mode)
  229.      register rtx op;
  230.      enum machine_mode mode;
  231. {
  232.   return (memory_operand (op, mode)
  233.       || (register_operand (op, mode)
  234.           && (GET_CODE (op) != REG
  235.           || REGNO (op) >= FIRST_PSEUDO_REGISTER
  236.           || FP_REGNO_P (REGNO (op)))));
  237. }
  238.  
  239. /* Return 1 if the operand is either an easy FP constant (see above) or
  240.    memory.  */
  241.  
  242. int
  243. mem_or_easy_const_operand (op, mode)
  244.      register rtx op;
  245.      enum machine_mode mode;
  246. {
  247.   return memory_operand (op, mode) || easy_fp_constant (op, mode);
  248. }
  249.  
  250. /* Return 1 if the operand is either a non-special register or an item
  251.    that can be used as the operand of an SI add insn.  */
  252.  
  253. int
  254. add_operand (op, mode)
  255.     register rtx op;
  256.     enum machine_mode mode;
  257. {
  258.   return (reg_or_short_operand (op, mode)
  259.       || (GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffff) == 0));
  260. }
  261.  
  262. /* Return 1 if OP is a constant but not a valid add_operand.  */
  263.  
  264. int
  265. non_add_cint_operand (op, mode)
  266.      register rtx op;
  267.      enum machine_mode mode;
  268. {
  269.   return (GET_CODE (op) == CONST_INT
  270.       && (unsigned) (INTVAL (op) + 0x8000) >= 0x10000
  271.       && (INTVAL (op) & 0xffff) != 0);
  272. }
  273.  
  274. /* Return 1 if the operand is a non-special register or a constant that
  275.    can be used as the operand of an OR or XOR insn on the RS/6000.  */
  276.  
  277. int
  278. logical_operand (op, mode)
  279.      register rtx op;
  280.      enum machine_mode mode;
  281. {
  282.   return (gpc_reg_operand (op, mode)
  283.       || (GET_CODE (op) == CONST_INT
  284.           && ((INTVAL (op) & 0xffff0000) == 0
  285.           || (INTVAL (op) & 0xffff) == 0)));
  286. }
  287.  
  288. /* Return 1 if C is a constant that is not a logical operand (as
  289.    above).  */
  290.  
  291. int
  292. non_logical_cint_operand (op, mode)
  293.      register rtx op;
  294.      enum machine_mode mode;
  295. {
  296.   return (GET_CODE (op) == CONST_INT
  297.       && (INTVAL (op) & 0xffff0000) != 0
  298.       && (INTVAL (op) & 0xffff) != 0);
  299. }
  300.  
  301. /* Return 1 if C is a constant that can be encoded in a mask on the
  302.    RS/6000.  It is if there are no more than two 1->0 or 0->1 transitions.
  303.    Reject all ones and all zeros, since these should have been optimized
  304.    away and confuse the making of MB and ME.  */
  305.  
  306. int
  307. mask_constant (c)
  308.      register int c;
  309. {
  310.   int i;
  311.   int last_bit_value;
  312.   int transitions = 0;
  313.  
  314.   if (c == 0 || c == ~0)
  315.     return 0;
  316.  
  317.   last_bit_value = c & 1;
  318.  
  319.   for (i = 1; i < 32; i++)
  320.     if (((c >>= 1) & 1) != last_bit_value)
  321.       last_bit_value ^= 1, transitions++;
  322.  
  323.   return transitions <= 2;
  324. }
  325.  
  326. /* Return 1 if the operand is a constant that is a mask on the RS/6000. */
  327.  
  328. int
  329. mask_operand (op, mode)
  330.      register rtx op;
  331.