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 / i960.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  56KB  |  2,246 lines
  1. /* Subroutines used for code generation on intel 80960.
  2.    Copyright (C) 1992 Free Software Foundation, Inc.
  3.    Contributed by Steven McGeady, Intel Corp.
  4.    Additional Work by Glenn Colon-Bonet, Jonathan Shapiro, Andy Wilson
  5.    Converted to GCC 2.0 by Jim Wilson and Michael Tiemann, Cygnus Support.
  6.  
  7. This file is part of GNU CC.
  8.  
  9. GNU CC is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2, or (at your option)
  12. any later version.
  13.  
  14. GNU CC is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with GNU CC; see the file COPYING.  If not, write to
  21. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22.  
  23. #include <stdio.h>
  24.  
  25. #include "config.h"
  26. #include "rtl.h"
  27. #include "regs.h"
  28. #include "hard-reg-set.h"
  29. #include "real.h"
  30. #include "insn-config.h"
  31. #include "conditions.h"
  32. #include "insn-flags.h"
  33. #include "output.h"
  34. #include "insn-attr.h"
  35. #include "flags.h"
  36. #include "tree.h"
  37. #include "insn-codes.h"
  38. #include "assert.h"
  39. #include "expr.h"
  40. #include "function.h"
  41. #include "recog.h"
  42. #include <math.h>
  43.  
  44. /* Save the operands last given to a compare for use when we
  45.    generate a scc or bcc insn.  */
  46.  
  47. rtx i960_compare_op0, i960_compare_op1;
  48.  
  49. /* Used to implement #pragma align/noalign.  Initialized by OVERRIDE_OPTIONS
  50.    macro in i960.h.  */
  51.  
  52. static int i960_maxbitalignment;
  53. static int i960_last_maxbitalignment;
  54.  
  55. /* Used to implement switching between MEM and ALU insn types, for better
  56.    C series performance.  */
  57.  
  58. enum insn_types i960_last_insn_type;
  59.  
  60. /* The leaf-procedure return register.  Set only if this is a leaf routine.  */
  61.  
  62. static int i960_leaf_ret_reg;
  63.  
  64. /* True if replacing tail calls with jumps is OK.  */
  65.  
  66. static int tail_call_ok;
  67.  
  68. /* A string containing a list of insns to emit in the epilogue so as to
  69.    restore all registers saved by the prologue.  Created by the prologue
  70.    code as it saves registers away.  */
  71.  
  72. char epilogue_string[1000];
  73.  
  74. /* A unique number (per function) for return labels.  */
  75.  
  76. static int ret_label = 0;
  77.  
  78. #if 0
  79. /* Handle pragmas for compatibility with Intel's compilers.  */
  80.  
  81. /* ??? This is incomplete, since it does not handle all pragmas that the
  82.    intel compilers understand.  Also, it needs to be rewritten to accept
  83.    a stream instead of a string for GCC 2.  */
  84.  
  85. void
  86. process_pragma(str)
  87.      char  *str;
  88. {
  89.   int align;
  90.   int i;
  91.  
  92.   if ((i = sscanf (str, " align %d", &align)) == 1)
  93.     switch (align)
  94.       {
  95.       case 0:            /* Return to last alignment.  */
  96.         align = i960_last_maxbitalignment / 8;
  97.  
  98.       case 16:            /* Byte alignments. */
  99.       case 8:
  100.       case 4:
  101.       case 2:
  102.       case 1:
  103.         i960_last_maxbitalignment = i960_maxbitalignment;
  104.         i960_maxbitalignment = align * 8;
  105.         break;
  106.  
  107.       default:            /* Unknown, silently ignore.  */
  108.         break;
  109.       }
  110.  
  111.   /* NOTE: ic960 R3.0 pragma align definition:
  112.  
  113.      #pragma align [(size)] | (identifier=size[,...])
  114.      #pragma noalign [(identifier)[,...]]
  115.  
  116.      (all parens are optional)
  117.  
  118.      - size is [1,2,4,8,16]
  119.      - noalign means size==1
  120.      - applies only to component elements of a struct (and union?)
  121.      - identifier applies to structure tag (only)
  122.      - missing identifier means next struct
  123.  
  124.      - alignment rules for bitfields need more investigation  */
  125.  
  126.   /* Should be pragma 'far' or equivalent for callx/balx here.  */
  127. }
  128. #endif
  129.  
  130. /* Initialize variables before compiling any files.  */
  131.  
  132. void
  133. i960_initialize ()
  134. {
  135.   if (TARGET_IC_COMPAT2_0)
  136.     {
  137.       i960_maxbitalignment = 8;
  138.       i960_last_maxbitalignment = 128;
  139.     }
  140.   else
  141.     {
  142.       i960_maxbitalignment = 128;
  143.       i960_last_maxbitalignment = 8;
  144.     }
  145. }
  146.  
  147. /* Return true if OP can be used as the source of an fp move insn.  */
  148.  
  149. int
  150. fpmove_src_operand (op, mode)
  151.      rtx op;
  152.      enum machine_mode mode;
  153. {
  154.   return (GET_CODE (op) == CONST_DOUBLE || general_operand (op, mode));
  155. }
  156.  
  157. #if 0
  158. /* Return true if OP is a register or zero.  */
  159.  
  160. int
  161. reg_or_zero_operand (op, mode)
  162.      rtx op;
  163.      enum machine_mode mode;
  164. {
  165.   return register_operand (op, mode) || op == const0_rtx;
  166. }
  167. #endif
  168.  
  169. /* Return truth value of whether OP can be used as an operands in a three
  170.    address arithmetic insn (such as add %o1,7,%l2) of mode MODE.  */
  171.  
  172. int
  173. arith_operand (op, mode)
  174.      rtx op;
  175.      enum machine_mode mode;
  176. {
  177.   return (register_operand (op, mode) || literal (op, mode));
  178. }
  179.  
  180. /* Return true if OP is a register or a valid floating point literal.  */
  181.  
  182. int
  183. fp_arith_operand (op, mode)
  184.      rtx op;
  185.      enum machine_mode mode;
  186. {
  187.   return (register_operand (op, mode) || fp_literal (op, mode));
  188. }
  189.  
  190. /* Return true is OP is a register or a valid signed integer literal.  */
  191.  
  192. int
  193. signed_arith_operand (op, mode)
  194.      rtx op;
  195.      enum machine_mode mode;
  196. {
  197.   return (register_operand (op, mode) || signed_literal (op, mode));
  198. }
  199.  
  200. /* Return truth value of whether OP is a integer which fits the
  201.    range constraining immediate operands in three-address insns.  */
  202.  
  203. int
  204. literal (op, mode)
  205.      rtx op;
  206.      enum machine_mode mode;
  207. {
  208.   return ((GET_CODE (op) == CONST_INT) && INTVAL(op) >= 0 && INTVAL(op) < 32);
  209. }
  210.  
  211. /* Return true if OP is a float constant of 1.  */
  212.  
  213. int
  214. fp_literal_one (op, mode)
  215.      rtx op;
  216.      enum machine_mode mode;
  217. {
  218.   return (TARGET_NUMERICS && (mode == VOIDmode || mode == GET_MODE (op))
  219.       && (op == CONST1_RTX (mode)));
  220. }
  221.  
  222. /* Return true if OP is a float constant of 0.  */
  223.  
  224. int
  225. fp_literal_zero (op, mode)
  226.      rtx op;
  227.      enum machine_mode mode;
  228. {
  229.   return (TARGET_NUMERICS && (mode == VOIDmode || mode == GET_MODE (op))
  230.       && (op == CONST0_RTX (mode)));
  231. }
  232.  
  233. /* Return true if OP is a valid floating point literal.  */
  234.  
  235. int
  236. fp_literal(op, mode)
  237.      rtx op;
  238.      enum machine_mode mode;
  239. {
  240.   return fp_literal_zero (op, mode) || fp_literal_one (op, mode);
  241. }
  242.  
  243. /* Return true if OP is a valid signed immediate constant.  */
  244.  
  245. int
  246. signed_literal(op, mode)
  247.      rtx op;
  248.      enum machine_mode mode;
  249. {
  250.   return ((GET_CODE (op) == CONST_INT) && INTVAL(op) > -32 && INTVAL(op) < 32);
  251. }
  252.  
  253. /* Return truth value of statement that OP is a symbolic memory
  254.    operand of mode MODE.  */
  255.  
  256. int
  257. symbolic_memory_operand (op, mode)
  258.      rtx op;
  259.      enum machine_mode mode;
  260. {
  261.   if (GET_CODE (op) == SUBREG)
  262.     op = SUBREG_REG (op);
  263.   if (GET_CODE (op) != MEM)
  264.     return 0;
  265.   op = XEXP (op, 0);
  266.   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST
  267.       || GET_CODE (op) == HIGH || GET_CODE (op) == LABEL_REF);
  268. }
  269.  
  270. /* Return truth value of whether OP is EQ or NE.  */
  271.  
  272. int
  273. eq_or_neq (op, mode)
  274.      rtx op;
  275.      enum machine_mode mode;
  276. {
  277.   return (GET_CODE (op) == EQ || GET_CODE (op) == NE);
  278. }
  279.  
  280. /* OP is an integer register or a constant.  */
  281.  
  282. int
  283. arith32_operand (op, mode)
  284.      rtx op;
  285.      enum machine_mode mode;
  286. {
  287.   if (register_operand (op, mode))
  288.     return 1;
  289.   return (CONSTANT_P (op));
  290. }
  291.  
  292. /* Return true if OP is an integer constant which is a power of 2.  */
  293.  
  294. int
  295. power2_operand (op,mode)
  296.      rtx op;
  297.      enum machine_mode mode;
  298. {
  299.   if (GET_CODE(op) != CONST_INT)
  300.     return 0;
  301.  
  302.   return exact_log2 (INTVAL (op)) >= 0;
  303. }
  304.  
  305. /* If VAL has only one bit set, return the index of that bit.  Otherwise
  306.    return -1.  */
  307.  
  308. int
  309. bitpos (val)
  310.      unsigned int val;
  311. {
  312.   register int i;
  313.  
  314.   for (i = 0; val != 0; i++, val >>= 1)
  315.     {
  316.       if (val & 1)
  317.     {
  318.       if (val != 1)
  319.         return -1;
  320.       return i;
  321.     }
  322.     }
  323.   return -1;
  324. }
  325.  
  326. /* Return non-zero if OP is a mask, i.e. all one bits are consecutive.
  327.    The return value indicates how many consecutive non-zero bits exist
  328.    if this is a mask.  This is the same as the next function, except that
  329.    it does not indicate what the start and stop bit positions are.  */
  330.  
  331. int
  332. is_mask (val)
  333.      unsigned int val;
  334. {
  335.   register int start, end, i;
  336.  
  337.   start = -1;
  338.   for (i = 0; val != 0; val >>= 1, i++)
  339.     {
  340.       if (val & 1)
  341.     {
  342.       if (start < 0)
  343.         start = i;
  344.  
  345.       end = i;
  346.       continue;
  347.     }
  348.       /* Still looking for the first bit.  */
  349.       if (start < 0)
  350.     continue