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 / convex.md < prev    next >
Text File  |  1994-02-06  |  37KB  |  1,352 lines
  1. ;;- Machine description for GNU compiler
  2. ;;- Convex Version
  3. ;;   Copyright (C) 1991 Free Software Foundation, Inc.
  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. ;; Scheduling defs
  22. ;;
  23. ;; Insn scheduling is not used at present.  Scheduling increases
  24. ;; register pressure so much that many spills are generated
  25. ;; even for very small functions.
  26.  
  27. ;; Compares
  28.  
  29. (define_insn "tstsi"
  30.   [(set (cc0)
  31.     (match_operand:SI 0 "register_operand" "r"))]
  32.   ""
  33.   "* return set_cmp (operands[0], const0_rtx, 'w');")
  34.  
  35. (define_insn "tsthi"
  36.   [(set (cc0)
  37.     (match_operand:HI 0 "register_operand" "r"))]
  38.   ""
  39.   "* return set_cmp (operands[0], const0_rtx, 'h');")
  40.  
  41. (define_expand "tstqi"
  42.   [(set (match_dup 1)
  43.     (sign_extend:SI (match_operand:QI 0 "register_operand" "r")))
  44.    (set (cc0)
  45.     (match_dup 1))]
  46.   ""
  47.   "operands[1] = gen_reg_rtx (SImode);")
  48.  
  49. (define_expand "tstdi"
  50.   [(parallel [(set (cc0) (match_operand:DI 0 "register_operand" "d"))
  51.           (use (match_dup 1))])]
  52.   ""
  53.   "operands[1] = force_reg (DImode, const0_rtx);")
  54.  
  55. (define_insn ""
  56.   [(set (cc0) (match_operand:DI 0 "register_operand" "d"))
  57.    (use (match_operand:DI 1 "register_operand" "d"))]
  58.   ""
  59.   "* return set_cmp (operands[0], operands[1], 'l');")
  60.  
  61. (define_expand "tstdf"
  62.   [(set (cc0)
  63.     (compare (match_operand:DF 0 "register_operand" "d")
  64.          (match_dup 1)))]
  65.   ""
  66.   "operands[1] = force_reg (DFmode, CONST0_RTX (DFmode));")
  67.  
  68. (define_insn "tstsf"
  69.   [(set (cc0)
  70.     (match_operand:SF 0 "register_operand" "d"))]
  71.   ""
  72.   "* return set_cmp (operands[0], CONST0_RTX (SFmode), 's');")
  73.  
  74. (define_insn "cmpsi"
  75.   [(set (cc0)
  76.     (compare (match_operand:SI 0 "register_operand" "d,a,i,r")
  77.          (match_operand:SI 1 "nonmemory_operand" "d,a,r,i")))]
  78.   ""
  79.   "* return set_cmp (operands[0], operands[1], 'w');")
  80.  
  81. (define_insn "cmphi"
  82.   [(set (cc0)
  83.     (compare (match_operand:HI 0 "register_operand" "d,a,r,i")
  84.          (match_operand:HI 1 "nonmemory_operand" "d,a,i,r")))]
  85.   ""
  86.   "* return set_cmp (operands[0], operands[1], 'h');")
  87.  
  88. (define_insn "cmpqi"
  89.   [(set (cc0)
  90.     (compare (match_operand:QI 0 "register_operand" "d")
  91.          (match_operand:QI 1 "register_operand" "d")))]
  92.   ""
  93.   "* return set_cmp (operands[0], operands[1], 'b');")
  94.  
  95. (define_insn "cmpdi"
  96.   [(set (cc0)
  97.     (compare (match_operand:DI 0 "register_operand" "d")
  98.          (match_operand:DI 1 "register_operand" "d")))]
  99.   ""
  100.   "* return set_cmp (operands[0], operands[1], 'l');")
  101.  
  102. (define_insn "cmpdf"
  103.   [(set (cc0)
  104.     (compare (match_operand:DF 0 "register_operand" "d")
  105.          (match_operand:DF 1 "register_operand" "d")))]
  106.   ""
  107.   "* return set_cmp (operands[0], operands[1], 'd');")
  108.  
  109. (define_insn "cmpsf"
  110.   [(set (cc0)
  111.     (compare (match_operand:SF 0 "nonmemory_operand" "dF,d")
  112.          (match_operand:SF 1 "nonmemory_operand" "d,F")))]
  113.   ""
  114.   "* return set_cmp (operands[0], operands[1], 's');")
  115.  
  116. ;; Moves
  117.  
  118. ;(define_insn "movtf"
  119. ;  [(set (match_operand:TF 0 "general_operand" "=g,d")
  120. ;    (match_operand:TF 1 "general_operand" "d,g"))]
  121. ;  ""
  122. ;  "*
  123. ;{
  124. ;  rtx opaddr = 0;
  125. ;  rtx xoperands[4];
  126. ;  xoperands[0] = operands[0];
  127. ;  xoperands[2] = operands[1];
  128. ;
  129. ;  if (REG_P (operands[0]))
  130. ;    xoperands[1] = gen_rtx (REG, TFmode, REGNO (operands[0]) + 1);
  131. ;  else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
  132. ;    xoperands[1] = 0;
  133. ;  else if (offsettable_memref_p (operands[0]))
  134. ;    xoperands[1] = adj_offsettable_operand (operands[0], 8);
  135. ;  else
  136. ;    {
  137. ;      opaddr = XEXP (operands[0], 0);
  138. ;      xoperands[0] = gen_rtx (MEM, TFmode, gen_rtx (REG, SImode, 13));
  139. ;      xoperands[1] = adj_offsettable_operand (xoperands[0], 8);
  140. ;    }
  141. ;
  142. ;  if (REG_P (operands[1]))
  143. ;    xoperands[3] = gen_rtx (REG, TFmode, REGNO (operands[1]) + 1);
  144. ;  else if (offsettable_memref_p (operands[1]))
  145. ;    xoperands[3] = adj_offsettable_operand (operands[1], 8);
  146. ;  else
  147. ;    {
  148. ;      opaddr = XEXP (operands[1], 0);
  149. ;      xoperands[2] = gen_rtx (MEM, TFmode, gen_rtx (REG, SImode, 13));
  150. ;      xoperands[3] = adj_offsettable_operand (xoperands[2], 8);
  151. ;    }
  152. ;
  153. ;  if (opaddr)
  154. ;    output_asm_insn (\"psh.w a5\;ld.w %0,a5\", &opaddr);
  155. ;  if (push_operand (operands[0], TFmode))
  156. ;    output_asm_insn (\"psh.l %3\;psh.l %2\", xoperands);
  157. ;  else if (GET_CODE (operands[0]) == MEM)
  158. ;    output_asm_insn (\"st.l %2,%0\;st.l %3,%1\", xoperands);
  159. ;  else if (GET_CODE (operands[1]) == REG)
  160. ;    output_asm_insn (\"mov %2,%0\;mov %3,%1\", xoperands);
  161. ;  else
  162. ;    output_asm_insn (\"ld.l %2,%0\;ld.l %3,%1\", xoperands);
  163. ;  if (opaddr)
  164. ;    output_asm_insn (\"pop.w a5\");
  165. ;  return \"\";
  166. ;}")
  167.  
  168. (define_insn "movdf"
  169.   [(set (match_operand:DF 0 "general_operand" "=g,d")
  170.     (match_operand:DF 1 "general_operand" "d,dmG"))]
  171.   ""
  172.   "*
  173. {
  174.   if (push_operand (operands[0], DFmode))
  175.     return \"psh.l %1\";
  176.   else if (GET_CODE (operands[0]) == MEM)
  177.     return \"st.l %1,%0\";
  178.   else if (GET_CODE (operands[1]) == REG)
  179.     return \"mov %1,%0\";
  180.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_D_P (operands[1]))
  181.     {
  182.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  183.                  const_double_high_int (operands[1]));
  184.       return \"ld.d %1,%0\";
  185.     }
  186.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_L_P (operands[1]))
  187.     {
  188.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  189.                  const_double_low_int (operands[1]));
  190.       return \"ld.l %1,%0\";
  191.     }
  192.   else
  193.     return \"ld.l %1,%0\";
  194. }")
  195.  
  196. (define_insn "movsf"
  197.   [(set (match_operand:SF 0 "general_operand" "=g,d")
  198.     (match_operand:SF 1 "general_operand" "d,gF"))]
  199.   ""
  200.   "*
  201. {
  202.   if (push_operand (operands[0], SFmode))
  203.     return \"psh.w %1\";
  204.   else if (GET_CODE (operands[0]) == MEM)
  205.     return \"st.s %1,%0\";
  206.   else if (GET_CODE (operands[1]) == REG)
  207.     return \"mov.s %1,%0\";
  208.   else
  209.     return \"ld.s %1,%0\";
  210. }")
  211.  
  212. (define_insn "movdi"
  213.   [(set (match_operand:DI 0 "general_operand" "=g,d")
  214.     (match_operand:DI 1 "general_operand" "d,dmiG"))]
  215.   ""
  216.   "*
  217. {
  218.   if (push_operand (operands[0], DImode))
  219.     return \"psh.l %1\";
  220.   else if (GET_CODE (operands[0]) == MEM)
  221.     return \"st.l %1,%0\";
  222.   else if (GET_CODE (operands[1]) == REG)
  223.     return \"mov %1,%0\";
  224.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_D_P (operands[1]))
  225.     {
  226.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  227.                  const_double_high_int (operands[1]));
  228.       return \"ld.d %1,%0\";
  229.     }
  230.   else
  231.     return \"ld.l %1,%0\";
  232. }")
  233.  
  234. ;; Special case of movsi, needed to express A-reg preference.
  235.  
  236. (define_insn ""
  237.   [(set (match_operand:SI 0 "push_operand" "=<")
  238.     (plus:SI (match_operand:SI 1 "register_operand" "a")
  239.          (match_operand:SI 2 "immediate_operand" "i")))]
  240.   "operands[1] != stack_pointer_rtx"
  241.   "pshea %a2(%1)")
  242.  
  243. ;; General movsi.  Constraints will be selected based on TARGET_INDIRECTS
  244. ;; to avoid indirect addressing on C3, where it is slow.
  245.  
  246. (define_expand "movsi"
  247.   [(set (match_operand:SI 0 "general_operand" "")
  248.     (match_operand:SI 1 "general_operand" ""))]
  249.   ""
  250.   "")
  251.  
  252. (define_insn ""
  253.   [(set (match_operand:SI 0 "push_operand" "=<,<")
  254.     (match_operand:SI 1 "general_operand" "Ad,io"))]
  255.   ""
  256.   "@
  257.    psh.w %1
  258.    pshea %a1")
  259.  
  260. (define_insn ""
  261.   [(set (match_operand:SI 0 "general_operand" "=g,r,<")
  262.     (match_operand:SI 1 "general_operand" "r,g,io"))]
  263.   "TARGET_INDIRECTS"
  264.   "*
  265. { 
  266.   if (push_operand (operands[0], SImode))
  267.     {
  268.       if (GET_CODE (operands[1]) == REG)
  269.     return \"psh.w %1\";
  270.       else
  271.         return \"pshea %a1\";
  272.     }
  273.   if (GET_CODE (operands[0]) == MEM)
  274.     return \"st.w %1,%0\";
  275.   if (GET_CODE (operands[1]) != REG)
  276.     return \"ld.w %1,%0\";
  277.   if (S_REG_P (operands[0]) && S_REG_P (operands[1]))
  278.     return \"mov.w %1,%0\";
  279.   return \"mov %1,%0\";
  280. }")
  281.  
  282. (define_insn ""
  283.   [(set (match_operand:SI 0 "general_operand"