home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / convex.md < prev    next >
Text File  |  1991-06-03  |  41KB  |  1,450 lines
  1. ;;- Machine description for GNU compiler
  2. ;;- Convex Version
  3. ;;   Copyright (C) 1989 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.  
  22. ;;- Instruction patterns.  When multiple patterns apply,
  23. ;;- the first one in the file is chosen.
  24. ;;-
  25. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  26. ;;-
  27. ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  28. ;;- updates for most instructions.
  29.  
  30. ;; Put tstsi first among test insns so it matches a CONST_INT operand.
  31.  
  32. (define_insn "tstsi"
  33.   [(set (cc0)
  34.     (match_operand:SI 0 "register_operand" "r"))]
  35.   ""
  36.   "* return set_cmp (operands[0], const0_rtx, 'w');")
  37.  
  38. (define_insn "tsthi"
  39.   [(set (cc0)
  40.     (match_operand:HI 0 "register_operand" "r"))]
  41.   ""
  42.   "* return set_cmp (operands[0], const0_rtx, 'h');")
  43.  
  44. (define_expand "tstqi"
  45.   [(set (match_dup 1)
  46.     (sign_extend:SI (match_operand:QI 0 "register_operand" "r")))
  47.    (set (cc0)
  48.     (match_dup 1))]
  49.   ""
  50.   "operands[1] = gen_reg_rtx (SImode);")
  51.  
  52. (define_expand "tstdi"
  53.   [(parallel [(set (cc0) (match_operand:DI 0 "register_operand" "d"))
  54.           (use (match_dup 1))])]
  55.   ""
  56.   "operands[1] = force_reg (DImode, const0_rtx);")
  57.  
  58. (define_insn ""
  59.   [(set (cc0) (match_operand:DI 0 "register_operand" "d"))
  60.    (use (match_operand:DI 1 "register_operand" "d"))]
  61.   ""
  62.   "* return set_cmp (operands[0], operands[1], 'l');")
  63.  
  64. (define_expand "tstdf"
  65.   [(set (cc0)
  66.     (compare (match_operand:DF 0 "register_operand" "d")
  67.          (match_dup 1)))]
  68.   ""
  69.   "operands[1] = force_reg (DFmode, dconst0_rtx);")
  70.  
  71. (define_insn "tstsf"
  72.   [(set (cc0)
  73.     (match_operand:SF 0 "register_operand" "d"))]
  74.   ""
  75.   "* return set_cmp (operands[0], fconst0_rtx, 's');")
  76.  
  77. ;; Put cmpsi first among compare insns so it matches two CONST_INT operands.
  78.  
  79. (define_insn "cmpsi"
  80.   [(set (cc0)
  81.     (compare (match_operand:SI 0 "nonmemory_operand" "d,a,i,r")
  82.          (match_operand:SI 1 "nonmemory_operand" "d,a,r,i")))]
  83.   ""
  84.   "* return set_cmp (operands[0], operands[1], 'w');")
  85.  
  86. (define_insn "cmphi"
  87.   [(set (cc0)
  88.     (compare (match_operand:HI 0 "nonmemory_operand" "d,a,r,i")
  89.          (match_operand:HI 1 "nonmemory_operand" "d,a,i,r")))]
  90.   ""
  91.   "* return set_cmp (operands[0], operands[1], 'h');")
  92.  
  93. (define_insn "cmpqi"
  94.   [(set (cc0)
  95.     (compare (match_operand:QI 0 "register_operand" "d")
  96.          (match_operand:QI 1 "register_operand" "d")))]
  97.   ""
  98.   "* return set_cmp (operands[0], operands[1], 'b');")
  99.  
  100. (define_insn "cmpdi"
  101.   [(set (cc0)
  102.     (compare (match_operand:DI 0 "register_operand" "d")
  103.          (match_operand:DI 1 "register_operand" "d")))]
  104.   ""
  105.   "* return set_cmp (operands[0], operands[1], 'l');")
  106.  
  107. (define_insn "cmpdf"
  108.   [(set (cc0)
  109.     (compare (match_operand:DF 0 "register_operand" "d")
  110.          (match_operand:DF 1 "register_operand" "d")))]
  111.   ""
  112.   "* return set_cmp (operands[0], operands[1], 'd');")
  113.  
  114. (define_insn "cmpsf"
  115.   [(set (cc0)
  116.     (compare (match_operand:SF 0 "nonmemory_operand" "dF,d")
  117.          (match_operand:SF 1 "nonmemory_operand" "d,F")))]
  118.   ""
  119.   "* return set_cmp (operands[0], operands[1], 's');")
  120.  
  121. (define_insn "movtf"
  122.   [(set (match_operand:TF 0 "general_operand" "=g,d")
  123.     (match_operand:TF 1 "general_operand" "d,g"))]
  124.   ""
  125.   "*
  126. {
  127.   rtx opaddr = 0;
  128.   rtx xoperands[4];
  129.   xoperands[0] = operands[0];
  130.   xoperands[2] = operands[1];
  131.  
  132.   if (REG_P (operands[0]))
  133.     xoperands[1] = gen_rtx (REG, TFmode, REGNO (operands[0]) + 1);
  134.   else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
  135.     xoperands[1] = 0;
  136.   else if (offsettable_memref_p (operands[0]))
  137.     xoperands[1] = adj_offsettable_operand (operands[0], 8);
  138.   else
  139.     {
  140.       opaddr = XEXP (operands[0], 0);
  141.       xoperands[0] = gen_rtx (MEM, TFmode, gen_rtx (REG, SImode, 13));
  142.       xoperands[1] = adj_offsettable_operand (xoperands[0], 8);
  143.     }
  144.  
  145.   if (REG_P (operands[1]))
  146.     xoperands[3] = gen_rtx (REG, TFmode, REGNO (operands[1]) + 1);
  147.   else if (offsettable_memref_p (operands[1]))
  148.     xoperands[3] = adj_offsettable_operand (operands[1], 8);
  149.   else
  150.     {
  151.       opaddr = XEXP (operands[1], 0);
  152.       xoperands[2] = gen_rtx (MEM, TFmode, gen_rtx (REG, SImode, 13));
  153.       xoperands[3] = adj_offsettable_operand (xoperands[2], 8);
  154.     }
  155.  
  156.   if (opaddr)
  157.     output_asm_insn (\"psh.w a5\;ld.w %0,a5\", &opaddr);
  158.   if (push_operand (operands[0], TFmode))
  159.     output_asm_insn (\"psh.l %3\;psh.l %2\", xoperands);
  160.   else if (GET_CODE (operands[0]) == MEM)
  161.     output_asm_insn (\"st.l %2,%0\;st.l %3,%1\", xoperands);
  162.   else if (GET_CODE (operands[1]) == REG)
  163.     output_asm_insn (\"mov %2,%0\;mov %3,%1\", xoperands);
  164.   else
  165.     output_asm_insn (\"ld.l %2,%0\;ld.l %3,%1\", xoperands);
  166.   if (opaddr)
  167.     output_asm_insn (\"pop.w a5\");
  168.   return \"\";
  169. }")
  170.  
  171. (define_insn "movdf"
  172.   [(set (match_operand:DF 0 "general_operand" "=g,d")
  173.     (match_operand:DF 1 "general_operand" "d,dmG"))]
  174.   ""
  175.   "*
  176. {
  177.   if (push_operand (operands[0], DFmode))
  178.     return \"psh.l %1\";
  179.   else if (GET_CODE (operands[0]) == MEM)
  180.     return \"st.l %1,%0\";
  181.   else if (GET_CODE (operands[1]) == REG)
  182.     return \"mov %1,%0\";
  183.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_D_P (operands[1]))
  184.     {
  185.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  186.                  const_double_high_int (operands[1]));
  187.       return \"ld.d %1,%0\";
  188.     }
  189.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_L_P (operands[1]))
  190.     {
  191.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  192.                  const_double_low_int (operands[1]));
  193.       return \"ld.l %1,%0\";
  194.     }
  195.   else
  196.     return \"ld.l %1,%0\";
  197. }")
  198.  
  199. (define_insn "movsf"
  200.   [(set (match_operand:SF 0 "general_operand" "=g,d")
  201.     (match_operand:SF 1 "general_operand" "d,gF"))]
  202.   ""
  203.   "*
  204. {
  205.   if (push_operand (operands[0], SFmode))
  206.     return \"psh.w %1\";
  207.   else if (GET_CODE (operands[0]) == MEM)
  208.     return \"st.s %1,%0\";
  209.   else if (GET_CODE (operands[1]) == REG)
  210.     return \"mov.s %1,%0\";
  211.   else
  212.     return \"ld.s %1,%0\";
  213. }")
  214.  
  215. (define_insn "movdi"
  216.   [(set (match_operand:DI 0 "general_operand" "=g,d")
  217.     (match_operand:DI 1 "general_operand" "d,dmiG"))]
  218.   ""
  219.   "*
  220. {
  221.   if (push_operand (operands[0], DImode))
  222.     return \"psh.l %1\";
  223.   else if (GET_CODE (operands[0]) == MEM)
  224.     return \"st.l %1,%0\";
  225.   else if (GET_CODE (operands[1]) == REG)
  226.     return \"mov %1,%0\";
  227.   else if (GET_CODE (operands[1]) == CONST_DOUBLE && LD_D_P (operands[1]))
  228.     {
  229.       operands[1] = gen_rtx (CONST_INT, VOIDmode,
  230.                  const_double_high_int (operands[1]));
  231.       return \"ld.d %1,%0\";
  232.     }
  233.   else
  234.     return \"ld.l %1,%0\";
  235. }")
  236.  
  237. ;; Special case of movsi, needed to express A-reg preference.
  238.  
  239. (define_insn ""
  240.   [(set (match_operand:SI 0 "push_operand" "=<")
  241.     (plus:SI (match_operand:SI 1 "register_operand" "a")
  242.          (match_operand:SI 2 "immediate_operand" "i")))]
  243.   "operands[1] != stack_pointer_rtx"
  244.   "pshea %a2(%1)")
  245.  
  246. (define_insn "movsi"
  247.   [(set (match_operand:SI 0 "general_operand" "=g,r,<")
  248.     (match_operand:SI 1 "general_operand" "r,g,io"))]
  249.   ""
  250.   "*
  251. { 
  252.   if (push_operand (operands[0], SImode))
  253.     {
  254.       if (GET_CODE (operands[1]) == REG)
  255.     return \"psh.w %1\";
  256.       else
  257.         return \"pshea %a1\";
  258.     }
  259.   if (GET_CODE (operands[0]) == MEM)
  260.     return \"st.w %1,%0\";
  261.   if (GET_CODE (operands[1]) != REG)
  262.     return \"ld.w %1,%0\";
  263.   if (S_REG_P (operands[0]) && S_REG_P (operands[1]))
  264.     return \"mov.w %1,%0\";
  265.   return \"mov %1,%0\";
  266. }")
  267.  
  268. (define_insn "movstrictsi"
  269.   [(set (strict_low_part (match_operand:SI 0 "general_operand" "=g,r"))
  270.     (match_operand:SI 1 "general_operand" "r,g"))]
  271.   ""
  272.   "*
  273. { 
  274.   if (GET_CODE (operands[0]) == MEM)
  275.     return \"st.w %1,%0\";
  276.   if (GET_CODE (operands[1]) != REG)
  277.     return \"ld.w %1,%0\";
  278.   if (S_REG_P (operands[0]) && S_REG_P (operands[1]))
  279.     return \"mov.w %1,%0\";
  280.   return \"mov %1,%0\";
  281. }")
  282.  
  283. (define_insn "movhi"
  284.   [(set (match_operand:HI 0 "general_operand" "=g,r")
  285.     (match_operand:HI 1 "general_operand" "r,g"))]
  286.   ""
  287.   "*
  288. {
  289.   if (push_operand (operands[0], HImode))
  290.     abort ();
  291.   else if (GET_CODE (operands[0]) == MEM)
  292.     return \"st.h %1,%0\";
  293.   else if (GET_CODE (operands[1]) == REG) 
  294.     {
  295.       if (S_REG_P (operands[0]) && S_REG_P (operands[1]))
  296.     return \"mov.w %1,%0\";
  297.       else
  298.         return \"mov %1,%0\";
  299.     }
  300.   else if (GET_CODE (operands[1]) == CONST_INT)
  301.     return \"ld.w %1,%0\";
  302.   else
  303.     return \"ld.h %1,%0\";
  304. }")
  305.  
  306. (define_insn "movqi"
  307.   [(set (match_operand:QI 0 "general_operand" "=g,r")
  308.     (match_operand:QI 1 "general_operand" "r,g"))]
  309.   ""
  310.   "*
  311. {
  312.   if (push_operand (operands[0], QImode))
  313.     abort ();
  314.   else if (GET_CODE (operands[0]) == MEM)
  315.     return \"st.b %1,%0\";
  316.   else if (GET_CODE (operands[1]) == REG)
  317.     {
  318.       if (S_REG_P (operands[0]) && S_REG_P (operands[1]))
  319.     return \"mov.w %1,%0\";
  320.       else
  321.         return \"mov %1,%0\";
  322.     }
  323.   else if (GET_CODE (operands[1]) == CONST_INT)
  324.     return \"ld.w %1,%0\";
  325.   else
  326.     return \"ld.b %1,%0\";
  327. }")
  328.  
  329. ;; Extension and truncation insns.
  330. ;; Those for integer source operand
  331. ;; are ordered widest source type first.
  332.  
  333. (define_insn "truncsiqi2"
  334.   [(set (match_operand:QI 0 "register_operand" "=d,a")
  335.     (truncate:QI (match_operand:SI 1 "register_operand" "d,a")))]
  336.   ""
  337.   "cvtw.b %1,%0")
  338.  
  339. (define_insn "truncsihi2"
  340.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  341.     (truncate:HI (match_operand:SI 1 "register_operand" "d,a")))]
  342.   ""
  343.   "cvtw.h %1,%0")
  344.  
  345. (define_insn "trunchiqi2"
  346.   [(set (match_operand:QI 0 "register_operand" "=r")
  347.     (truncate:QI (match_operand:HI 1 "register_operand" "0")))]
  348.   ""
  349.   "")
  350.  
  351. (define_insn "truncdisi2"
  352.   [(set (match_operand:SI 0 "register_operand" "=d")
  353.     (truncate:SI (match_operand:DI 1 "register_operand" "d")))]
  354.   ""
  355.   "cvtl.w %1,%0")
  356.  
  357. (define_insn "extendsidi2"
  358.   [(set (match_operand:DI 0 "register_operand" "=d")
  359.     (sign_extend:DI (match_operand:SI 1 "register_operand" "d")))]
  360.   ""
  361.   "cvtw.l %1,%0")
  362.  
  363. (define_insn "extendhisi2"
  364.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  365.     (sign_extend:SI (match_operand:HI 1 "register_operand" "d,a")))]
  366.   ""
  367.   "cvth.w %1,%0")
  368.  
  369. (define_insn "extendqihi2"
  370.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  371.     (sign_extend:HI (match_operand:QI 1 "register_operand" "d,a")))]
  372.   ""
  373.   "cvtb.w %1,%0")
  374.  
  375. (define_insn "extendqisi2"
  376.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  377.     (sign_extend:SI (match_operand:QI 1 "register_operand" "d,a")))]
  378.   ""
  379.   "cvtb.w %1,%0")
  380.  
  381. (define_insn "extendsfdf2"
  382.   [(set (match_operand:DF 0 "register_operand" "=d")
  383.     (float_extend:DF (match_operand:SF 1 "register_operand" "d")))]
  384.   ""
  385.   "cvts.d %1,%0")
  386.  
  387. (define_insn "truncdfsf2"
  388.   [(set (match_operand:SF 0 "register_operand" "=d")
  389.     (float_truncate:SF (match_operand:DF 1 "register_operand" "d")))]
  390.   ""
  391.   "cvtd.s %1,%0")
  392.  
  393. (define_insn "zero_extendhisi2"
  394.   [(set (match_operand:SI 0 "register_operand" "=r")
  395.     (zero_extend:SI (match_operand:HI 1 "register_operand" "0")))]
  396.   ""
  397.   "and #0xffff,%0")
  398.  
  399. (define_insn "zero_extendqihi2"
  400.   [(set (match_operand:HI 0 "register_operand" "=r")
  401.     (zero_extend:HI (match_operand:QI 1 "register_operand" "0")))]
  402.   ""
  403.   "and #0xff,%0")
  404.  
  405. (define_insn "zero_extendqisi2"
  406.   [(set (match_operand:SI 0 "register_operand" "=r")
  407.     (zero_extend:SI (match_operand:QI 1 "register_operand" "0")))]
  408.   ""
  409.   "and #0xff,%0")
  410.  
  411. (define_insn "zero_extendsidi2"
  412.   [(set (match_operand:DI 0 "register_operand" "=d")
  413.     (zero_extend:DI (match_operand:SI 1 "register_operand" "0")))]
  414.   ""
  415.   "ld.u #0,%0")
  416.  
  417. ;; Fix-to-float conversion insns.
  418. ;; Note that the ones that start with SImode come first.
  419. ;; That is so that an operand that is a CONST_INT
  420. ;; (and therefore lacks a specific machine mode).
  421. ;; will be recognized as SImode (which is always valid)
  422. ;; rather than as QImode or HImode.
  423.  
  424. (define_insn "floatsisf2"
  425.   [(set (match_operand:SF 0 "register_operand" "=d")
  426.     (float:SF (match_operand:SI 1 "register_operand" "d")))]
  427.   ""
  428.   "cvtw.s %1,%0")
  429.  
  430. (define_insn "floatdisf2"
  431.   [(set (match_operand:SF 0 "register_operand" "=d")
  432.     (float:SF (match_operand:DI 1 "register_operand" "d")))]
  433.   ""
  434.   "cvtl.s %1,%0")
  435.  
  436. (define_insn "floatsidf2"
  437.   [(set (match_operand:DF 0 "register_operand" "=d")
  438.     (float:DF (match_operand:SI 1 "register_operand" "d")))]
  439.   "TARGET_C2"
  440.   "cvtw.d %1,%0")
  441.  
  442. (define_insn "floatdidf2"
  443.   [(set (match_operand:DF 0 "register_operand" "=d")
  444.     (float:DF (match_operand:DI 1 "register_operand" "d")))]
  445.   ""
  446.   "cvtl.d %1,%0")
  447.  
  448. ;; Float-to-fix conversion insns.
  449.  
  450. (define_insn "fix_truncsfsi2"
  451.   [(set (match_operand:SI 0 "register_operand" "=d")
  452.     (fix:SI (fix:SF (match_operand:SF 1 "register_operand" "d"))))]
  453.   ""
  454.   "cvts.w %1,%0")
  455.  
  456. (define_insn "fix_truncsfdi2"
  457.   [(set (match_operand:DI 0 "register_operand" "=d")
  458.     (fix:DI (fix:SF (match_operand:SF 1 "register_operand" "d"))))]
  459.   ""
  460.   "cvts.l %1,%0")
  461.  
  462. (define_insn "fix_truncdfsi2"
  463.   [(set (match_operand:SI 0 "register_operand" "=d")
  464.     (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "d"))))]
  465.   ""
  466.   "*
  467. {
  468.   if (TARGET_C2)
  469.     return \"cvtd.w %1,%0\";
  470.   return \"cvtd.l %1,%0\";
  471. }")
  472.  
  473. (define_insn "fix_truncdfdi2"
  474.   [(set (match_operand:DI 0 "register_operand" "=d")
  475.     (fix:DI (fix:DF (match_operand:DF 1 "register_operand" "d"))))]
  476.   ""
  477.   "cvtd.l %1,%0")
  478.  
  479. ;;- All kinds of add instructions.
  480.  
  481. (define_insn "adddf3"
  482.   [(set (match_operand:DF 0 "register_operand" "=d")
  483.     (plus:DF (match_operand:DF 1 "register_operand" "%0")
  484.          (match_operand:DF 2 "register_operand" "d")))]
  485.   ""
  486.   "add.d %2,%0")
  487.  
  488. (define_insn "addsf3"
  489.   [(set (match_operand:SF 0 "register_operand" "=d")
  490.     (plus:SF (match_operand:SF 1 "register_operand" "%0")
  491.          (match_operand:SF 2 "nonmemory_operand" "dF")))]
  492.   ""
  493.   "add.s %2,%0")
  494.  
  495. (define_insn "adddi3"
  496.   [(set (match_operand:DI 0 "register_operand" "=d")
  497.     (plus:DI (match_operand:DI 1 "register_operand" "%0")
  498.          (match_operand:DI 2 "register_operand" "d")))]
  499.   ""
  500.   "add.l %2,%0")
  501.  
  502. ;; special case of addsi3, needed to specify an A reg for the destination 
  503. ;; when the source is a sum involving FP or AP.
  504.  
  505. (define_insn ""
  506.   [(set (match_operand:SI 0 "register_operand" "=a")
  507.     (plus:SI (match_operand:SI 1 "register_operand" "%a")
  508.          (match_operand:SI 2 "immediate_operand" "i")))]
  509.   "operands[1] == frame_pointer_rtx || operands[1] == arg_pointer_rtx"
  510.   "ldea %a2(%1),%0")
  511.  
  512. (define_insn "addsi3"
  513.   [(set (match_operand:SI 0 "register_operand" "=d,a,a")
  514.     (plus:SI (match_operand:SI 1 "nonmemory_operand" "%0,0,a")
  515.          (match_operand:SI 2 "nonmemory_operand" "di,ri,i")))]
  516.   ""
  517.   "* switch (which_alternative) 
  518. {
  519.  case 0:
  520.  case 1: 
  521.    return \"add.w %2,%0\";
  522.  case 2:
  523.    if ((TARGET_C2 || A_REG_P (operands[0]))
  524.        && operands[1] != stack_pointer_rtx)
  525.      return \"ldea %a2(%1),%0\";
  526.    else
  527.      return \"mov %1,%0\;add.w %2,%0\";
  528. }")
  529.  
  530. (define_insn "addhi3"
  531.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  532.     (plus:HI (match_operand:HI 1 "register_operand" "%0,0")
  533.          (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  534.   ""
  535.   "add.h %2,%0")
  536.  
  537. (define_insn "addqi3"
  538.   [(set (match_operand:QI 0 "register_operand" "=d")
  539.     (plus:QI (match_operand:QI 1 "register_operand" "%0")
  540.          (match_operand:QI 2 "register_operand" "d")))]
  541.   ""
  542.   "add.b %2,%0")
  543.  
  544. ;;- All kinds of subtract instructions.
  545.  
  546. (define_insn "subdf3"
  547.   [(set (match_operand:DF 0 "register_operand" "=d")
  548.     (minus:DF (match_operand:DF 1 "register_operand" "0")
  549.           (match_operand:DF 2 "register_operand" "d")))]
  550.   ""
  551.   "sub.d %2,%0")
  552.  
  553. (define_insn "subsf3"
  554.   [(set (match_operand:SF 0 "register_operand" "=d")
  555.     (minus:SF (match_operand:SF 1 "register_operand" "0")
  556.           (match_operand:SF 2 "nonmemory_operand" "dF")))]
  557.   ""
  558.   "sub.s %2,%0")
  559.  
  560. (define_insn "subdi3"
  561.   [(set (match_operand:DI 0 "register_operand" "=d")
  562.     (minus:DI (match_operand:DI 1 "register_operand" "0")
  563.           (match_operand:DI 2 "register_operand" "d")))]
  564.   ""
  565.   "sub.l %2,%0")
  566.  
  567. (define_insn "subsi3"
  568.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  569.     (minus:SI (match_operand:SI 1 "register_operand" "0,0")
  570.           (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  571.   ""
  572.   "sub.w %2,%0")
  573.  
  574. (define_insn "subhi3"
  575.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  576.     (minus:HI (match_operand:HI 1 "register_operand" "0,0")
  577.           (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  578.   ""
  579.   "sub.h %2,%0")
  580.  
  581. (define_insn "subqi3"
  582.   [(set (match_operand:QI 0 "register_operand" "=d")
  583.     (minus:QI (match_operand:QI 1 "register_operand" "0")
  584.           (match_operand:QI 2 "register_operand" "d")))]
  585.   ""
  586.   "sub.b %2,%0")
  587.  
  588. ;;- Multiply instructions.
  589.  
  590. (define_insn "muldf3"
  591.   [(set (match_operand:DF 0 "register_operand" "=d")
  592.     (mult:DF (match_operand:DF 1 "register_operand" "%0")
  593.          (match_operand:DF 2 "register_operand" "d")))]
  594.   ""
  595.   "mul.d %2,%0")
  596.  
  597. (define_insn "mulsf3"
  598.   [(set (match_operand:SF 0 "register_operand" "=d")
  599.     (mult:SF (match_operand:SF 1 "register_operand" "%0")
  600.          (match_operand:SF 2 "nonmemory_operand" "dF")))]
  601.   ""
  602.   "mul.s %2,%0")
  603.  
  604. (define_insn "muldi3"
  605.   [(set (match_operand:DI 0 "register_operand" "=d")
  606.     (mult:DI (match_operand:DI 1 "register_operand" "%0")
  607.          (match_operand:DI 2 "register_operand" "d")))]
  608.   ""
  609.   "mul.l %2,%0")
  610.  
  611. (define_insn "mulsi3"
  612.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  613.     (mult:SI (match_operand:SI 1 "register_operand" "%0,0")
  614.          (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  615.   ""
  616.   "mul.w %2,%0")
  617.  
  618. (define_insn "mulhi3"
  619.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  620.     (mult:HI (match_operand:HI 1 "register_operand" "%0,0")
  621.          (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  622.   ""
  623.   "mul.h %2,%0")
  624.  
  625. (define_insn "mulqi3"
  626.   [(set (match_operand:QI 0 "register_operand" "=d")
  627.     (mult:QI (match_operand:QI 1 "register_operand" "%0")
  628.          (match_operand:QI 2 "register_operand" "d")))]
  629.   ""
  630.   "mul.b %2,%0")
  631.  
  632. ;;- Divide instructions.
  633.  
  634. (define_insn "divdf3"
  635.   [(set (match_operand:DF 0 "register_operand" "=d")
  636.     (div:DF (match_operand:DF 1 "register_operand" "0")
  637.         (match_operand:DF 2 "register_operand" "d")))]
  638.   ""
  639.   "div.d %2,%0")
  640.  
  641. (define_insn "divsf3"
  642.   [(set (match_operand:SF 0 "register_operand" "=d")
  643.     (div:SF (match_operand:SF 1 "register_operand" "0")
  644.         (match_operand:SF 2 "nonmemory_operand" "dF")))]
  645.   ""
  646.   "div.s %2,%0")
  647.  
  648. (define_insn "divdi3"
  649.   [(set (match_operand:DI 0 "register_operand" "=d")
  650.     (div:DI (match_operand:DI 1 "register_operand" "0")
  651.         (match_operand:DI 2 "register_operand" "d")))]
  652.   ""
  653.   "div.l %2,%0")
  654.  
  655. (define_insn "udivdi3"
  656.   [(set (match_operand:DI 0 "register_operand" "=d")
  657.     (udiv:DI (match_operand:DI 1 "register_operand" "d")
  658.          (match_operand:DI 2 "register_operand" "d")))]
  659.   ""
  660.   "psh.l %2\;psh.l %1\;callq udiv64\;pop.l %0\;add.w #8,sp")
  661.  
  662. (define_insn "divsi3"
  663.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  664.     (div:SI (match_operand:SI 1 "register_operand" "0,0")
  665.         (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  666.   ""
  667.   "div.w %2,%0")
  668.  
  669. (define_insn "divhi3"
  670.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  671.     (div:HI (match_operand:HI 1 "register_operand" "0,0")
  672.         (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  673.   ""
  674.   "div.h %2,%0")
  675.  
  676. (define_insn "divqi3"
  677.   [(set (match_operand:QI 0 "register_operand" "=d")
  678.     (div:QI (match_operand:QI 1 "register_operand" "0")
  679.         (match_operand:QI 2 "register_operand" "d")))]
  680.   ""
  681.   "div.b %2,%0")
  682.  
  683. ;; - and, or, xor
  684.  
  685. (define_insn ""
  686.   [(set (match_operand:DI 0 "register_operand" "=d")
  687.     (and:DI (match_operand:DI 1 "register_operand" "%0")
  688.         (match_operand:DI 2 "immediate_operand" "Fn")))]
  689.   "GET_CODE (operands[2]) == CONST_INT
  690.    || (GET_CODE (operands[2]) == CONST_DOUBLE
  691.        && CONST_DOUBLE_HIGH (operands[2]) == -1)"
  692.   "and %2,%0")
  693.  
  694. (define_insn "anddi3"
  695.   [(set (match_operand:DI 0 "register_operand" "=d")
  696.     (and:DI (match_operand:DI 1 "register_operand" "%0")
  697.         (match_operand:DI 2 "register_operand" "d")))]
  698.   ""
  699.   "and %2,%0")
  700.  
  701. (define_insn "andsi3"
  702.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  703.     (and:SI (match_operand:SI 1 "register_operand" "%0,0")
  704.         (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  705.   ""
  706.   "and %2,%0")
  707.  
  708. (define_insn "andhi3"
  709.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  710.     (and:HI (match_operand:HI 1 "register_operand" "%0,0")
  711.         (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  712.   ""
  713.   "and %2,%0")
  714.  
  715. (define_insn "andqi3"
  716.   [(set (match_operand:QI 0 "register_operand" "=d,a")
  717.     (and:QI (match_operand:QI 1 "register_operand" "%0,0")
  718.         (match_operand:QI 2 "nonmemory_operand" "di,ai")))]
  719.   ""
  720.   "and %2,%0")
  721.  
  722. ;;- Bit set instructions.
  723.  
  724. (define_insn ""
  725.   [(set (match_operand:DI 0 "register_operand" "=d")
  726.     (ior:DI (match_operand:DI 1 "register_operand" "%0")
  727.         (match_operand:DI 2 "immediate_operand" "Fn")))]
  728.   "GET_CODE (operands[2]) == CONST_INT
  729.    || (GET_CODE (operands[2]) == CONST_DOUBLE
  730.        && CONST_DOUBLE_HIGH (operands[2]) == 0)"
  731.   "or %2,%0")
  732.  
  733. (define_insn "iordi3"
  734.   [(set (match_operand:DI 0 "register_operand" "=d")
  735.     (ior:DI (match_operand:DI 1 "register_operand" "%0")
  736.         (match_operand:DI 2 "register_operand" "d")))]
  737.   ""
  738.   "or %2,%0")
  739.  
  740. (define_insn "iorsi3"
  741.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  742.     (ior:SI (match_operand:SI 1 "register_operand" "%0,0")
  743.         (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  744.   ""
  745.   "or %2,%0")
  746.  
  747. (define_insn "iorhi3"
  748.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  749.     (ior:HI (match_operand:HI 1 "register_operand" "%0,0")
  750.         (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  751.   ""
  752.   "or %2,%0")
  753.  
  754. (define_insn "iorqi3"
  755.   [(set (match_operand:QI 0 "register_operand" "=d,a")
  756.     (ior:QI (match_operand:QI 1 "register_operand" "%0,0")
  757.         (match_operand:QI 2 "nonmemory_operand" "di,ai")))]
  758.   ""
  759.   "or %2,%0")
  760.  
  761. ;;- xor instructions.
  762.  
  763. (define_insn ""
  764.   [(set (match_operand:DI 0 "register_operand" "=d")
  765.     (xor:DI (match_operand:DI 1 "register_operand" "%0")
  766.         (match_operand:DI 2 "immediate_operand" "Fn")))]
  767.   "GET_CODE (operands[2]) == CONST_INT
  768.    || (GET_CODE (operands[2]) == CONST_DOUBLE
  769.        && CONST_DOUBLE_HIGH (operands[2]) == 0)"
  770.   "xor %2,%0")
  771.  
  772. (define_insn "xordi3"
  773.   [(set (match_operand:DI 0 "register_operand" "=d")
  774.     (xor:DI (match_operand:DI 1 "register_operand" "%0")
  775.         (match_operand:DI 2 "register_operand" "d")))]
  776.   ""
  777.   "xor %2,%0")
  778.  
  779. (define_insn "xorsi3"
  780.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  781.     (xor:SI (match_operand:SI 1 "register_operand" "%0,0")
  782.         (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  783.   ""
  784.   "xor %2,%0")
  785.  
  786. (define_insn "xorhi3"
  787.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  788.     (xor:HI (match_operand:HI 1 "register_operand" "%0,0")
  789.         (match_operand:HI 2 "nonmemory_operand" "di,ai")))]
  790.   ""
  791.   "xor %2,%0")
  792.  
  793. (define_insn "xorqi3"
  794.   [(set (match_operand:QI 0 "register_operand" "=d,a")
  795.     (xor:QI (match_operand:QI 1 "register_operand" "%0,0")
  796.         (match_operand:QI 2 "nonmemory_operand" "di,ai")))]
  797.   ""
  798.   "xor %2,%0")
  799.  
  800. (define_insn "negdf2"
  801.   [(set (match_operand:DF 0 "register_operand" "=d")
  802.     (neg:DF (match_operand:DF 1 "register_operand" "d")))]
  803.   ""
  804.   "neg.d %1,%0")
  805.  
  806. (define_insn "negsf2"
  807.   [(set (match_operand:SF 0 "register_operand" "=d")
  808.     (neg:SF (match_operand:SF 1 "register_operand" "d")))]
  809.   ""
  810.   "neg.s %1,%0")
  811.  
  812. (define_insn "negdi2"
  813.   [(set (match_operand:DI 0 "register_operand" "=d")
  814.     (neg:DI (match_operand:DI 1 "register_operand" "d")))]
  815.   ""
  816.   "neg.l %1,%0")
  817.  
  818. (define_insn "negsi2"
  819.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  820.     (neg:SI (match_operand:SI 1 "register_operand" "d,a")))]
  821.   ""
  822.   "neg.w %1,%0")
  823.  
  824. (define_insn "neghi2"
  825.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  826.     (neg:HI (match_operand:HI 1 "register_operand" "d,a")))]
  827.   ""
  828.   "neg.h %1,%0")
  829.  
  830. (define_insn "negqi2"
  831.   [(set (match_operand:QI 0 "register_operand" "=d")
  832.     (neg:QI (match_operand:QI 1 "register_operand" "d")))]
  833.   ""
  834.   "neg.b %1,%0")
  835.  
  836. (define_insn "one_cmpldi2"
  837.   [(set (match_operand:DI 0 "register_operand" "=d")
  838.     (not:DI (match_operand:DI 1 "register_operand" "d")))]
  839.   ""
  840.   "not %1,%0")
  841.  
  842. (define_insn "one_cmplsi2"
  843.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  844.     (not:SI (match_operand:SI 1 "register_operand" "d,a")))]
  845.   ""
  846.   "not %1,%0")
  847.  
  848. (define_insn "one_cmplhi2"
  849.   [(set (match_operand:HI 0 "register_operand" "=d,a")
  850.     (not:HI (match_operand:HI 1 "register_operand" "d,a")))]
  851.   ""
  852.   "not %1,%0")
  853.  
  854. (define_insn "one_cmplqi2"
  855.   [(set (match_operand:QI 0 "register_operand" "=d,a")
  856.     (not:QI (match_operand:QI 1 "register_operand" "d,a")))]
  857.   ""
  858.   "not %1,%0")
  859.  
  860. ;;- shifts
  861. ;;
  862. ;; Convex shift instructions are logical shifts.
  863. ;; To make signed right shifts:
  864. ;; for SImode, sign extend to DImode and shift, works for 0..32
  865. ;; for DImode, shift and then extend the sign, works for 0..63 -- but not 64
  866.  
  867. (define_insn "lshlsi3"
  868.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  869.     (lshift:SI (match_operand:SI 1 "register_operand" "0,0")
  870.            (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  871.   ""
  872.   "*
  873. {
  874.   if (operands[2] == const1_rtx)
  875.     return \"add.w %0,%0\";
  876.   else if (TARGET_C2 && S_REG_P (operands[0]))
  877.     return \"shf.w %2,%0\";
  878.   else
  879.     return \"shf %2,%0\";
  880. }")
  881.  
  882. (define_insn "ashlsi3"
  883.   [(set (match_operand:SI 0 "register_operand" "=d,a")
  884.     (ashift:SI (match_operand:SI 1 "register_operand" "0,0")
  885.            (match_operand:SI 2 "nonmemory_operand" "di,ai")))]
  886.   ""
  887.   "*
  888. {
  889.   if (operands[2] == const1_rtx)
  890.     return \"add.w %0,%0\";
  891.   else if (TARGET_C2 && S_REG_P (operands[0]))
  892.     return \"shf.w %2,%0\";
  893.   else
  894.     return \"shf %2,%0\";
  895. }")
  896.  
  897. (define_expand "lshrsi3"
  898.   [(set (match_operand:SI 0 "register_operand" "")
  899.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "")
  900.              (neg:SI (match_operand:SI 2 "nonmemory_operand" ""))))]
  901.   ""
  902.   "operands[2] = negate_rtx (SImode, operands[2]);")
  903.  
  904. (define_insn ""
  905.   [(set
  906.     (match_operand:SI 0 "register_operand" "=d,a")
  907.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "0,0")
  908.          (neg:SI (match_operand:SI 2 "nonmemory_operand" "di,ai"))))]
  909.   ""
  910.   "*
  911. {
  912.   if (A_REG_P (operands[0]))
  913.     return \"shf %2,%0\";
  914.   else if (TARGET_C2)
  915.     return \"shf.w %2,%0\";
  916.   else
  917.     return \"ld.u #0,%0\;shf %2,%0\";
  918. }")
  919.  
  920. (define_insn ""
  921.   [(set
  922.     (match_operand:SI 0 "register_operand" "=r")
  923.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "0")
  924.          (match_operand:SI 2 "immediate_operand" "i")))]
  925.   ""
  926.   "*
  927. {
  928.   if (A_REG_P (operands[0]))
  929.     return \"shf #%n2,%0\";
  930.   else if (TARGET_C2)
  931.     return \"shf.w #%n2,%0\";
  932.   else
  933.     return \"ld.u #0,%0\;shf #%n2,%0\";
  934. }")
  935.  
  936. (define_expand "ashrsi3"
  937.   [(set (match_operand:SI 0 "register_operand" "=d")
  938.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "d")
  939.              (neg:SI (match_operand:SI 2 "nonmemory_operand" "di"))))]
  940.   ""
  941.   "operands[2] = negate_rtx (SImode, operands[2]);")
  942.  
  943. (define_insn ""
  944.   [(set (match_operand:SI 0 "register_operand" "=&d")
  945.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "d")
  946.              (neg:SI (match_operand:SI 2 "nonmemory_operand" "di"))))]
  947.   ""
  948.   "cvtw.l %1,%0\;shf %2,%0")
  949.  
  950. (define_insn ""
  951.   [(set (match_operand:SI 0 "register_operand" "=&d")
  952.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "d")
  953.              (match_operand:SI 2 "immediate_operand" "i")))]
  954.   ""
  955.   "cvtw.l %1,%0\;shf #%n2,%0")
  956.  
  957. (define_insn "lshldi3"
  958.   [(set (match_operand:DI 0 "register_operand" "=d")
  959.     (lshift:DI (match_operand:DI 1 "register_operand" "0")
  960.            (match_operand:SI 2 "nonmemory_operand" "di")))]
  961.   ""
  962.   "shf %2,%0")
  963.  
  964. (define_insn "ashldi3"
  965.   [(set (match_operand:DI 0 "register_operand" "=d")
  966.     (ashift:DI (match_operand:DI 1 "register_operand" "0")
  967.            (match_operand:SI 2 "nonmemory_operand" "di")))]
  968.   ""
  969.   "shf %2,%0")
  970.  
  971. (define_expand "lshrdi3"
  972.   [(set (match_operand:DI 0 "register_operand" "=d")
  973.     (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
  974.              (neg:SI (match_operand:SI 2 "nonmemory_operand" "di"))))]
  975.   ""
  976.   "operands[2] = negate_rtx (SImode, operands[2]);")
  977.  
  978. (define_insn ""
  979.   [(set (match_operand:DI 0 "register_operand" "=d")
  980.     (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
  981.              (neg:SI (match_operand:SI 2 "nonmemory_operand" "di"))))]
  982.   ""
  983.   "shf %2,%0")
  984.  
  985. (define_insn ""
  986.   [(set (match_operand:DI 0 "register_operand" "=d")
  987.     (lshiftrt:DI (match_operand:DI 1 "register_operand" "0")
  988.              (match_operand:SI 2 "immediate_operand" "i")))]
  989.   ""
  990.   "shf #%n2,%0")
  991.  
  992. ;; signed  a >> b  is
  993. ;;     ((a >> b) ^ signbit) - signbit
  994. ;; where signbit is (1 << 63) >> b
  995.  
  996. (define_expand "ashrdi3"
  997.   [(match_operand:DI 0 "register_operand" "")
  998.    (match_operand:DI 1 "register_operand" "")
  999.    (match_operand:SI 2 "nonmemory_operand" "")
  1000.    (match_dup 3)]
  1001.   ""
  1002.   "
  1003. {
  1004.   if (GET_CODE (operands[2]) == CONST_INT)
  1005.     {
  1006.       int rshift = INTVAL (operands[2]);
  1007.       operands[3] =
  1008.     force_reg (DImode, immed_double_const (1 << (63 - rshift),
  1009.                            1 << (31 - rshift), DImode));
  1010.     }
  1011.   else
  1012.     {
  1013.       operands[3] =
  1014.       force_reg (DImode, immed_double_const (0, 1 << 31, DImode));
  1015.       emit_insn (gen_lshrdi3 (operands[3], operands[3], operands[2]));
  1016.     }
  1017.  
  1018.   emit_insn (gen_lshrdi3 (operands[0], operands[1], operands[2]));
  1019.   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
  1020.               gen_rtx (XOR, DImode, operands[0], operands[3])));
  1021.   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
  1022.               gen_rtx (MINUS, DImode, operands[0], operands[3])));
  1023.   DONE;
  1024. }")
  1025.  
  1026. ;; __builtin instructions
  1027.  
  1028. (define_insn "sqrtdf2"
  1029.   [(set (match_operand:DF 0 "register_operand" "=d")
  1030.     (sqrt:DF (match_operand:DF 1 "register_operand" "0")))]
  1031.   "TARGET_C2"
  1032.   "sqrt.d %0")
  1033.  
  1034. (define_insn "sqrtsf2"
  1035.   [(set (match_operand:SF 0 "register_operand" "=d")
  1036.     (sqrt:SF (match_operand:SF 1 "register_operand" "0")))]
  1037.   "TARGET_C2"
  1038.   "sqrt.s %0")
  1039.  
  1040. (define_insn ""
  1041.   [(set (match_operand:SI 0 "register_operand" "=d")
  1042.     (minus:SI (ffs:SI (match_operand:SI 1 "register_operand" "d"))
  1043.           (const_int 1)))]
  1044.   ""
  1045.   "tzc %1,%0\;le.w #32,%0\;jbrs.f .+6\;ld.w #-1,%0")
  1046.  
  1047. (define_expand "ffssi2"
  1048.   [(set (match_operand:SI 0 "register_operand" "=d")
  1049.     (minus:SI (ffs:SI (match_operand:SI 1 "register_operand" "d"))
  1050.           (const_int 1)))
  1051.    (set (match_dup 0)
  1052.     (plus:SI (match_dup 0)
  1053.          (const_int 1)))]
  1054.   ""
  1055.   "")
  1056.  
  1057. (define_insn "abssf2"
  1058.   [(set (match_operand:SF 0 "register_operand" "=d")
  1059.     (abs:SF (match_operand:SF 1 "register_operand" "0")))]
  1060.   ""
  1061.   "and #0x7fffffff,%0")
  1062.  
  1063. (define_expand "absdf2"
  1064.   [(set (subreg:DI (match_operand:DF 0 "register_operand" "=d") 0)
  1065.     (and:DI (subreg:DI (match_operand:DF 1 "register_operand" "d") 0)
  1066.         (match_dup 2)))]
  1067.   ""
  1068.   "operands[2] = force_reg (DImode,
  1069.                 immed_double_const (-1, 0x7fffffff, DImode));")
  1070.  
  1071. (define_insn "jump"
  1072.   [(set (pc)
  1073.     (label_ref (match_operand 0 "" "")))]
  1074.   ""
  1075.   "jbr %l0")
  1076.  
  1077. (define_insn "beq"
  1078.   [(set (pc)
  1079.     (if_then_else (eq (cc0)
  1080.               (const_int 0))
  1081.               (label_ref (match_operand 0 "" ""))
  1082.               (pc)))]
  1083.   ""
  1084.   "* return gen_cmp (operands[0], \"eq\", 't'); ")
  1085.  
  1086. (define_insn "bne"
  1087.   [(set (pc)
  1088.     (if_then_else (ne (cc0)
  1089.               (const_int 0))
  1090.               (label_ref (match_operand 0 "" ""))
  1091.               (pc)))]
  1092.   ""
  1093.   "* return gen_cmp (operands[0], \"eq\", 'f'); ")
  1094.  
  1095. (define_insn "bgt"
  1096.   [(set (pc)
  1097.     (if_then_else (gt (cc0)
  1098.               (const_int 0))
  1099.               (label_ref (match_operand 0 "" ""))
  1100.               (pc)))]
  1101.   ""
  1102.   "* return gen_cmp (operands[0], \"le\", 'f'); ")
  1103.  
  1104. (define_insn "bgtu"
  1105.   [(set (pc)
  1106.     (if_then_else (gtu (cc0)
  1107.                (const_int 0))
  1108.               (label_ref (match_operand 0 "" ""))
  1109.               (pc)))]
  1110.   ""
  1111.   "* return gen_cmp (operands[0], \"leu\", 'f'); ")
  1112.  
  1113. (define_insn "blt"
  1114.   [(set (pc)
  1115.     (if_then_else (lt (cc0)
  1116.               (const_int 0))
  1117.               (label_ref (match_operand 0 "" ""))
  1118.               (pc)))]
  1119.   ""
  1120.   "* return gen_cmp (operands[0], \"lt\", 't'); ")
  1121.  
  1122. (define_insn "bltu"
  1123.   [(set (pc)
  1124.     (if_then_else (ltu (cc0)
  1125.                (const_int 0))
  1126.               (label_ref (match_operand 0 "" ""))
  1127.               (pc)))]
  1128.   ""
  1129.   "* return gen_cmp (operands[0], \"ltu\", 't'); ")
  1130.  
  1131. (define_insn "bge"
  1132.   [(set (pc)
  1133.     (if_then_else (ge (cc0)
  1134.               (const_int 0))
  1135.               (label_ref (match_operand 0 "" ""))
  1136.               (pc)))]
  1137.   ""
  1138.   "* return gen_cmp (operands[0], \"lt\", 'f'); ")
  1139.  
  1140. (define_insn "bgeu"
  1141.   [(set (pc)
  1142.     (if_then_else (geu (cc0)
  1143.                (const_int 0))
  1144.               (label_ref (match_operand 0 "" ""))
  1145.               (pc)))]
  1146.   ""
  1147.   "* return gen_cmp (operands[0], \"ltu\", 'f'); ")
  1148.  
  1149. (define_insn "ble"
  1150.   [(set (pc)
  1151.     (if_then_else (le (cc0)
  1152.               (const_int 0))
  1153.               (label_ref (match_operand 0 "" ""))
  1154.               (pc)))]
  1155.   ""
  1156.   "* return gen_cmp (operands[0], \"le\", 't'); ")
  1157.  
  1158. (define_insn "bleu"
  1159.   [(set (pc)
  1160.     (if_then_else (leu (cc0)
  1161.                (const_int 0))
  1162.               (label_ref (match_operand 0 "" ""))
  1163.               (pc)))]
  1164.   ""
  1165.   "* return gen_cmp (operands[0], \"leu\", 't'); ")
  1166.  
  1167. (define_insn ""
  1168.   [(set (pc)
  1169.     (if_then_else (eq (cc0)
  1170.               (const_int 0))
  1171.               (pc)
  1172.               (label_ref (match_operand 0 "" ""))))]
  1173.   ""
  1174.   "* return gen_cmp (operands[0], \"eq\", 'f'); ")
  1175.  
  1176. (define_insn ""
  1177.   [(set (pc)
  1178.     (if_then_else (ne (cc0)
  1179.               (const_int 0))
  1180.               (pc)
  1181.               (label_ref (match_operand 0 "" ""))))]
  1182.   ""
  1183.   "* return gen_cmp (operands[0], \"eq\", 't'); ")
  1184.  
  1185. (define_insn ""
  1186.   [(set (pc)
  1187.     (if_then_else (gt (cc0)
  1188.               (const_int 0))
  1189.               (pc)
  1190.               (label_ref (match_operand 0 "" ""))))]
  1191.   ""
  1192.   "* return gen_cmp (operands[0], \"le\", 't'); ")
  1193.  
  1194. (define_insn ""
  1195.   [(set (pc)
  1196.     (if_then_else (gtu (cc0)
  1197.                (const_int 0))
  1198.               (pc)
  1199.               (label_ref (match_operand 0 "" ""))))]
  1200.   ""
  1201.   "* return gen_cmp (operands[0], \"leu\", 't'); ")
  1202.  
  1203. (define_insn ""
  1204.   [(set (pc)
  1205.     (if_then_else (lt (cc0)
  1206.               (const_int 0))
  1207.               (pc)
  1208.               (label_ref (match_operand 0 "" ""))))]
  1209.   ""
  1210.   "* return gen_cmp (operands[0], \"lt\", 'f'); ")
  1211.  
  1212. (define_insn ""
  1213.   [(set (pc)
  1214.     (if_then_else (ltu (cc0)
  1215.                (const_int 0))
  1216.               (pc)
  1217.               (label_ref (match_operand 0 "" ""))))]
  1218.   ""
  1219.   "* return gen_cmp (operands[0], \"ltu\", 'f'); ")
  1220.  
  1221. (define_insn ""
  1222.   [(set (pc)
  1223.     (if_then_else (ge (cc0)
  1224.               (const_int 0))
  1225.               (pc)
  1226.               (label_ref (match_operand 0 "" ""))))]
  1227.   ""
  1228.   "* return gen_cmp (operands[0], \"lt\", 't'); ")
  1229.  
  1230. (define_insn ""
  1231.   [(set (pc)
  1232.     (if_then_else (geu (cc0)
  1233.                (const_int 0))
  1234.               (pc)
  1235.               (label_ref (match_operand 0 "" ""))))]
  1236.   ""
  1237.   "* return gen_cmp (operands[0], \"ltu\", 't'); ")
  1238.  
  1239. (define_insn ""
  1240.   [(set (pc)
  1241.     (if_then_else (le (cc0)
  1242.               (const_int 0))
  1243.               (pc)
  1244.               (label_ref (match_operand 0 "" ""))))]
  1245.   ""
  1246.   "* return gen_cmp (operands[0], \"le\", 'f'); ")
  1247.  
  1248. (define_insn ""
  1249.   [(set (pc)
  1250.     (if_then_else (leu (cc0)
  1251.                (const_int 0))
  1252.               (pc)
  1253.               (label_ref (match_operand 0 "" ""))))]
  1254.   ""
  1255.   "* return gen_cmp (operands[0], \"leu\", 'f'); ")
  1256.  
  1257. ;;  - Calls
  1258. ;;
  1259. ;; arg count word may be omitted to save a push and let gcc try to
  1260. ;; combine the arg list pop.  RETURN_POPS_ARGS from tm.h decides this.
  1261.  
  1262. (define_insn "call"
  1263.   [(call (match_operand:QI 0 "memory_operand" "m")
  1264.      (match_operand:SI 1 "general_operand" "g"))]
  1265.   ""
  1266.   "*
  1267. {
  1268.   if (! RETURN_POPS_ARGS (ignoreme)) 
  1269.     {
  1270.       if (operands[1] == const0_rtx)
  1271.     return \"calls %0\";
  1272.       if (! reg_mentioned_p (arg_pointer_rtx, operands[0]))
  1273.     return \"mov sp,ap\;calls %0\;ld.w 12(fp),ap\";
  1274.       operands[0] = XEXP (operands[0], 0);
  1275.       return \"ld.w %0,a1\;mov sp,ap\;calls (a1)\;ld.w 12(fp),ap\";
  1276.     }
  1277.   operands[1] = gen_rtx (CONST_INT, VOIDmode, (INTVAL (operands[1]) + 3)/ 4);
  1278.   if (! reg_mentioned_p (arg_pointer_rtx, operands[0]))
  1279.     return \"mov sp,ap\;pshea %a1\;calls %0\;ld.w 12(fp),ap\;add.w #4*%a1+4,sp\";
  1280.   operands[0] = XEXP (operands[0], 0);
  1281.   return \"ld.w %0,a1\;mov sp,ap\;pshea %a1\;calls (a1)\;ld.w 12(fp),ap\;add.w #4*%a1+4,sp\";
  1282. }")
  1283.  
  1284. (define_insn "call_value"
  1285.   [(set (match_operand 0 "" "=g")
  1286.     (call (match_operand:QI 1 "memory_operand" "m")
  1287.           (match_operand:SI 2 "general_operand" "g")))]
  1288.   ""
  1289.   "*
  1290. {
  1291.   if (! RETURN_POPS_ARGS (ignoreme)) 
  1292.     {
  1293.       if (operands[2] == const0_rtx)
  1294.     return \"calls %1\";
  1295.       if (! reg_mentioned_p (arg_pointer_rtx, operands[1]))
  1296.     return \"mov sp,ap\;calls %1\;ld.w 12(fp),ap\";
  1297.       operands[1] = XEXP (operands[1], 0);
  1298.       return \"ld.w %1,a1\;mov sp,ap\;calls (a1)\;ld.w 12(fp),ap\";
  1299.     }
  1300.   operands[2] = gen_rtx (CONST_INT, VOIDmode, (INTVAL (operands[2]) + 3) / 4);
  1301.   if (! reg_mentioned_p (arg_pointer_rtx, operands[1]))
  1302.     return \"mov sp,ap\;pshea %a2\;calls %1\;ld.w 12(fp),ap\;add.w #4*%a2+4,sp\";
  1303.   operands[1] = XEXP (operands[1], 0);
  1304.   return \"ld.w %1,a1\;mov sp,ap\;pshea %a2\;calls (a1)\;ld.w 12(fp),ap\;add.w #4*%a2+4,sp\";
  1305. }")
  1306.  
  1307. (define_insn "return"
  1308.   [(return)]
  1309.   ""
  1310.   "rtn")
  1311.  
  1312. (define_insn "nop"
  1313.   [(const_int 0)]
  1314.   ""
  1315.   "nop")
  1316.  
  1317. (define_insn "tablejump"
  1318.   [(set (pc) (match_operand:SI 0 "address_operand" "p"))
  1319.    (use (label_ref (match_operand 1 "" "")))]
  1320.   ""
  1321.   "jmp %a0")
  1322.  
  1323. ;; fix up the code generated for bit field tests
  1324.  
  1325. ;; cc0 = (x >> k1) & k2  -->  cc0 = x & (k2 << k1)
  1326. ;; cc0 = (x << k1) & k2  -->  cc0 = x & (k2 >> k1)  
  1327.  
  1328. (define_peephole
  1329.   [(set (match_operand:SI 0 "register_operand" "r")
  1330.     (lshift:SI (match_dup 0)
  1331.            (match_operand 1 "immediate_operand" "i")))
  1332.    (set (match_dup 0)
  1333.     (and:SI (match_dup 0)
  1334.         (match_operand 2 "immediate_operand" "i")))
  1335.    (set (cc0) (match_dup 0))]
  1336.   "dead_or_set_p (insn, operands[0])
  1337.    && GET_CODE (operands[1]) == CONST_INT
  1338.    && GET_CODE (operands[2]) == CONST_INT
  1339.    && next_insn_tests_no_inequality (insn)"
  1340.   "*
  1341. {
  1342.   operands[2] = gen_rtx (CONST_INT, VOIDmode, 
  1343.              INTVAL (operands[2]) >> INTVAL (operands[1]));
  1344.   output_asm_insn (\"and %2,%0\", operands);
  1345.   return set_cmp (operands[0], const0_rtx, 'w');
  1346. }")
  1347.  
  1348. (define_peephole
  1349.   [(set (match_operand:SI 0 "register_operand" "r")
  1350.     (lshiftrt:SI (match_dup 0)
  1351.              (match_operand 1 "immediate_operand" "i")))
  1352.    (set (match_dup 0)
  1353.     (and:SI (match_dup 0)
  1354.         (match_operand 2 "immediate_operand" "i")))
  1355.    (set (cc0) (match_dup 0))]
  1356.   "dead_or_set_p (insn, operands[0])
  1357.    && GET_CODE (operands[1]) == CONST_INT
  1358.    && GET_CODE (operands[2]) == CONST_INT
  1359.    && next_insn_tests_no_inequality (insn)"
  1360.   "*
  1361. {
  1362.   operands[2] = gen_rtx (CONST_INT, VOIDmode, 
  1363.              INTVAL (operands[2]) << INTVAL (operands[1]));
  1364.   output_asm_insn (\"and %2,%0\", operands);
  1365.   return set_cmp (operands[0], const0_rtx, 'w');
  1366. }")
  1367.  
  1368. ;; same as above where x is (y & 0xff...) caused by a zero extend
  1369.  
  1370. (define_peephole
  1371.   [(set (match_operand:SI 0 "register_operand" "r")
  1372.     (zero_extend:SI (match_operand 1 "register_operand" "0")))
  1373.    (set (match_dup 0)
  1374.     (lshift:SI (match_dup 0)
  1375.            (match_operand 2 "immediate_operand" "i")))
  1376.    (set (match_dup 0)
  1377.     (and:SI (match_dup 0)
  1378.         (match_operand 3 "immediate_operand" "i")))
  1379.    (set (cc0) (match_dup 0))]
  1380.   "dead_or_set_p (insn, operands[0])
  1381.    && REGNO (operands[0]) == REGNO (operands[1])
  1382.    && GET_CODE (operands[2]) == CONST_INT
  1383.    && GET_CODE (operands[3]) == CONST_INT
  1384.    && next_insn_tests_no_inequality (insn)"
  1385.   "*
  1386. {
  1387.   operands[3] = gen_rtx (CONST_INT, VOIDmode, 
  1388.              (INTVAL (operands[3]) >> INTVAL (operands[2])) &
  1389.              ~((-1) << GET_MODE_BITSIZE (GET_MODE (operands[1]))));
  1390.   output_asm_insn (\"and %3,%0\", operands);
  1391.   return set_cmp (operands[0], const0_rtx, 'w');
  1392. }")
  1393.  
  1394. (define_peephole
  1395.   [(set (match_operand:SI 0 "register_operand" "r")
  1396.     (zero_extend:SI (match_operand 1 "register_operand" "0")))
  1397.    (set (match_dup 0)
  1398.     (lshiftrt:SI (match_dup 0)
  1399.              (match_operand 2 "immediate_operand" "i")))
  1400.    (set (match_dup 0)
  1401.     (and:SI (match_dup 0)
  1402.         (match_operand 3 "immediate_operand" "i")))
  1403.    (set (cc0) (match_dup 0))]
  1404.   "dead_or_set_p (insn, operands[0])
  1405.    && REGNO (operands[0]) == REGNO (operands[1])
  1406.    && GET_CODE (operands[2]) == CONST_INT
  1407.    && GET_CODE (operands[3]) == CONST_INT
  1408.    && next_insn_tests_no_inequality (insn)"
  1409.   "*
  1410. {
  1411.   operands[3] = gen_rtx (CONST_INT, VOIDmode, 
  1412.              (INTVAL (operands[3]) << INTVAL (operands[2])) &
  1413.              ~((-1) << GET_MODE_BITSIZE (GET_MODE (operands[1]))));
  1414.   output_asm_insn (\"and %3,%0\", operands);
  1415.   return set_cmp (operands[0], const0_rtx, 'w');
  1416. }")
  1417.  
  1418. ;; same as above where AND optimized away
  1419.  
  1420. (define_peephole
  1421.   [(set (match_operand:SI 0 "register_operand" "r")
  1422.     (zero_extend:SI (match_operand 1 "register_operand" "0")))
  1423.    (set (match_dup 0)
  1424.     (lshiftrt:SI (match_dup 0)
  1425.              (match_operand 2 "immediate_operand" "i")))
  1426.    (set (cc0) (match_dup 0))]
  1427.   "dead_or_set_p (insn, operands[0])
  1428.    && REGNO (operands[0]) == REGNO (operands[1])
  1429.    && GET_CODE (operands[2]) == CONST_INT
  1430.    && next_insn_tests_no_inequality (insn)"
  1431.   "*
  1432. {
  1433.   operands[2] = gen_rtx (CONST_INT, VOIDmode, 
  1434.              ((-1) << INTVAL (operands[2])) &
  1435.              ~((-1) << GET_MODE_BITSIZE (GET_MODE (operands[1]))));
  1436.   output_asm_insn (\"and %2,%0\", operands);
  1437.   return set_cmp (operands[0], const0_rtx, 'w');
  1438. }")
  1439.  
  1440. ;;- Local variables:
  1441. ;;- mode:emacs-lisp
  1442. ;;- comment-start: ";;- "
  1443. ;;- eval: (set-syntax-table (copy-sequence (syntax-table)))
  1444. ;;- eval: (modify-syntax-entry ?[ "(]")
  1445. ;;- eval: (modify-syntax-entry ?] ")[")
  1446. ;;- eval: (modify-syntax-entry ?{ "(}")
  1447. ;;- eval: (modify-syntax-entry ?} "){")
  1448. ;;- End:
  1449.  
  1450.