home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / a29k.md < prev    next >
Text File  |  1991-06-04  |  77KB  |  2,718 lines
  1. ;;- Machine description for AMD Am29000 for GNU C compiler
  2. ;;   Copyright (C) 1988-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. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  22.  
  23. ;; The insns in this file are presented in the same order as the AMD 29000
  24. ;; User's Manual (i.e., alphabetical by machine op-code).
  25. ;;
  26. ;; DEFINE_EXPAND's are located near the first occurrance of the major insn
  27. ;; that they generate.
  28.  
  29. ;; The only attribute we have is the type.  We only care about calls, branches,
  30. ;; loads, stores, floating-point operations, and multi-word insns.
  31. ;; Everything else is miscellaneous.
  32.  
  33. (define_attr "type"
  34.   "call,branch,load,store,fadd,fmul,fam,fdiv,dmul,dam,ddiv,multi,misc"
  35.   (const_string "misc"))
  36.  
  37. ;; ASM insns cannot go into a delay slot, so call them "multi".
  38. (define_asm_attributes [(set_attr "type" "multi")])
  39.  
  40. (define_attr "in_delay_slot" "yes,no"
  41.   (if_then_else (eq_attr "type" "call,branch,multi")  (const_string "no")
  42.         (const_string "yes")))
  43.  
  44. ;; Branch and call insns require a single delay slot.  Annulling is not
  45. ;; supported.
  46. (define_delay (eq_attr "type" "call,branch")
  47.   [(eq_attr "in_delay_slot" "yes") (nil) (nil)])
  48.  
  49. ;; Define the function unit usages.  We first define memory as a unit.
  50. (define_function_unit "memory" 1 2 (eq_attr "type" "load") 6 11)
  51. (define_function_unit "memory" 1 2 (eq_attr "type" "store") 1 0)
  52.  
  53. ;; Now define the function units for the floating-point support.  Most
  54. ;; units are pipelined and can accept an input every cycle.
  55. ;;
  56. ;; Note that we have an inaccuracy here.  If a fmac insn is issued, followed
  57. ;; 2 cycles later by a fadd, there will be a conflict for the floating
  58. ;; adder that we can't represent.  Also, all insns will conflict for the
  59. ;; floating-point rounder.  It isn't clear how to represent this.
  60.  
  61. (define_function_unit "multiplier" 1 0 (eq_attr "type" "fmul") 3 0)
  62. (define_function_unit "multiplier" 1 0 (eq_attr "type" "dmul") 6 8)
  63. (define_function_unit "multiplier" 1 0 (eq_attr "type" "fam") 6 8)
  64. (define_function_unit "multiplier" 1 0 (eq_attr "type" "dam") 9 8)
  65.  
  66. (define_function_unit "adder" 1 0 (eq_attr "type" "fadd,fam,dam") 3 0)
  67.  
  68. (define_function_unit "divider" 1 1 (eq_attr "type" "fdiv") 11 20)
  69. (define_function_unit "divider" 1 1 (eq_attr "type" "ddiv") 18 34)
  70.  
  71. ;; ADD
  72. (define_insn "addsi3"
  73.   [(set (match_operand:SI 0 "gen_reg_operand" "=r,r")
  74.     (plus:SI (match_operand:SI 1 "gen_reg_operand" "%r,r")
  75.          (match_operand:SI 2 "add_operand" "rI,N")))]
  76.   ""
  77.   "@
  78.    add %0,%1,%2
  79.    sub %0,%1,%n2")
  80.  
  81. (define_insn "adddi3"
  82.   [(set (match_operand:DI 0 "gen_reg_operand" "=r")
  83.     (plus:DI (match_operand:DI 1 "gen_reg_operand" "%r")
  84.          (match_operand:DI 2 "gen_reg_operand" "r")))]
  85.   ""
  86.   "add %L0,%L1,%L2\;addc %0,%1,%2"
  87.   [(set_attr "type" "multi")])
  88.  
  89. ;; AND/ANDN
  90. (define_insn "andsi3"
  91.   [(set (match_operand:SI 0 "gen_reg_operand" "=r,r")
  92.     (and:SI (match_operand:SI 1 "gen_reg_operand" "%r,r")
  93.         (match_operand:SI 2 "and_operand" "rI,K")))]
  94.   ""
  95.   "@
  96.    and %0,%1,%2
  97.    andn %0,%1,%C2")
  98.  
  99. (define_insn ""
  100.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  101.     (and:SI (not:SI (match_operand:SI 1 "srcb_operand" "rI"))
  102.         (match_operand:SI 2 "gen_reg_operand" "r")))]
  103.   ""
  104.   "andn %0,%2,%1")
  105.  
  106.  
  107. ;; CALLI
  108. ;;
  109. ;; Start with a subroutine to write out CLOBBERs starting at lr2 up to,
  110. ;; but not including, the next parameter register.  If operand[0] is null,
  111. ;; it means that all the argument registers have been used.
  112. (define_expand "clobbers_to"
  113.   [(clobber (match_operand:SI 0 "" ""))]
  114.   ""
  115.   "
  116. {
  117.   int i;
  118.   int high_regno;
  119.  
  120.   if (operands[0] == 0)
  121.     high_regno = R_LR (18);
  122.   else if (GET_CODE (operands[0]) != REG || REGNO (operands[0]) < R_LR (0)
  123.        || REGNO (operands[0]) > R_LR (18))
  124.     abort ();
  125.   else
  126.     high_regno = REGNO (operands[0]);
  127.  
  128.   for (i = R_LR (2); i < high_regno; i++)
  129.     emit_insn (gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, i)));
  130.  
  131.   DONE;
  132. }")
  133.  
  134. (define_expand "call"
  135.   [(parallel [(call (match_operand:SI 0 "" "")
  136.             (match_operand 1 "" ""))
  137.           (clobber (reg:SI 32))])
  138.    (match_operand 2 "" "")]
  139.   ""
  140.   "
  141. {
  142.   if (GET_CODE (operands[0]) != MEM)
  143.     abort ();
  144.  
  145.   if (! TARGET_SMALL_MEMORY
  146.       && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
  147.     operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  148.                force_reg (Pmode, XEXP (operands[0], 0)));
  149.  
  150.   operands[2] = gen_clobbers_to (operands[2]);
  151. }")
  152.  
  153. (define_insn ""
  154.   [(call (match_operand:SI 0 "memory_operand" "m")
  155.      (match_operand 1 "" ""))
  156.    (clobber (reg:SI 32))]
  157.   ""
  158.   "calli lr0,%0%#"
  159.   [(set_attr "type" "call")])
  160.  
  161. (define_expand "call_value"
  162.   [(parallel [(set (match_operand:SI 0 "gen_reg_operand" "")
  163.            (call (match_operand:SI 1 "" "")
  164.              (match_operand 2 "" "")))
  165.            (clobber (reg:SI 32))])
  166.    (match_operand 3 "" "")]
  167.   ""
  168.   "
  169. {
  170.   if (GET_CODE (operands[1]) != MEM)
  171.     abort ();
  172.  
  173.   if (! TARGET_SMALL_MEMORY
  174.       && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
  175.     operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  176.                force_reg (Pmode, XEXP (operands[1], 0)));
  177.  
  178.   operands[3] = gen_clobbers_to (operands[3]);
  179. }")
  180.  
  181. (define_insn ""
  182.   [(set (match_operand 0 "gen_reg_operand" "=r")
  183.     (call (match_operand:SI 1 "memory_operand" "m")
  184.           (match_operand 2 "" "")))
  185.    (clobber (reg:SI 32))]
  186.   ""
  187.   "calli lr0,%1%#"
  188.   [(set_attr "type" "call")])
  189.  
  190. (define_insn ""
  191.   [(call (mem:SI (match_operand:SI 0 "immediate_operand" "i"))
  192.      (match_operand:SI 1 "general_operand" "g"))
  193.    (clobber (reg:SI 32))]
  194.   "GET_CODE (operands[0]) == SYMBOL_REF
  195.    && (TARGET_SMALL_MEMORY
  196.        || ! strcmp (XSTR (operands[0], 0), current_function_name))"
  197.   "call lr0,%F0"
  198.   [(set_attr "type" "call")])
  199.  
  200. (define_insn ""
  201.   [(set (match_operand 0 "gen_reg_operand" "=r")
  202.     (call (mem:SI (match_operand:SI 1 "immediate_operand" "i"))
  203.           (match_operand:SI 2 "general_operand" "g")))
  204.    (clobber (reg:SI 32))]
  205.   "GET_CODE (operands[1]) == SYMBOL_REF
  206.    && (TARGET_SMALL_MEMORY
  207.        || ! strcmp (XSTR (operands[1], 0), current_function_name))"
  208.   "call lr0,%F1"
  209.   [(set_attr "type" "call")])
  210.  
  211. (define_expand "probe"
  212.   [(call (mem:SI (symbol_ref:SI "_msp_check"))
  213.      (const_int 1))]
  214.   "TARGET_STACK_CHECK"
  215.   "")
  216.  
  217. ;; This is used for internal routine calls via TPC.  Currently used only
  218. ;; in probe, above.
  219. (define_insn ""
  220.   [(call (mem:SI (match_operand:SI 0 "immediate_operand" "s"))
  221.      (const_int 1))]
  222.   ""
  223.   "call %*,%0"
  224.   [(set_attr "type" "call")])
  225.  
  226. ;; CONST, CONSTH, CONSTN
  227. ;;
  228. ;; Many of these are generated from move insns.
  229. (define_insn ""
  230.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  231.     (and:SI (match_operand:SI 1 "immediate_operand" "i")
  232.         (const_int 65535)))]
  233.   ""
  234.   "const %0,%1")
  235.  
  236. (define_insn ""
  237.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  238.              (const_int 16)
  239.              (match_operand:SI 1 "const_0_operand" ""))
  240.     (ashiftrt:SI (match_operand:SI 2 "immediate_operand" "i")
  241.              (const_int 16)))]
  242.   ""
  243.   "consth %0,%2")
  244.  
  245. (define_insn ""
  246.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  247.              (const_int 16)
  248.              (match_operand:SI 1 "const_0_operand" ""))
  249.     (match_operand:SI 2 "cint_16_operand" "J"))]
  250.   ""
  251.   "*
  252. { operands[2] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) << 16);
  253.   return \"consth %0,%2\";
  254. }")
  255.  
  256. (define_insn ""
  257.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  258.     (ior:SI (and:SI (match_operand:SI 1 "gen_reg_operand" "0")
  259.             (const_int 65535))
  260.         (match_operand:SI 2 "const_int_operand" "n")))]
  261.   "(INTVAL (operands[1]) & 0xffff) == 0"
  262.   "consth %0,%2")
  263.  
  264. (define_insn ""
  265.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  266.     (ior:SI (and:SI (match_operand:SI 1 "gen_reg_operand" "0")
  267.             (const_int 65535))
  268.         (and:SI (match_operand:SI 2 "immediate_operand" "i")
  269.             (const_int -65536))))]
  270.   ""
  271.   "consth %0,%2")
  272.  
  273.  
  274. ;; CONVERT
  275. (define_insn "fix_truncsfsi2"
  276.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  277.     (fix:SI (match_operand:SF 1 "register_operand" "r")))]
  278.   ""
  279.   "convert %0,%1,0,3,0,1")
  280.  
  281. (define_insn "fix_truncdfsi2"
  282.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  283.     (fix:SI (match_operand:DF 1 "register_operand" "r")))]
  284.   ""
  285.   "convert %0,%1,0,3,0,2")
  286.  
  287. (define_insn "fixuns_truncsfsi2"
  288.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  289.     (unsigned_fix:SI (match_operand:SF 1 "register_operand" "r")))]
  290.   ""
  291.   "convert %0,%1,1,3,0,1")
  292.  
  293. (define_insn "fixuns_truncdfsi2"
  294.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  295.     (unsigned_fix:SI (match_operand:DF 1 "register_operand" "r")))]
  296.   ""
  297.   "convert %0,%1,1,3,0,2")
  298.  
  299. (define_insn "truncdfsf2"
  300.   [(set (match_operand:SF 0 "register_operand" "=r")
  301.     (float_truncate:SF (match_operand:DF 1 "register_operand" "r")))]
  302.   ""
  303.   "convert %0,%1,0,4,1,2")
  304.  
  305. (define_insn "extendsfdf2"
  306.   [(set (match_operand:DF 0 "register_operand" "=r")
  307.     (float_extend:DF (match_operand:SF 1 "register_operand" "r")))]
  308.   ""
  309.   "convert %0,%1,0,4,2,1")
  310.  
  311. (define_insn "floatsisf2"
  312.   [(set (match_operand:SF 0 "register_operand" "=r")
  313.     (float:SF (match_operand:SI 1 "gen_reg_operand" "r")))]
  314.   ""
  315.   "convert %0,%1,0,4,1,0")
  316.  
  317. (define_insn "floatsidf2"
  318.   [(set (match_operand:DF 0 "register_operand" "=r")
  319.     (float:DF (match_operand:SI 1 "gen_reg_operand" "r")))]
  320.   ""
  321.   "convert %0,%1,0,4,2,0")
  322.  
  323. (define_insn "floatunssisf2"
  324.   [(set (match_operand:SF 0 "register_operand" "=r")
  325.     (unsigned_float:SF (match_operand:SI 1 "gen_reg_operand" "r")))]
  326.   ""
  327.   "convert %0,%1,1,4,1,0")
  328.  
  329. (define_insn "floatunssidf2"
  330.   [(set (match_operand:DF 0 "register_operand" "=r")
  331.     (unsigned_float:DF (match_operand:SI 1 "gen_reg_operand" "r")))]
  332.   ""
  333.   "convert %0,%1,1,4,2,0")
  334.  
  335. ;; CPxxx, DEQ, DGT, DGE, FEQ, FGT, FGE
  336. (define_insn ""
  337.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  338.     (match_operator 3 "comparison_operator"
  339.             [(match_operand:SI 1 "gen_reg_operand" "r")
  340.              (match_operand:SI 2 "srcb_operand" "rI")]))]
  341.   ""
  342.   "cp%J3 %0,%1,%2")
  343.  
  344. (define_insn ""
  345.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  346.     (match_operator 3 "fp_comparison_operator"
  347.             [(match_operand:SF 1 "register_operand" "r")
  348.              (match_operand:SF 2 "register_operand" "r")]))]
  349.   ""
  350.   "f%J3 %0,%1,%2"
  351.   [(set_attr "type" "fadd")])
  352.  
  353. (define_insn ""
  354.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  355.     (match_operator 3 "fp_comparison_operator"
  356.             [(match_operand:DF 1 "register_operand" "r")
  357.              (match_operand:DF 2 "register_operand" "r")]))]
  358.   ""
  359.   "d%J3 %0,%1,%2"
  360.   [(set_attr "type" "fadd")])
  361.  
  362. ;; DADD
  363. (define_expand "adddf3"
  364.   [(set (match_operand:DF 0 "register_operand" "")
  365.     (plus:DF (match_operand:DF 1 "register_operand" "")
  366.          (match_operand:DF 2 "register_operand" "")))]
  367.   ""
  368.   "")
  369.  
  370. (define_insn ""
  371.   [(set (match_operand:DF 0 "register_operand" "=r")
  372.     (plus:DF (match_operand:DF 1 "register_operand" "%r")
  373.          (match_operand:DF 2 "register_operand" "r")))]
  374.   "! TARGET_29050 "
  375.   "dadd %0,%1,%2"
  376.   [(set_attr "type" "fadd")])
  377.  
  378. (define_insn ""
  379.   [(set (match_operand:DF 0 "register_operand" "=r,a")
  380.     (plus:DF (match_operand:DF 1 "register_operand" "%r,r")
  381.          (match_operand:DF 2 "register_operand" "r,0")))]
  382.   "TARGET_29050"
  383.   "@
  384.    dadd %0,%1,%2
  385.    dmac 8,%0,%1,0"
  386.   [(set_attr "type" "fadd,dam")])
  387.  
  388. ;; DDIV
  389. (define_insn "divdf3"
  390.   [(set (match_operand:DF 0 "register_operand" "=r")
  391.     (div:DF (match_operand:DF 1 "register_operand" "=r")
  392.         (match_operand:DF 2 "register_operand" "r")))]
  393.   ""
  394.   "ddiv %0,%1,%2"
  395.   [(set_attr "type" "ddiv")])
  396.  
  397. ;; DIVIDE
  398. ;;
  399. ;; We must set Q to the sign extension of the dividend first.  For MOD, we
  400. ;; must get the remainder from Q.
  401. ;;
  402. ;; For divmod: operand 1 is divided by operand 2; quotient goes to operand
  403. ;; 0 and remainder to operand 3.
  404. (define_expand "divmodsi4"
  405.   [(set (match_dup 4)
  406.     (ashiftrt:SI (match_operand:SI 1 "gen_reg_operand" "")
  407.              (const_int 31)))
  408.    (set (reg:SI 180)
  409.     (match_dup 4))
  410.    (parallel [(set (match_operand:SI 0 "gen_reg_operand" "")
  411.            (div:SI (match_dup 1)
  412.                (match_operand:SI 2 "gen_reg_operand" "")))
  413.           (set (reg:SI 180)
  414.            (mod:SI (match_dup 1)
  415.                (match_dup 2)))
  416.           (use (reg:SI 180))])
  417.    (set (match_operand:SI 3 "gen_reg_operand" "")
  418.     (reg:SI 180))]
  419.   ""
  420.   "
  421. {
  422.   operands[4] = gen_reg_rtx (SImode);
  423. }")
  424.  
  425. (define_insn ""
  426.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  427.     (div:SI (match_operand:SI 1 "gen_reg_operand" "r")
  428.         (match_operand:SI 2 "gen_reg_operand" "r")))
  429.    (set (reg:SI 180)
  430.     (mod:SI (match_dup 1)
  431.         (match_dup 2)))
  432.    (use (reg:SI 180))]
  433.   ""
  434.   "divide %0,%1,%2")
  435.  
  436. ;; DIVIDU
  437. ;;
  438. ;; Similar to DIVIDE.
  439. (define_expand "udivmodsi4"
  440.   [(set (reg:SI 180)
  441.     (const_int 0))
  442.    (parallel [(set (match_operand:SI 0 "gen_reg_operand" "")
  443.            (udiv:SI (match_operand:SI 1 "gen_reg_operand" "")
  444.                 (match_operand:SI 2 "gen_reg_operand" "")))
  445.           (set (reg:SI 180)
  446.            (umod:SI (match_dup 1)
  447.                 (match_dup 2)))
  448.           (use (reg:SI 180))])
  449.    (set (match_operand:SI 3 "gen_reg_operand" "")
  450.     (reg:SI 180))]
  451.   ""
  452.   "")
  453.  
  454. (define_insn ""
  455.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  456.     (udiv:SI (match_operand:SI 1 "gen_reg_operand" "r")
  457.          (match_operand:SI 2 "gen_reg_operand" "r")))
  458.    (set (reg:SI 180)
  459.     (umod:SI (match_dup 1)
  460.          (match_dup 2)))
  461.    (use (reg:SI 180))]
  462.   ""
  463.   "dividu %0,%1,%2")
  464.  
  465. ;; DMAC/DMSM
  466. (define_insn ""
  467.   [(set (match_operand:DF 0 "register_operand" "=a,*r")
  468.     (plus:DF (mult:DF (match_operand:DF 1 "register_operand" "%r,A")
  469.               (match_operand:DF 2 "register_operand" "r,r"))
  470.          (match_operand:DF 3 "register_operand" "0,*r")))]
  471.   "TARGET_29050"
  472.   "@
  473.    dmac 0,%0,%1,%2
  474.    dmsm %0,%2,%3"
  475.   [(set_attr "type" "dam")])
  476.  
  477. (define_insn ""
  478.   [(set (match_operand:DF 0 "register_operand" "=a")
  479.     (plus:DF (mult:DF (neg:DF (match_operand:DF 1 "register_operand" "r"))
  480.               (match_operand:DF 2 "register_operand" "r"))
  481.          (match_operand:DF 3 "register_operand" "0")))]
  482.   "TARGET_29050"
  483.   "dmac 1,%0,%2,%1"
  484.   [(set_attr "type" "dam")])
  485.  
  486. (define_insn ""
  487.   [(set (match_operand:DF 0 "register_operand" "=a")
  488.     (minus:DF (mult:DF (match_operand:DF 1 "register_operand" "%r")
  489.                (match_operand:DF 2 "register_operand" "r"))
  490.           (match_operand:DF 3 "register_operand" "0")))]
  491.   "TARGET_29050"
  492.   "dmac 2,%0,%1,%2"
  493.   [(set_attr "type" "dam")])
  494.  
  495. (define_insn ""
  496.   [(set (match_operand:DF 0 "register_operand" "=a")
  497.     (minus:DF (match_operand:DF 1 "register_operand" "0")
  498.           (mult:DF (match_operand:DF 2 "register_operand" "%r")
  499.                (match_operand:DF 3 "register_operand" "r"))))]
  500.   "TARGET_29050"
  501.   "dmac 2,%0,%2,%3"
  502.   [(set_attr "type" "dam")])
  503.  
  504. (define_insn ""
  505.   [(set (match_operand:DF 0 "register_operand" "=a")
  506.     (minus:DF (mult:DF (match_operand:DF 1 "register_operand" "r")
  507.                (neg:DF (match_operand:DF 2 "register_operand" "r")))
  508.           (match_operand:DF 3 "register_operand" "0")))]
  509.   "TARGET_29050"
  510.   "dmac 3,%0,%1,%2"
  511.   [(set_attr "type" "dam")])
  512.  
  513. (define_insn ""
  514.   [(set (match_operand:DF 0 "register_operand" "=a")
  515.     (minus:DF (match_operand:DF 1 "register_operand" "0")
  516.           (mult:DF (neg:DF (match_operand:DF 2 "register_operand" "r"))
  517.                (match_operand:DF 3 "register_operand" "r"))))]
  518.   "TARGET_29050"
  519.   "dmac 3,%0,%3,%2"
  520.   [(set_attr "type" "dam")])
  521.  
  522. (define_insn ""
  523.   [(set (match_operand:DF 0 "register_operand" "=a")
  524.     (mult:DF (neg:DF (match_operand:DF 1 "register_operand" "r"))
  525.          (match_operand:DF 2 "register_operand" "r")))]
  526.   "TARGET_29050"
  527.   "dmac 5,%0,%2,%1"
  528.   [(set_attr "type" "dam")])
  529.  
  530. (define_insn ""
  531.   [(set (match_operand:DF 0 "register_operand" "=a")
  532.     (minus:DF (neg:DF (match_operand:DF 1 "register_operand" "r"))
  533.           (match_operand:DF 2 "register_operand" "0")))]
  534.   "TARGET_29050"
  535.   "dmac 11,%0,%1,0"
  536.   [(set_attr "type" "dam")])
  537.  
  538. (define_insn ""
  539.   [(set (match_operand:DF 0 "register_operand" "=a")
  540.     (neg:DF (plus:DF (match_operand:DF 1 "register_operand" "%r")
  541.              (match_operand:DF 2 "register_operand" "0"))))]
  542.   "TARGET_29050"
  543.   "dmac 11,%0,%1,0"
  544.   [(set_attr "type" "dam")])
  545.  
  546. (define_insn ""
  547.  [(set (match_operand:DF 0 "register_operand" "=r,r,a")
  548.        (neg:DF (match_operand:DF 1 "register_operand" "0,r,r")))
  549.   (clobber (match_scratch:SI 2 "=&r,X"))]
  550.  "TARGET_29050"
  551.  "@
  552.   cpeq %2,gr1,gr1\;xor %0,%1,%2
  553.   cpeq %2,gr1,gr1\;xor %0,%1,%2\;sll %L0,%L1,0
  554.   dmac 13,%0,%1,0"
  555.  [(set_attr "type" "multi,multi,dam")])
  556.  
  557. ;; DMUL
  558. (define_expand "muldf3"
  559.   [(set (match_operand:DF 0 "register_operand" "")
  560.     (mult:DF (match_operand:DF 1 "register_operand" "")
  561.          (match_operand:DF 2 "register_operand" "")))]
  562.   ""
  563.   "")
  564.  
  565. (define_insn ""
  566.   [(set (match_operand:DF 0 "register_operand" "=r")
  567.     (mult:DF (match_operand:DF 1 "register_operand" "%r")
  568.          (match_operand:DF 2 "register_operand" "r")))]
  569.   "! TARGET_29050"
  570.   "dmul %0,%1,%2"
  571.   [(set_attr "type" "dmul")])
  572.  
  573. (define_insn ""
  574.   [(set (match_operand:DF 0 "register_operand" "=r,a")
  575.     (mult:DF (match_operand:DF 1 "register_operand" "%r,r")
  576.          (match_operand:DF 2 "register_operand" "r,r")))]
  577.   "TARGET_29050"
  578.   "@
  579.    dmul %0,%1,%2
  580.    dmac 4,%0,%1,%2"
  581.   [(set_attr "type" "dmul,dam")])
  582.  
  583. ;; DSUB
  584. (define_expand "subdf3"
  585.   [(set (match_operand:DF 0 "register_operand" "=r")
  586.     (minus:DF (match_operand:DF 1 "register_operand" "r")
  587.           (match_operand:DF 2 "register_operand" "r")))]
  588.   ""
  589.   "")
  590.  
  591. (define_insn ""
  592.   [(set (match_operand:DF 0 "register_operand" "=r")
  593.     (minus:DF (match_operand:DF 1 "register_operand" "r")
  594.           (match_operand:DF 2 "register_operand" "r")))]
  595.   "! TARGET_29050"
  596.   "dsub %0,%1,%2"
  597.   [(set_attr "type" "fadd")])
  598.  
  599. (define_insn ""
  600.   [(set (match_operand:DF 0 "register_operand" "=r,a,a")
  601.     (minus:DF (match_operand:DF 1 "register_operand" "r,0,r")
  602.           (match_operand:DF 2 "register_operand" "r,r,0")))]
  603.   "TARGET_29050"
  604.   "@
  605.    dsub %0,%1,%2
  606.    dmac 9,%0,%2,0
  607.    dmac 10,%0,%1,0"
  608.   [(set_attr "type" "fadd,dam,dam")])
  609.  
  610. ;; EXBYTE
  611. (define_insn ""
  612.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  613.     (ior:SI (and:SI (match_operand:SI 1 "srcb_operand" "rI")
  614.             (const_int -256))
  615.         (zero_extract:SI (match_operand:SI 2 "gen_reg_operand" "r")
  616.                  (const_int 8)
  617.                  (ashift:SI (match_operand:SI 3 "register_operand" "b")
  618.                         (const_int 3)))))]
  619.   ""
  620.   "exbyte %0,%2,%1")
  621.  
  622. (define_insn ""
  623.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  624.     (zero_extract:SI (match_operand:SI 1 "gen_reg_operand" "r")
  625.              (const_int 8)
  626.              (ashift:SI (match_operand:SI 2 "register_operand" "b")
  627.                     (const_int 3))))]
  628.   ""
  629.   "exbyte %0,%1,0")
  630.  
  631. (define_insn ""
  632.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  633.              (const_int 8)
  634.              (match_operand:SI 1 "const_24_operand" ""))
  635.     (zero_extract:SI (match_operand:SI 2 "gen_reg_operand" "r")
  636.              (const_int 8)
  637.              (ashift:SI (match_operand:SI 3 "register_operand" "b")
  638.                     (const_int 3))))]
  639.   ""
  640.   "exbyte %0,%2,%0")
  641.  
  642. (define_expand "extzv"
  643.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  644.     (zero_extract:SI (match_operand:SI 1 "gen_reg_operand" "")
  645.              (match_operand:SI 2 "general_operand" "")
  646.              (match_operand:SI 3 "general_operand" "")))]
  647.   ""
  648.   "
  649. {
  650.   int size, pos;
  651.  
  652.   if (GET_CODE (operands[2]) != CONST_INT
  653.       || GET_CODE (operands[3]) != CONST_INT)
  654.     FAIL;
  655.  
  656.   size = INTVAL (operands[2]);
  657.   pos = INTVAL (operands[3]);
  658.   if ((size != 8 && size != 16) || pos % size != 0)
  659.     FAIL;
  660.  
  661.   operands[3] = gen_rtx (ASHIFT, SImode,
  662.              force_reg (SImode,
  663.                     gen_rtx (CONST_INT, VOIDmode, pos / size)),
  664.              gen_rtx (CONST_INT, VOIDmode, 3));
  665. }")
  666.  
  667. (define_expand "extv"
  668.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  669.     (zero_extract:SI (match_operand:SI 1 "gen_reg_operand" "")
  670.              (match_operand:SI 2 "general_operand" "")
  671.              (match_operand:SI 3 "general_operand" "")))]
  672.   ""
  673.   "
  674. {
  675.   int pos;
  676.  
  677.   if (GET_CODE (operands[2]) != CONST_INT
  678.       || GET_CODE (operands[3]) != CONST_INT)
  679.     FAIL;
  680.  
  681.   pos = INTVAL (operands[3]);
  682.   if (INTVAL (operands[2]) != 16 || pos % 16 != 0)
  683.     FAIL;
  684.  
  685.   operands[3] = gen_rtx (ASHIFT, SImode,
  686.              force_reg (SImode,
  687.                     gen_rtx (CONST_INT, VOIDmode, pos / 16)),
  688.              gen_rtx (CONST_INT, VOIDmode, 3));
  689. }")
  690.  
  691. ;; EXHW
  692. (define_insn ""
  693.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  694.     (ior:SI (and:SI (match_operand:SI 1 "srcb_operand" "rI")
  695.         (const_int -65536))
  696.         (zero_extract:SI (match_operand:SI 2 "gen_reg_operand" "r")
  697.                  (const_int 16)
  698.                  (ashift:SI (match_operand:SI 3 "register_operand" "b")
  699.                         (const_int 3)))))]
  700.   ""
  701.   "exhw %0,%2,%1")
  702.  
  703. (define_insn ""
  704.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  705.     (zero_extract:SI (match_operand:SI 1 "gen_reg_operand" "r")
  706.              (const_int 16)
  707.              (ashift:SI (match_operand:SI 2 "register_operand" "b")
  708.                     (const_int 3))))]
  709.   ""
  710.   "exhw %0,%1,0")
  711.  
  712. (define_insn ""
  713.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  714.              (const_int 16)
  715.              (match_operand:SI 1 "const_16_operand" ""))
  716.     (zero_extract:SI (match_operand:SI 2 "gen_reg_operand" "r")
  717.              (const_int 16)
  718.              (ashift:SI (match_operand:SI 3 "register_operand" "b")
  719.                     (const_int 3))))]
  720.   ""
  721.   "exhw %0,%2,%0")
  722.  
  723. ;; EXHWS
  724. (define_insn ""
  725.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  726.     (sign_extract:SI (match_operand:SI 1 "gen_reg_operand" "r")
  727.              (const_int 16)
  728.              (ashift:SI (match_operand:SI 2 "register_operand" "b")
  729.                     (const_int 3))))]
  730.   ""
  731.   "exhws %0,%1")
  732.  
  733. ;; EXTRACT
  734. (define_insn ""
  735.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  736.     (rotate:SI (match_operand:SI 1 "gen_reg_operand" "r")
  737.            (reg:QI 178)))]
  738.   ""
  739.   "extract %0,%1,%1")
  740.  
  741. (define_expand "rotlsi3"
  742.   [(set (reg:QI 178)
  743.     (match_operand: SI 2 "gen_reg_or_immediate_operand" ""))
  744.    (set (match_operand:SI 0 "gen_reg_operand" "")
  745.     (rotate:SI (match_operand:SI 1 "gen_reg_operand" "")
  746.            (reg:QI 178)))]
  747.   ""
  748.   "
  749. { operands[2] = gen_lowpart (QImode, operands[2]); }")
  750.  
  751. ;; FADD
  752. (define_expand "addsf3"
  753.   [(set (match_operand:SF 0 "register_operand" "")
  754.     (plus:SF (match_operand:SF 1 "register_operand" "")
  755.          (match_operand:SF 2 "register_operand" "")))]
  756.   ""
  757.   "")
  758.  
  759. (define_insn ""
  760.   [(set (match_operand:SF 0 "register_operand" "=r")
  761.     (plus:SF (match_operand:SF 1 "register_operand" "%r")
  762.          (match_operand:SF 2 "register_operand" "r")))]
  763.   "! TARGET_29050"
  764.   "fadd %0,%1,%2"
  765.   [(set_attr "type" "fadd")])
  766.  
  767. (define_insn ""
  768.   [(set (match_operand:SF 0 "register_operand" "=r,a")
  769.     (plus:SF (match_operand:SF 1 "register_operand" "%r,r")
  770.          (match_operand:SF 2 "register_operand" "r,0")))]
  771.   "TARGET_29050"
  772.   "@
  773.    fadd %0,%1,%2
  774.    fmac 8,%0,%1,0"
  775.   [(set_attr "type" "fadd,fam")])
  776.  
  777. ;; FDIV
  778. (define_insn "divsf3"
  779.   [(set (match_operand:SF 0 "register_operand" "=r")
  780.     (div:DF (match_operand:SF 1 "register_operand" "=r")
  781.         (match_operand:SF 2 "register_operand" "r")))]
  782.   ""
  783.   "fdiv %0,%1,%2"
  784.   [(set_attr "type" "fdiv")])
  785.  
  786. ;; FDMUL
  787. (define_insn ""
  788.   [(set (match_operand:DF 0 "register_operand" "=r")
  789.     (mult:DF (float_extend:DF (match_operand:SF 1 "register_operand" "%r"))
  790.          (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  791.   ""
  792.   "fdmul %0,%1,%2")
  793.  
  794. ;; FMAC/FMSM
  795. (define_insn ""
  796.   [(set (match_operand:SF 0 "register_operand" "=a,*r")
  797.     (plus:SF (mult:SF (match_operand:SF 1 "register_operand" "%r,A")
  798.               (match_operand:SF 2 "register_operand" "r,r"))
  799.          (match_operand:SF 3 "register_operand" "0,*r")))]
  800.   "TARGET_29050"
  801.   "@
  802.    fmac 0,%0,%1,%2
  803.    fmsm %0,%2,%3"
  804.   [(set_attr "type" "fam")])
  805.  
  806. (define_insn ""
  807.   [(set (match_operand:SF 0 "register_operand" "=a")
  808.     (plus:SF (mult:SF (neg:SF (match_operand:SF 1 "register_operand" "r"))
  809.               (match_operand:SF 2 "register_operand" "r"))
  810.          (match_operand:SF 3 "register_operand" "0")))]
  811.   "TARGET_29050"
  812.   "fmac 1,%0,%2,%1"
  813.   [(set_attr "type" "fam")])
  814.  
  815. (define_insn ""
  816.   [(set (match_operand:SF 0 "register_operand" "=a")
  817.     (minus:SF (mult:SF (match_operand:SF 1 "register_operand" "%r")
  818.                (match_operand:SF 2 "register_operand" "r"))
  819.           (match_operand:SF 3 "register_operand" "0")))]
  820.   "TARGET_29050"
  821.   "fmac 2,%0,%1,%2"
  822.   [(set_attr "type" "fam")])
  823.  
  824. (define_insn ""
  825.   [(set (match_operand:SF 0 "register_operand" "=a")
  826.     (minus:SF (match_operand:SF 1 "register_operand" "0")
  827.           (mult:SF (match_operand:SF 2 "register_operand" "%r")
  828.                (match_operand:SF 3 "register_operand" "r"))))]
  829.   "TARGET_29050"
  830.   "fmac 2,%0,%2,%3"
  831.   [(set_attr "type" "fam")])
  832.  
  833. (define_insn ""
  834.   [(set (match_operand:SF 0 "register_operand" "=a")
  835.     (minus:SF (mult:SF (neg:SF (match_operand:SF 1 "register_operand" "r"))
  836.                (match_operand:SF 2 "register_operand" "r"))
  837.           (match_operand:SF 3 "register_operand" "0")))]
  838.   "TARGET_29050"
  839.   "fmac 3,%0,%2,%1"
  840.   [(set_attr "type" "fam")])
  841.  
  842. (define_insn ""
  843.   [(set (match_operand:SF 0 "register_operand" "=a")
  844.     (minus:SF (match_operand:SF 1 "register_operand" "0")
  845.           (mult:SF (neg:SF (match_operand:SF 2 "register_operand" "r"))
  846.                (match_operand:SF 3 "register_operand" "r"))))]
  847.   "TARGET_29050"
  848.   "fmac 3,%0,%3,%2"
  849.   [(set_attr "type" "fam")])
  850.  
  851. (define_insn ""
  852.   [(set (match_operand:SF 0 "register_operand" "=a")
  853.     (mult:SF (neg:SF (match_operand:SF 1 "register_operand" "r"))
  854.          (match_operand:SF 2 "register_operand" "r")))]
  855.   "TARGET_29050"
  856.   "fmac 5,%0,%2,%1"
  857.   [(set_attr "type" "fam")])
  858.  
  859. (define_insn ""
  860.   [(set (match_operand:SF 0 "register_operand" "=a")
  861.     (minus:SF (neg:SF (match_operand:SF 1 "register_operand" "%r"))
  862.           (match_operand:SF 2 "register_operand" "0")))]
  863.   "TARGET_29050"
  864.   "fmac 11,%0,%1,0"
  865.   [(set_attr "type" "fam")])
  866.  
  867. (define_insn ""
  868.   [(set (match_operand:SF 0 "register_operand" "=a")
  869.     (neg:SF (plus:SF (match_operand:SF 1 "register_operand" "%r")
  870.              (match_operand:SF 2 "register_operand" "0"))))]
  871.   "TARGET_29050"
  872.   "fmac 11,%0,%1,0"
  873.   [(set_attr "type" "fam")])
  874.  
  875. (define_insn ""
  876.   [(set (match_operand:SF 0 "register_operand" "=r,a")
  877.     (neg:SF (match_operand:SF 1 "register_operand" "r,r")))
  878.    (clobber (match_scratch:SI 2 "=&r,X"))]
  879.   "TARGET_29050"
  880.   "@
  881.    cpeq %2,gr1,gr1\;xor %0,%1,%2
  882.    fmac 13,%0,%1,0"
  883.   [(set_attr "type" "multi,fam")])
  884.  
  885. ;; FMUL
  886. (define_expand "mulsf3"
  887.   [(set (match_operand:SF 0 "register_operand" "")
  888.     (mult:SF (match_operand:SF 1 "register_operand" "")
  889.          (match_operand:SF 2 "register_operand" "")))]
  890.   ""
  891.   "")
  892.  
  893. (define_insn ""
  894.   [(set (match_operand:SF 0 "register_operand" "=r")
  895.     (mult:SF (match_operand:SF 1 "register_operand" "%r")
  896.          (match_operand:SF 2 "register_operand" "r")))]
  897.   "! TARGET_29050"
  898.   "fmul %0,%1,%2"
  899.   [(set_attr "type" "fmul")])
  900.  
  901. (define_insn ""
  902.   [(set (match_operand:SF 0 "register_operand" "=r,a")
  903.     (mult:SF (match_operand:SF 1 "register_operand" "%r,r")
  904.          (match_operand:SF 2 "register_operand" "r,r")))]
  905.   "TARGET_29050"
  906.   "@
  907.    fmul %0,%1,%2
  908.    fmac 4,%0,%1,%2"
  909.   [(set_attr "type" "fmul,fam")])
  910.  
  911. ;; FSUB
  912. (define_expand "subsf3"
  913.   [(set (match_operand:SF 0 "register_operand" "")
  914.     (minus:SF (match_operand:SF 1 "register_operand" "")
  915.           (match_operand:SF 2 "register_operand" "")))]
  916.   ""
  917.   "")
  918.  
  919. (define_insn ""
  920.   [(set (match_operand:SF 0 "register_operand" "=r")
  921.     (minus:SF (match_operand:SF 1 "register_operand" "r")
  922.           (match_operand:SF 2 "register_operand" "r")))]
  923.   "! TARGET_29050"
  924.   "fsub %0,%1,%2"
  925.   [(set_attr "type" "fadd")])
  926.  
  927. (define_insn ""
  928.   [(set (match_operand:SF 0 "register_operand" "=r,a,a")
  929.     (minus:SF (match_operand:SF 1 "register_operand" "r,0,r")
  930.           (match_operand:SF 2 "register_operand" "r,r,0")))]
  931.   "TARGET_29050"
  932.   "@
  933.    fsub %0,%1,%2
  934.    fmac 9,%0,%2,0
  935.    fmac 10,%0,%1,0"
  936.   [(set_attr "type" "fadd,fam,fam")])
  937.  
  938. ;; INBYTE
  939. (define_insn ""
  940.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  941.              (const_int 8)
  942.              (ashift:SI (match_operand:SI 2 "register_operand" "b")
  943.                     (const_int 3)))
  944.     (match_operand:SI 1 "srcb_operand" "rI"))]
  945.   ""
  946.   "inbyte %0,%0,%1")
  947.  
  948. (define_insn ""
  949.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  950.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 255)
  951.                        (ashift:SI (match_operand:SI 3 "register_operand" "b")
  952.                               (const_int 3))))
  953.             (match_operand:SI 1 "gen_reg_operand" "r"))
  954.         (ashift:SI (and:SI (match_operand:SI 2 "srcb_operand" "rI")
  955.                    (const_int 255))
  956.                (match_operand:SI 3 "const_24_operand" ""))))]
  957.   ""
  958.   "inbyte %0,%1,%2")
  959.  
  960. (define_insn ""
  961.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  962.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 255)
  963.                        (ashift:SI (match_operand:SI 3 "register_operand" "b")
  964.                               (const_int 3))))
  965.             (match_operand:SI 1 "gen_reg_operand" "r"))
  966.         (ashift:SI (match_operand:SI 2 "srcb_operand" "rI")
  967.                (match_operand:SI 3 "const_24_operand" ""))))]
  968.   ""
  969.   "inbyte %0,%1,%2")
  970.  
  971. ;; INHW
  972. (define_insn ""
  973.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "+r")
  974.              (const_int 16)
  975.              (ashift:SI (match_operand:SI 2 "register_operand" "b")
  976.                     (const_int 3)))
  977.     (match_operand:SI 1 "srcb_operand" "rI"))]
  978.   ""
  979.   "inhw %0,%0,%1")
  980.  
  981. (define_insn ""
  982.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  983.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 65535)
  984.                        (ashift:SI (match_operand:SI 3 "register_operand" "b")
  985.                               (const_int 3))))
  986.             (match_operand:SI 1 "gen_reg_operand" "r"))
  987.         (ashift:SI (and:SI (match_operand:SI 2 "srcb_operand" "rI")
  988.                    (const_int 65535))
  989.                (match_operand:SI 3 "const_24_operand" ""))))]
  990.   ""
  991.   "inhw %0,%1,%2")
  992.  
  993. (define_insn ""
  994.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  995.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 65535)
  996.                        (ashift:SI (match_operand:SI 3 "register_operand" "b")
  997.                               (const_int 3))))
  998.             (match_operand:SI 1 "gen_reg_operand" "r"))
  999.         (ashift:SI (match_operand:SI 2 "srcb_operand" "rI")
  1000.                (match_operand:SI 3 "const_24_operand" ""))))]
  1001.   ""
  1002.   "inhw %0,%1,%2")
  1003.  
  1004. (define_expand "insv"
  1005.   [(set (zero_extract:SI (match_operand:SI 0 "gen_reg_operand" "")
  1006.              (match_operand:SI 1 "general_operand" "")
  1007.              (match_operand:SI 2 "general_operand" ""))
  1008.     (match_operand:SI 3 "srcb_operand" ""))]
  1009.   ""
  1010.   "
  1011. {
  1012.   int size, pos;
  1013.  
  1014.   if (GET_CODE (operands[1]) != CONST_INT
  1015.       || GET_CODE (operands[2]) != CONST_INT)
  1016.     FAIL;
  1017.  
  1018.   size = INTVAL (operands[1]);
  1019.   pos = INTVAL (operands[2]);
  1020.   if ((size != 8 && size != 16) || pos % size != 0)
  1021.     FAIL;
  1022.  
  1023.   operands[2] = gen_rtx (ASHIFT, SImode,
  1024.              force_reg (SImode,
  1025.                     gen_rtx (CONST_INT, VOIDmode, pos / size)),
  1026.              gen_rtx (CONST_INT, VOIDmode, 3));
  1027. }")
  1028.  
  1029. ;; LOAD (also used by move insn).
  1030. (define_insn ""
  1031.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1032.     (mem:SI (and:SI (match_operand:SI 1 "gen_reg_operand" "r")
  1033.             (const_int -4))))
  1034.    (set (reg:SI 177)
  1035.     (and:SI (match_dup 1)
  1036.         (const_int 3)))]
  1037.   "! TARGET_DW_ENABLE"
  1038.   "load 0,17,%0,%1"
  1039.   [(set_attr "type" "load")])
  1040.  
  1041. (define_insn ""
  1042.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1043.     (mem:SI (and:SI (match_operand:SI 1 "gen_reg_operand" "r")
  1044.             (const_int -4))))
  1045.    (set (reg:SI 177)
  1046.     (and:SI (match_dup 1)
  1047.         (const_int 2)))]
  1048.   "! TARGET_DW_ENABLE"
  1049.   "load 0,18,%0,%1"
  1050.   [(set_attr "type" "load")])
  1051.  
  1052. (define_insn ""
  1053.   [(set (match_operand 0 "gen_reg_operand" "=r")
  1054.     (match_operator 2 "extend_operator"
  1055.             [(match_operand 1 "memory_operand" "m")]))]
  1056.   "TARGET_DW_ENABLE && GET_MODE (operands[0]) == GET_MODE (operands[2])"
  1057.   "load 0,%X2,%0,%1"
  1058.   [(set_attr "type" "load")])
  1059.  
  1060. ;; LOADM
  1061. (define_expand "load_multiple"
  1062.   [(set (reg:SI 179)
  1063.     (match_dup 2))
  1064.    (match_parallel 3 "" [(set (match_operand:SI 0 "" "")
  1065.                   (match_operand:SI 1 "" ""))])]
  1066.   ""
  1067.   "
  1068. {
  1069.   int regno;
  1070.   int count;
  1071.   rtx from;
  1072.   int i;
  1073.  
  1074.   /* Support only loading a constant number of hard registers from memory.  */
  1075.   if (GET_CODE (operands[2]) != CONST_INT
  1076.       || operands[2] == const1_rtx
  1077.       || GET_CODE (operands[1]) != MEM
  1078.       || GET_CODE (operands[0]) != REG
  1079.       || REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
  1080.     FAIL;
  1081.  
  1082.   count = INTVAL (operands[2]);
  1083.   regno = REGNO (operands[0]);
  1084.  
  1085.   /* CR gets set to the number of registers minus one.  */
  1086.   operands[2] = gen_rtx (CONST_INT, VOIDmode, count - 1);
  1087.  
  1088.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 2));
  1089.   from = memory_address (SImode, XEXP (operands[1], 0));
  1090.   XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
  1091.                      gen_rtx (REG, SImode, regno),
  1092.                      gen_rtx (MEM, SImode, from));
  1093.   XVECEXP (operands[3], 0, 1)
  1094.     = gen_rtx (USE, VOIDmode, gen_rtx (REG, SImode, R_CR));
  1095.   XVECEXP (operands[3], 0, 2)
  1096.     = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, R_CR));
  1097.  
  1098.   for (i = 1; i < count; i++)
  1099.     XVECEXP (operands[3], 0, i + 2)
  1100.       = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
  1101.          gen_rtx (MEM, SImode, plus_constant (from, i * 4)));
  1102. }")
  1103.  
  1104. ;; Indicate that CR is used and is then clobbered.
  1105. (define_insn ""
  1106.   [(set (match_operand 0 "gen_reg_operand" "=r")
  1107.     (match_operand 1 "memory_operand" "m"))
  1108.    (use (reg:SI 179))
  1109.    (clobber (reg:SI 179))]
  1110.   "GET_MODE (operands[0]) == GET_MODE (operands[1])
  1111.    && GET_MODE_SIZE (GET_MODE (operands[0])) > UNITS_PER_WORD
  1112.    && ! TARGET_29050"
  1113.   "loadm 0,0,%0,%1"
  1114.   [(set_attr "type" "load")])
  1115.  
  1116. (define_insn ""
  1117.   [(set (match_operand 0 "gen_reg_operand" "=&r")
  1118.     (match_operand 1 "memory_operand" "m"))
  1119.    (use (reg:SI 179))
  1120.    (clobber (reg:SI 179))]
  1121.   "GET_MODE (operands[0]) == GET_MODE (operands[1])
  1122.    && GET_MODE_SIZE (GET_MODE (operands[0])) > UNITS_PER_WORD
  1123.    && TARGET_29050"
  1124.   "loadm 0,0,%0,%1"
  1125.   [(set_attr "type" "load")])
  1126.  
  1127. (define_insn ""
  1128.   [(match_parallel 0 "load_multiple_operation"
  1129.            [(set (match_operand:SI 1 "gen_reg_operand" "=r")
  1130.              (match_operand:SI 2 "memory_operand" "m"))
  1131.             (use (reg:SI 179))
  1132.             (clobber (reg:SI 179))])]
  1133.   "! TARGET_29050"
  1134.   "loadm 0,0,%1,%2"
  1135.   [(set_attr "type" "load")])
  1136.  
  1137. (define_insn ""
  1138.   [(match_parallel 0 "load_multiple_operation"
  1139.            [(set (match_operand:SI 1 "gen_reg_operand" "=&r")
  1140.              (match_operand:SI 2 "memory_operand" "m"))
  1141.             (use (reg:SI 179))
  1142.             (clobber (reg:SI 179))])]
  1143.   "TARGET_29050"
  1144.   "loadm 0,0,%1,%2"
  1145.   [(set_attr "type" "load")])
  1146.  
  1147. ;; MTSR (used also by move insn)
  1148. (define_insn ""
  1149.   [(set (match_operand:SI 0 "spec_reg_operand" "=*h,*h")
  1150.     (and:SI (match_operand:SI 1 "gen_reg_or_immediate_operand" "r,i")
  1151.         (match_operand:SI 2 "const_int_operand" "n,n")))]
  1152.   "masks_bits_for_special (operands[0], operands[2])"
  1153.   "@
  1154.    mtsr %0,%1
  1155.    mtsrim %0,%1")
  1156.  
  1157. ;; MULTIPLY, MULTM, MULTMU
  1158. (define_insn "mulsi3"
  1159.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1160.     (mult:SI (match_operand:SI 1 "gen_reg_operand" "%r")
  1161.          (match_operand:SI 2 "gen_reg_operand" "r")))]
  1162.   ""
  1163.   "multiply %0,%1,%2")
  1164.  
  1165. (define_insn ""
  1166.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1167.     (subreg:SI
  1168.      (mult:DI
  1169.       (sign_extend:DI (match_operand:SI 1 "gen_reg_operand" "%r"))
  1170.       (sign_extend:DI (match_operand:SI 2 "gen_reg_operand" "r"))) 0))]
  1171.   ""
  1172.   "multm %0,%1,%2")
  1173.  
  1174. (define_insn ""
  1175.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1176.     (subreg:SI
  1177.      (mult:DI
  1178.       (zero_extend:DI (match_operand:SI 1 "gen_reg_operand" "%r"))
  1179.       (zero_extend:DI (match_operand:SI 2 "gen_reg_operand" "r"))) 0))]
  1180.   ""
  1181.   "multmu %0,%1,%2")
  1182.  
  1183. (define_insn "mulsidi3"
  1184.   [(set (match_operand:DI 0 "gen_reg_operand" "=r")
  1185.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gen_reg_operand" "r"))
  1186.          (sign_extend:DI (match_operand:SI 2 "gen_reg_operand" "r"))))]
  1187.   ""
  1188.   "multiply %L0,%1,%2\;multm %0,%1,%2"
  1189.   [(set_attr "type" "multi")])
  1190.  
  1191. (define_split
  1192.   [(set (match_operand:DI 0 "gen_reg_operand" "")
  1193.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gen_reg_operand" ""))
  1194.          (sign_extend:DI (match_operand:SI 2 "gen_reg_operand" ""))))]
  1195.   "reload_completed"
  1196.   [(set (match_dup 3)
  1197.     (mult:SI (match_dup 1) (match_dup 2)))
  1198.    (set (match_dup 4)
  1199.     (subreg:SI (mult:DI
  1200.             (sign_extend:DI (match_dup 1))
  1201.             (sign_extend:DI (match_dup 2))) 0))]
  1202.   "
  1203. { operands[3] = operand_subword (operands[0], 1, 1, DImode);
  1204.   operands[4] = operand_subword (operands[1], 0, 1, DImode); } ")
  1205.                 
  1206. (define_insn "umulsidi3"
  1207.   [(set (match_operand:DI 0 "gen_reg_operand" "=r")
  1208.     (mult:DI (zero_extend:DI (match_operand:SI 1 "gen_reg_operand" "r"))
  1209.          (zero_extend:DI (match_operand:SI 2 "gen_reg_operand" "r"))))]
  1210.   ""
  1211.   "multiplu %L0,%1,%2\;multmu %0,%1,%2"
  1212.   [(set_attr "type" "multi")])
  1213.  
  1214. (define_split
  1215.   [(set (match_operand:DI 0 "gen_reg_operand" "")
  1216.     (mult:DI (zero_extend:DI (match_operand:SI 1 "gen_reg_operand" ""))
  1217.          (zero_extend:DI (match_operand:SI 2 "gen_reg_operand" ""))))]
  1218.   "reload_completed"
  1219.   [(set (match_dup 3)
  1220.     (mult:SI (match_dup 1) (match_dup 2)))
  1221.    (set (match_dup 4)
  1222.     (subreg:SI (mult:DI (zero_extend:DI (match_dup 1))
  1223.                 (zero_extend:DI (match_dup 2))) 0))]
  1224.   "
  1225. { operands[3] = operand_subword (operands[0], 1, 1, DImode);
  1226.   operands[4] = operand_subword (operands[1], 0, 1, DImode); } ")
  1227.                 
  1228. ;; NAND
  1229. (define_insn ""
  1230.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1231.     (ior:SI (not:SI (match_operand:SI 1 "gen_reg_operand" "%r"))
  1232.         (not:SI (match_operand:SI 2 "srcb_operand" "rI"))))]
  1233.   ""
  1234.   "nand %0,%1,%2")
  1235.  
  1236. (define_insn ""
  1237.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1238.     (ior:SI (not:SI (match_operand:SI 1 "gen_reg_operand" "r"))
  1239.         (match_operand:SI 2 "const_int_operand" "K")))]
  1240.   "((unsigned) ~ INTVAL (operands[2])) < 256"
  1241.   "nand %0,%1,%C2")
  1242.  
  1243. ;; NOR
  1244. (define_insn ""
  1245.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1246.     (and:SI (not:SI (match_operand:SI 1 "gen_reg_operand" "%r"))
  1247.         (not:SI (match_operand:SI 2 "srcb_operand" "rI"))))]
  1248.   ""
  1249.   "nor %0,%1,%2")
  1250.  
  1251. (define_insn ""
  1252.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1253.     (and:SI (not:SI (match_operand:SI 1 "gen_reg_operand" "r"))
  1254.         (match_operand:SI 2 "const_int_operand" "K")))]
  1255.   "((unsigned) ~ INTVAL (operands[2])) < 256"
  1256.   "nor %0,%1,%C2")
  1257.  
  1258. (define_insn "one_cmplsi2"
  1259.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1260.     (not:SI (match_operand:SI 1 "gen_reg_operand" "r")))]
  1261.   ""
  1262.   "nor %0,%1,0")
  1263.  
  1264. ;; OR/ORN
  1265. (define_expand "iorsi3"
  1266.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  1267.     (ior:SI (match_operand:SI 1 "gen_reg_operand" "")
  1268.         (match_operand:SI 2 "srcb_operand" "")))]
  1269.   ""
  1270.   "")
  1271.  
  1272. (define_insn ""
  1273.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1274.     (ior:SI (match_operand:SI 1 "gen_reg_operand" "%r")
  1275.         (match_operand:SI 2 "srcb_operand" "rI")))]
  1276.   "! TARGET_29050"
  1277.   "or %0,%1,%2")
  1278.  
  1279. (define_insn ""
  1280.   [(set (match_operand:SI 0 "gen_reg_operand" "=r,r")
  1281.     (ior:SI (match_operand:SI 1 "gen_reg_operand" "%r,r")
  1282.         (match_operand:SI 2 "srcb_operand" "rI,K")))]
  1283.   "TARGET_29050"
  1284.   "@
  1285.    or %0,%1,%2
  1286.    orn %0,%1,%C2")
  1287.  
  1288.  
  1289. ;; SLL (also used by move insn)
  1290. (define_insn "nop"
  1291.   [(const_int 0)]
  1292.   ""
  1293.   "aseq 0x40,gr1,gr1")
  1294.  
  1295. (define_insn "ashlsi3"
  1296.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1297.     (ashift:SI (match_operand:SI 1 "gen_reg_operand" "r")
  1298.            (match_operand:QI 2 "srcb_operand" "rn")))]
  1299.   ""
  1300.   "sll %0,%1,%Q2")
  1301.  
  1302. ;; SRA
  1303. (define_insn "ashrsi3"
  1304.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1305.     (ashiftrt:SI (match_operand:SI 1 "gen_reg_operand" "r")
  1306.              (match_operand:QI 2 "srcb_operand" "rn")))]
  1307.   ""
  1308.   "sra %0,%1,%Q2")
  1309.  
  1310. ;; SRL
  1311. (define_insn "lshrsi3"
  1312.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1313.     (lshiftrt:SI (match_operand:SI 1 "gen_reg_operand" "r")
  1314.              (match_operand:QI 2 "srcb_operand" "rn")))]
  1315.   ""
  1316.   "srl %0,%1,%Q2")
  1317.  
  1318. ;; STORE
  1319. ;;
  1320. ;; These somewhat bogus patterns exist to set OPT = 001/010 for partial-word
  1321. ;; stores on systems with DW not set.
  1322. (define_insn ""
  1323.   [(set (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "r")
  1324.             (const_int -4)))
  1325.     (match_operand:SI 1 "gen_reg_operand" "r"))]
  1326.   "! TARGET_DW_ENABLE"
  1327.   "store 0,1,%1,%0"
  1328.   [(set_attr "type" "store")])
  1329.  
  1330. (define_insn ""
  1331.   [(set (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "r")
  1332.             (const_int -3)))
  1333.     (match_operand:SI 1 "gen_reg_operand" "r"))]
  1334.   "! TARGET_DW_ENABLE"
  1335.   "store 0,2,%1,%0"
  1336.   [(set_attr "type" "store")])
  1337.  
  1338. ;; STOREM
  1339. (define_expand "store_multiple"
  1340.   [(use (match_operand 0 "" ""))
  1341.    (use (match_operand 1 "" ""))
  1342.    (use (match_operand 2 "" ""))]
  1343.   ""
  1344.   "
  1345. { rtx pat;
  1346.  
  1347.  if (TARGET_NO_STOREM_BUG)
  1348.     pat = gen_store_multiple_no_bug (operands[0], operands[1], operands[2]);
  1349.   else
  1350.     pat = gen_store_multiple_bug (operands[0], operands[1], operands[2]);
  1351.  
  1352.   if (pat)
  1353.     emit_insn (pat);
  1354.   else
  1355.     FAIL;
  1356.  
  1357.   DONE;
  1358. }")
  1359.  
  1360. (define_expand "store_multiple_no_bug"
  1361.   [(set (reg:SI 179)
  1362.     (match_dup 2))
  1363.    (match_parallel 3 "" [(set (match_operand:SI 0 "" "")
  1364.                   (match_operand:SI 1 "" ""))])]
  1365.   ""
  1366.   "
  1367. {
  1368.   int regno;
  1369.   int count;
  1370.   rtx from;
  1371.   int i;
  1372.  
  1373.   /* Support only storing a constant number of hard registers to memory.  */
  1374.   if (GET_CODE (operands[2]) != CONST_INT
  1375.       || operands[2] == const1_rtx
  1376.       || GET_CODE (operands[0]) != MEM
  1377.       || GET_CODE (operands[1]) != REG
  1378.       || REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)
  1379.     FAIL;
  1380.  
  1381.   count = INTVAL (operands[2]);
  1382.   regno = REGNO (operands[1]);
  1383.  
  1384.   /* CR gets set to the number of registers minus one.  */
  1385.   operands[2] = gen_rtx (CONST_INT, VOIDmode, count - 1);
  1386.  
  1387.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 2));
  1388.   from = memory_address (SImode, XEXP (operands[0], 0));
  1389.   XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
  1390.                      gen_rtx (MEM, SImode, from),
  1391.                      gen_rtx (REG, SImode, regno));
  1392.   XVECEXP (operands[3], 0, 1)
  1393.     = gen_rtx (USE, VOIDmode, gen_rtx (REG, SImode, R_CR));
  1394.   XVECEXP (operands[3], 0, 2)
  1395.     = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, R_CR));
  1396.  
  1397.   for (i = 1; i < count; i++)
  1398.     XVECEXP (operands[3], 0, i + 2)
  1399.       = gen_rtx (SET, VOIDmode,
  1400.          gen_rtx (MEM, SImode, plus_constant (from, i * 4)),
  1401.          gen_rtx (REG, SImode, regno + i));
  1402. }")
  1403.  
  1404. (define_expand "store_multiple_bug"
  1405.   [(match_parallel 3 "" [(set (match_operand:SI 0 "" "")
  1406.                   (match_operand:SI 1 "" ""))])]
  1407.   ""
  1408.   "
  1409. {
  1410.   int regno;
  1411.   int count;
  1412.   rtx from;
  1413.   int i;
  1414.  
  1415.   /* Support only storing a constant number of hard registers to memory.  */
  1416.   if (GET_CODE (operands[2]) != CONST_INT
  1417.       || operands[2] == const1_rtx
  1418.       || GET_CODE (operands[0]) != MEM
  1419.       || GET_CODE (operands[1]) != REG
  1420.       || REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)
  1421.     FAIL;
  1422.  
  1423.   count = INTVAL (operands[2]);
  1424.   regno = REGNO (operands[1]);
  1425.  
  1426.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
  1427.   from = memory_address (SImode, XEXP (operands[0], 0));
  1428.   XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
  1429.                      gen_rtx (MEM, SImode, from),
  1430.                      gen_rtx (REG, SImode, regno));
  1431.   XVECEXP (operands[3], 0, 1)
  1432.     = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, R_CR));
  1433.  
  1434.   for (i = 1; i < count; i++)
  1435.     XVECEXP (operands[3], 0, i + 1)
  1436.       = gen_rtx (SET, VOIDmode,
  1437.          gen_rtx (MEM, SImode, plus_constant (from, i * 4)),
  1438.          gen_rtx (REG, SImode, regno + i));
  1439. }")
  1440.  
  1441. (define_insn ""
  1442.   [(set (match_operand 0 "memory_operand" "=m")
  1443.     (match_operand 1 "gen_reg_operand" "r"))
  1444.    (clobber (reg:SI 179))]
  1445.   "!TARGET_NO_STOREM_BUG
  1446.    && GET_MODE (operands[0]) == GET_MODE (operands[1])
  1447.    && GET_MODE_SIZE (GET_MODE (operands[0])) > UNITS_PER_WORD"
  1448.   "mtsrim cr,%S1\;storem 0,0,%1,%0"
  1449.   [(set_attr "type" "multi")])
  1450.  
  1451. (define_insn ""
  1452.   [(match_parallel 0 "store_multiple_operation"
  1453.            [(set (match_operand:SI 1 "memory_operand" "=m")
  1454.              (match_operand:SI 2 "gen_reg_operand" "r"))
  1455.             (clobber (reg:SI 179))])]
  1456.   "!TARGET_NO_STOREM_BUG"
  1457.   "mtsrim cr,%V0\;storem 0,0,%2,%1"
  1458.   [(set_attr "type" "multi")])
  1459.  
  1460. (define_insn ""
  1461.   [(set (match_operand 0 "memory_operand" "=m")
  1462.     (match_operand 1 "gen_reg_operand" "r"))
  1463.    (use (reg:SI 179))
  1464.    (clobber (reg:SI 179))]
  1465.   "TARGET_NO_STOREM_BUG
  1466.    && GET_MODE (operands[0]) == GET_MODE (operands[1])
  1467.    && GET_MODE_SIZE (GET_MODE (operands[0])) > UNITS_PER_WORD"
  1468.   "storem 0,0,%1,%0"
  1469.   [(set_attr "type" "store")])
  1470.  
  1471. (define_insn ""
  1472.   [(match_parallel 0 "store_multiple_operation"
  1473.            [(set (match_operand:SI 1 "memory_operand" "=m")
  1474.              (match_operand:SI 2 "gen_reg_operand" "r"))
  1475.             (use (reg:SI 179))
  1476.             (clobber (reg:SI 179))])]
  1477.   "TARGET_NO_STOREM_BUG"
  1478.   "storem 0,0,%2,%1"
  1479.   [(set_attr "type" "store")])
  1480.  
  1481. ;; SUB
  1482. ;;
  1483. ;; Either operand can be a register or an 8-bit constant, but both cannot be
  1484. ;; constants (can't usually occur anyway).
  1485. (define_expand "subsi3"
  1486.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  1487.     (minus:SI (match_operand:SI 1 "srcb_operand" "")
  1488.           (match_operand:SI 2 "srcb_operand" "")))]
  1489.   ""
  1490.   "
  1491. {
  1492.   if (GET_CODE (operands[0]) == CONST_INT
  1493.       && GET_CODE (operands[1]) == CONST_INT)
  1494.     operands[1] = force_reg (SImode, operands[1]);
  1495. }")
  1496.  
  1497. (define_insn ""
  1498.   [(set (match_operand:SI 0 "gen_reg_operand" "=r,r")
  1499.     (minus:SI (match_operand:SI 1 "srcb_operand" "r,I")
  1500.           (match_operand:SI 2 "srcb_operand" "rI,r")))]
  1501.   "register_operand (operands[1], SImode)
  1502.    || register_operand (operands[2], SImode)"
  1503.   "@
  1504.    sub %0,%1,%2
  1505.    subr %0,%2,%1")
  1506.  
  1507. (define_insn "subdi3"
  1508.   [(set (match_operand:DI 0 "gen_reg_operand" "=r")
  1509.     (minus:DI (match_operand:DI 1 "gen_reg_operand" "r")
  1510.           (match_operand:DI 2 "gen_reg_operand" "r")))]
  1511.   ""
  1512.   "sub %L0,%L1,%L2\;subc %0,%1,%2"
  1513.   [(set_attr "type" "multi")])
  1514.  
  1515. ;; SUBR (also used above in SUB)
  1516. (define_insn "negdi2"
  1517.   [(set (match_operand:DI 0 "gen_reg_operand" "=r")
  1518.     (neg:DI (match_operand:DI 1 "gen_reg_operand" "r")))]
  1519.   ""
  1520.   "subr %L0,%L1,0\;subrc %0,%1,0"
  1521.   [(set_attr "type" "multi")])
  1522.  
  1523. (define_insn "negsi2"
  1524.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1525.     (neg:SI (match_operand:SI 1 "gen_reg_operand" "r")))]
  1526.   ""
  1527.   "subr %0,%1,0")
  1528.  
  1529. ;; XNOR
  1530. (define_insn ""
  1531.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1532.     (not:SI (xor:SI (match_operand:SI 1 "gen_reg_operand" "%r")
  1533.             (match_operand:SI 2 "srcb_operand" "rI"))))]
  1534.   ""
  1535.   "xnor %0,%1,%2")
  1536.  
  1537. ;; XOR
  1538. (define_insn "xorsi3"
  1539.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1540.     (xor:SI (match_operand:SI 1 "gen_reg_operand" "%r")
  1541.         (match_operand:SI 2 "srcb_operand" "rI")))]
  1542.   ""
  1543.   "xor %0,%1,%2")
  1544.  
  1545. ;; Can use XOR to negate floating-point values, but we are better off not doing
  1546. ;; it that way on the 29050 so it can combine with the fmac insns.
  1547. (define_expand "negsf2"
  1548.   [(set (match_operand:SF 0 "register_operand" "")
  1549.     (neg:SF (match_operand:SF 1 "register_operand" "")))]
  1550.   ""
  1551.   "
  1552. {
  1553.   rtx result;
  1554.   rtx target;
  1555.  
  1556.   if (! TARGET_29050)
  1557.     {
  1558.       target = operand_subword_force (operands[0], 0, SFmode);
  1559.       result = expand_binop (SImode, xor_optab,
  1560.                  operand_subword_force (operands[1], 0, SFmode),
  1561.                  gen_rtx (CONST_INT, VOIDmode, 0x80000000),
  1562.                  target, 0, OPTAB_WIDEN);
  1563.       if (result == 0)
  1564.     abort ();
  1565.  
  1566.       if (result != target)
  1567.     emit_move_insn (result, target);
  1568.  
  1569.       /* Make a place for REG_EQUAL.  */
  1570.       emit_move_insn (operands[0], operands[0]);
  1571.       DONE;
  1572.     }
  1573. }")
  1574.  
  1575. (define_expand "negdf2"
  1576.   [(set (match_operand:DF 0 "register_operand" "")
  1577.     (neg:DF (match_operand:DF 1 "register_operand" "")))]
  1578.   ""
  1579.   "
  1580. {
  1581.   rtx result;
  1582.   rtx target;
  1583.   rtx seq;
  1584.  
  1585.   if (! TARGET_29050)
  1586.     {
  1587.       start_sequence ();
  1588.       target = operand_subword_force (operands[0], 0, DFmode);
  1589.       result = expand_binop (SImode, xor_optab,
  1590.                  operand_subword_force (operands[1], 0, DFmode),
  1591.                  gen_rtx (CONST_INT, VOIDmode, 0x80000000),
  1592.                  target, 0, OPTAB_WIDEN);
  1593.       if (result == 0)
  1594.     abort ();
  1595.  
  1596.       if (result != target)
  1597.     emit_move_insn (result, target);
  1598.   
  1599.       emit_move_insn (gen_lowpart (SImode, operands[0]),
  1600.               gen_lowpart (SImode, operands[1]));
  1601.  
  1602.       seq = gen_sequence ();
  1603.       end_sequence ();
  1604.  
  1605.       emit_no_conflict_block (seq, operands[0], operands[1], 0, 0);
  1606.       DONE;
  1607.     }
  1608. }")
  1609.  
  1610. ;; Sign extend and truncation operations.
  1611. (define_insn "zero_extendqihi2"
  1612.   [(set (match_operand:HI 0 "gen_reg_operand" "=r")
  1613.     (zero_extend:HI (match_operand:QI 1 "gen_reg_operand" "r")))]
  1614.   ""
  1615.   "and %0,%1,255")
  1616.  
  1617. (define_insn "zero_extendqisi2"
  1618.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1619.     (zero_extend:SI (match_operand:QI 1 "gen_reg_operand" "r")))]
  1620.   ""
  1621.   "and %0,%1,255")
  1622.  
  1623. (define_insn "zero_extendhisi2"
  1624.   [(set (match_operand:SI 0 "gen_reg_operand" "=r")
  1625.     (zero_extend:SI (match_operand:HI 1 "gen_reg_operand" "0")))]
  1626.   ""
  1627.   "consth %0,0")
  1628.  
  1629. (define_expand "extendqihi2"
  1630.   [(set (match_dup 2)
  1631.     (ashift:SI (match_operand:QI 1 "gen_reg_operand" "")
  1632.            (const_int 24)))
  1633.    (set (match_operand:HI 0 "gen_reg_operand" "")
  1634.     (ashiftrt:SI (match_dup 2)
  1635.              (const_int 24)))]
  1636.   ""
  1637.   "
  1638. { operands[0] = gen_lowpart (SImode, operands[0]);
  1639.   operands[1] = gen_lowpart (SImode, operands[1]);
  1640.   operands[2] = gen_reg_rtx (SImode); }")
  1641.  
  1642. (define_expand "extendqisi2"
  1643.   [(set (match_dup 2)
  1644.     (ashift:SI (match_operand:QI 1 "gen_reg_operand" "")
  1645.            (const_int 24)))
  1646.    (set (match_operand:SI 0 "gen_reg_operand" "")
  1647.     (ashiftrt:SI (match_dup 2)
  1648.              (const_int 24)))]
  1649.   ""
  1650.   "
  1651. { operands[1] = gen_lowpart (SImode, operands[1]);
  1652.   operands[2] = gen_reg_rtx (SImode); }")
  1653.  
  1654. (define_expand "extendhisi2"
  1655.   [(set (match_dup 2)
  1656.     (ashift:SI (match_operand:HI 1 "gen_reg_operand" "")
  1657.            (const_int 16)))
  1658.    (set (match_operand:SI 0 "gen_reg_operand" "")
  1659.     (ashiftrt:SI (match_dup 2)
  1660.              (const_int 16)))]
  1661.   ""
  1662.   "
  1663. { operands[1] = gen_lowpart (SImode, operands[1]);
  1664.   operands[2] = gen_reg_rtx (SImode); }")
  1665.  
  1666. ;; Define the methods used to move data around.
  1667. ;;
  1668. ;; movsi:
  1669. ;;
  1670. ;; If storing into memory, force source into register.
  1671. (define_expand "movsi"
  1672.   [(set (match_operand:SI 0 "general_operand" "")
  1673.     (match_operand:SI 1 "general_operand" ""))]
  1674.   ""
  1675.   "
  1676. {
  1677.   if (GET_CODE (operands[0]) == MEM && ! gen_reg_operand (operands[1], SImode))
  1678.     operands[1] = copy_to_mode_reg (SImode, operands[1]);
  1679.   else if (spec_reg_operand (operands[0], SImode)
  1680.        && ! (register_operand (operands[1], SImode)
  1681.          || cint_16_operand (operands[1], SImode)))
  1682.     operands[1] = force_reg (SImode, operands[1]);
  1683. }")
  1684.  
  1685. (define_split
  1686.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  1687.     (match_operand:SI 1 "long_const_operand" ""))]
  1688.   ""
  1689.   [(set (match_dup 0)
  1690.     (and:SI (match_dup 1)
  1691.         (const_int 65535)))
  1692.    (set (match_dup 0)
  1693.     (ior:SI (and:SI (match_dup 0)
  1694.             (const_int 65535))
  1695.         (and:SI (match_dup 1)
  1696.             (const_int -65536))))]
  1697.   "")
  1698.  
  1699. ;; Subroutines to load/store halfwords.  Use TAV (gr121) as scratch.  We have
  1700. ;; two versions of storehi, one when halfword writes are supported and one
  1701. ;; where they aren't.
  1702. (define_expand "loadhi"
  1703.   [(parallel [(set (match_dup 2)
  1704.            (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1705.                    (const_int -4))))
  1706.           (set (reg:SI 177)
  1707.            (and:SI (match_dup 0)
  1708.                (const_int 2)))])
  1709.    (set (match_operand:HI 1 "gen_reg_operand" "")
  1710.     (zero_extract:SI (match_dup 2)
  1711.              (const_int 16)
  1712.              (ashift:SI (reg:SI 177)
  1713.                     (const_int 3))))]
  1714.   ""
  1715.   "
  1716. { operands[1] = gen_lowpart (SImode, operands[1]);
  1717.  
  1718.   if (reload_in_progress)
  1719.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1720.   else
  1721.     operands[2] = gen_reg_rtx (SImode);
  1722. }")
  1723.  
  1724. (define_expand "storehinhww"
  1725.   [(parallel [(set (match_dup 2)
  1726.            (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1727.                    (const_int -4))))
  1728.           (set (reg:SI 177)
  1729.            (and:SI (match_dup 0)
  1730.                  (const_int 2)))])
  1731.    (set (zero_extract:SI (match_dup 2)
  1732.              (const_int 8)
  1733.              (ashift:SI (reg:SI 177)
  1734.                     (const_int 3)))
  1735.     (match_operand:HI 1 "gen_reg_operand" ""))
  1736.    (set (mem:SI (match_dup 0))
  1737.     (match_dup 2))]
  1738.   ""
  1739.   "
  1740. { operands[1] = gen_lowpart (SImode, operands[1]);
  1741.  
  1742.   if (reload_in_progress)
  1743.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1744.   else
  1745.     operands[2] = gen_reg_rtx (SImode);
  1746. }")
  1747.  
  1748. (define_expand "storehihww"
  1749.   [(set (reg:SI 177)
  1750.     (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1751.         (const_int 3)))
  1752.    (set (match_dup 2)
  1753.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 65535)
  1754.                        (ashift:SI (reg:SI 177)
  1755.                               (const_int 3))))
  1756.             (match_operand:HI 1 "gen_reg_operand" ""))
  1757.         (ashift:SI (and:SI (match_dup 1)
  1758.                    (const_int 65535))
  1759.                (ashift:SI (reg:SI 177)
  1760.                       (const_int 3)))))
  1761.    (set (mem:SI (and:SI (match_dup 0)
  1762.             (const_int -3)))
  1763.     (match_dup 2))]
  1764.   ""
  1765.   "
  1766. { operands[1] = gen_lowpart (SImode, operands[1]);
  1767.  
  1768.   if (reload_in_progress)
  1769.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1770.   else
  1771.     operands[2] = gen_reg_rtx (SImode);
  1772. }")
  1773.  
  1774. (define_expand "movhi"
  1775.   [(set (match_operand:HI 0 "general_operand" "")
  1776.     (match_operand:HI 1 "general_operand" ""))]
  1777.   ""
  1778.   "
  1779. { if (GET_CODE (operands[0]) == MEM) 
  1780.     {
  1781.       if (! gen_reg_operand (operands[1], HImode))
  1782.     operands[1] = copy_to_mode_reg (HImode, operands[1]);
  1783.       if (! TARGET_DW_ENABLE)
  1784.     {
  1785.       if (TARGET_BYTE_WRITES)
  1786.         emit_insn (gen_storehihww (XEXP (operands[0], 0), operands[1]));
  1787.       else
  1788.         emit_insn (gen_storehinhww (XEXP (operands[0], 0), operands[1]));
  1789.       DONE;
  1790.     }
  1791.     }
  1792.   else if (GET_CODE (operands[1]) == MEM)
  1793.     {
  1794.       if (! TARGET_DW_ENABLE)
  1795.     {
  1796.       emit_insn (gen_loadhi (XEXP (operands[1], 0), operands[0]));
  1797.       DONE;
  1798.     }
  1799.     }
  1800. }")
  1801.  
  1802. ;; Subroutines to load/store bytes.  Use TAV (gr121) as scratch.
  1803. (define_expand "loadqi"
  1804.   [(parallel [(set (match_dup 2)
  1805.            (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1806.                    (const_int -4))))
  1807.           (set (reg:SI 177)
  1808.            (and:SI (match_dup 0)
  1809.                (const_int 3)))])
  1810.    (set (match_operand:QI 1 "gen_reg_operand" "")
  1811.     (zero_extract:SI (match_dup 2)
  1812.              (const_int 8)
  1813.              (ashift:SI (reg:SI 177)
  1814.                     (const_int 3))))]
  1815.   ""
  1816.   "
  1817. { operands[1] = gen_lowpart (SImode, operands[1]);
  1818.  
  1819.   if (reload_in_progress)
  1820.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1821.   else
  1822.     operands[2] = gen_reg_rtx (SImode);
  1823. }")
  1824.  
  1825. (define_expand "storeqinhww"
  1826.   [(parallel [(set (match_dup 2)
  1827.            (mem:SI (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1828.                    (const_int -4))))
  1829.           (set (reg:SI 177)
  1830.            (and:SI (match_dup 0)
  1831.                (const_int 3)))])
  1832.    (set (zero_extract:SI (match_dup 2)
  1833.              (const_int 8)
  1834.              (ashift:SI (reg:SI 177)
  1835.                     (const_int 3)))
  1836.     (match_operand:QI 1 "gen_reg_operand" ""))
  1837.    (set (mem:SI (match_dup 0))
  1838.     (match_dup 2))]
  1839.   ""
  1840.   "
  1841. { operands[1] = gen_lowpart (SImode, operands[1]);
  1842.  
  1843.   if (reload_in_progress)
  1844.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1845.   else
  1846.     operands[2] = gen_reg_rtx (SImode);
  1847. }")
  1848.  
  1849. (define_expand "storeqihww"
  1850.   [(set (reg:SI 177)
  1851.     (and:SI (match_operand:SI 0 "gen_reg_operand" "")
  1852.         (const_int 3)))
  1853.    (set (match_dup 2)
  1854.     (ior:SI (and:SI (not:SI (ashift:SI (const_int 255)
  1855.                        (ashift:SI (reg:SI 177)
  1856.                               (const_int 3))))
  1857.             (match_operand:HI 1 "gen_reg_operand" ""))
  1858.         (ashift:SI (and:SI (match_dup 1)
  1859.                    (const_int 255))
  1860.                (ashift:SI (reg:SI 177)
  1861.                       (const_int 3)))))
  1862.    (set (mem:SI (and:SI (match_dup 0)
  1863.                 (const_int -4)))
  1864.     (match_dup 2))]
  1865.   ""
  1866.   "
  1867. { operands[1] = gen_lowpart (SImode, operands[1]);
  1868.  
  1869.   if (reload_in_progress)
  1870.     operands[2] = gen_rtx (REG, SImode, R_TAV);
  1871.   else
  1872.     operands[2] = gen_reg_rtx (SImode);
  1873. }")
  1874.  
  1875. (define_expand "movqi"
  1876.   [(set (match_operand:QI 0 "general_operand" "")
  1877.     (match_operand:QI 1 "general_operand" ""))]
  1878.   ""
  1879.   "
  1880. { if (GET_CODE (operands[0]) == MEM)
  1881.     {
  1882.       if (! gen_reg_operand (operands[1], QImode))
  1883.     operands[1] = copy_to_mode_reg (QImode, operands[1]);
  1884.       if (! TARGET_DW_ENABLE)
  1885.     {
  1886.       if (TARGET_BYTE_WRITES)
  1887.         emit_insn (gen_storeqihww (XEXP (operands[0], 0), operands[1]));
  1888.       else
  1889.         emit_insn (gen_storeqinhww (XEXP (operands[0], 0), operands[1]));
  1890.       DONE;
  1891.     }
  1892.     }
  1893.   else if (GET_CODE (operands[1]) == MEM)
  1894.     {
  1895.       if (! TARGET_DW_ENABLE)
  1896.     {
  1897.       emit_insn (gen_loadqi (XEXP (operands[1], 0), operands[0]));
  1898.       DONE;
  1899.     }
  1900.     }
  1901. }")
  1902.  
  1903. ;; Now the actual insns used to move data around.  We include here the
  1904. ;; DEFINE_SPLITs that may be needed.  In some cases these will be
  1905. ;; split again.  For floating-point, if we can look inside the constant,
  1906. ;; always split it.  This can eliminate unnecessary insns.
  1907. (define_insn ""
  1908.   [(set (match_operand:SF 0 "out_operand" "=r,r,r,r,m")
  1909.     (match_operand:SF 1 "in_operand" "r,E,F,m,r"))]
  1910.   "(gen_reg_operand (operands[0], SFmode)
  1911.     || gen_reg_operand (operands[1], SFmode))
  1912.    && ! TARGET_29050"
  1913.   "@
  1914.    sll %0,%1,0
  1915.    #
  1916.    const %0,%1\;consth %0,%1
  1917.    load 0,0,%0,%1
  1918.    store 0,0,%1,%0"
  1919.   [(set_attr "type" "misc,multi,multi,load,store")])
  1920.  
  1921. (define_insn ""
  1922.   [(set (match_operand:SF 0 "out_operand" "=r,r,r,r,m,*a,r")
  1923.     (match_operand:SF 1 "in_operand" "r,E,F,m,r,r,*a"))]
  1924.   "(gen_reg_operand (operands[0], SFmode)
  1925.     || gen_reg_operand (operands[1], SFmode))
  1926.    && TARGET_29050"
  1927.   "@
  1928.    sll %0,%1,0
  1929.    #
  1930.    const %0,%1\;consth %0,%1
  1931.    load 0,0,%0,%1
  1932.    store 0,0,%1,%0
  1933.    mtacc %1,1,%0
  1934.    mfacc %0,1,%1"
  1935.   [(set_attr "type" "misc,multi,multi,load,store,fadd,fadd")])
  1936.  
  1937. ;; Turn this into SImode.  It will then be split up that way.
  1938. (define_split
  1939.   [(set (match_operand:SF 0 "register_operand" "")
  1940.     (match_operand:SF 1 "float_const_operand" ""))]
  1941.   "HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT"
  1942.   [(set (match_dup 0)
  1943.     (match_dup 1))]
  1944.   "
  1945. { operands[0] = gen_lowpart (SImode, operands[0]);
  1946.   operands[1] = gen_lowpart (SImode, operands[1]);
  1947. }")
  1948.  
  1949. (define_insn ""
  1950.   [(set (match_operand:DF 0 "out_operand" "=r,r,r,r,m")
  1951.     (match_operand:DF 1 "in_operand" "r,E,F,m,r"))
  1952.    (clobber (reg:SI 179))]
  1953.   "(gen_reg_operand (operands[0], DFmode)
  1954.     || gen_reg_operand (operands[1], DFmode))
  1955.    && ! TARGET_29050"
  1956.   "@
  1957.    sll %0,%1,0\;sll %L0,%L1,0
  1958.    #
  1959.    const %0,%1\;consth %0,%1\;const %L0,%L1\;consth %L0,%L1
  1960.    mtsrim cr,1\;loadm 0,0,%0,%1
  1961.    mtsrim cr,1\;storem 0,0,%1,%0"
  1962.   [(set_attr "type" "multi,multi,multi,multi,multi")])
  1963.  
  1964. (define_insn ""
  1965.   [(set (match_operand:DF 0 "out_operand" "=r,r,r,&r,m,*a,r")
  1966.     (match_operand:DF 1 "in_operand" "r,E,F,m,r,r,*a"))
  1967.    (clobber (reg:SI 179))]
  1968.   "(gen_reg_operand (operands[0], DFmode)
  1969.     || gen_reg_operand (operands[1], DFmode))
  1970.    && TARGET_29050"
  1971.   "@
  1972.    sll %0,%1,0\;sll %L0,%L1,0
  1973.    #
  1974.    const %0,%1\;consth %0,%1\;const %L0,%L1\;consth %L0,%L1
  1975.    mtsrim cr,1\;loadm 0,0,%0,%1
  1976.    mtsrim cr,1\;storem 0,0,%1,%0
  1977.    mtacc %1,2,%0
  1978.    mfacc %0,2,%1"
  1979.   [(set_attr "type" "multi,multi,multi,multi,multi,fadd,fadd")])
  1980.  
  1981. ;; Split register-register copies and constant loads into two SImode loads,
  1982. ;; one for each word.  In the constant case, they will get further split.
  1983. ;; Don't so this until register allocation, though, since it will
  1984. ;; interfere with register allocation.
  1985. (define_split
  1986.   [(set (match_operand:DF 0 "gen_reg_operand" "")
  1987.     (match_operand:DF 1 "gen_reg_or_float_constant_operand" ""))
  1988.    (clobber (reg:SI 179))]
  1989.   "reload_completed"
  1990.   [(set (match_dup 2) (match_dup 3))
  1991.    (set (match_dup 4) (match_dup 5))]
  1992.   "
  1993. { operands[2] = operand_subword (operands[0], 0, 1, DFmode);
  1994.   operands[3] = operand_subword (operands[1], 0, 1, DFmode);
  1995.   operands[4] = operand_subword (operands[0], 1, 1, DFmode);
  1996.   operands[5] = operand_subword (operands[1], 1, 1, DFmode);
  1997.  
  1998.   if (operands[2] == 0 || operands[3] == 0
  1999.       || operands[4] == 0 || operands[5] == 0)
  2000.     FAIL;
  2001. }")
  2002.  
  2003. ;; Split memory loads and stores into the MTSR and LOADM/STOREM.
  2004. (define_split
  2005.   [(set (match_operand:DF 0 "out_operand" "")
  2006.     (match_operand:DF 1 "in_operand" ""))
  2007.    (clobber (reg:SI 179))]
  2008.   "TARGET_NO_STOREM_BUG
  2009.    && (memory_operand (operands[0], DFmode)
  2010.        || memory_operand (operands[1], DFmode))"
  2011.   [(set (reg:SI 179) (const_int 1))
  2012.    (parallel [(set (match_dup 0) (match_dup 1))
  2013.           (use (reg:SI 179))
  2014.           (clobber (reg:SI 179))])]
  2015.   "")
  2016.  
  2017. ;; DI move is similar to DF move.  We have no way of handling CONST_DOUBLEs
  2018. ;; if HOST_BITS_PER_INT != BITS_PER_WORD, so don't bother trying.
  2019. (define_insn ""
  2020.   [(set (match_operand:DI 0 "out_operand" "=r,r,r,m")
  2021.     (match_operand:DI 1 "in_operand" "r,i,m,r"))
  2022.    (clobber (reg:SI 179))]
  2023.   "(gen_reg_operand (operands[0], DImode)
  2024.      || gen_reg_operand (operands[1], DImode))
  2025.    && ! TARGET_29050"
  2026.   "@
  2027.    sll %0,%1,0\;sll %L0,%L1,0
  2028.    #
  2029.    mtsrim cr,1\;loadm 0,0,%0,%1
  2030.    mtsrim cr,1\;storem 0,0,%1,%0"
  2031.   [(set_attr "type" "multi,multi,multi,multi")])
  2032.  
  2033. (define_insn ""
  2034.   [(set (match_operand:DI 0 "out_operand" "=r,r,&r,m")
  2035.     (match_operand:DI 1 "in_operand" "r,i,m,r"))
  2036.    (clobber (reg:SI 179))]
  2037.   "(gen_reg_operand (operands[0], DImode)
  2038.      || gen_reg_operand (operands[1], DImode))
  2039.    && TARGET_29050"
  2040.   "@
  2041.    sll %0,%1,0\;sll %L0,%L1,0
  2042.    #
  2043.    mtsrim cr,1\;loadm 0,0,%0,%1
  2044.    mtsrim cr,1\;storem 0,0,%1,%0"
  2045.   [(set_attr "type" "multi,multi,multi,multi")])
  2046.  
  2047. (define_split
  2048.   [(set (match_operand:DI 0 "gen_reg_operand" "")
  2049.     (match_operand:DI 1 "gen_reg_operand" ""))
  2050.    (clobber (reg:SI 179))]
  2051.   "reload_completed"
  2052.   [(set (match_dup 2) (match_dup 3))
  2053.    (set (match_dup 4) (match_dup 5))]
  2054.   "
  2055. { operands[2] = operand_subword (operands[0], 0, 1, DFmode);
  2056.   operands[3] = operand_subword (operands[1], 0, 1, DFmode);
  2057.   operands[4] = operand_subword (operands[0], 1, 1, DFmode);
  2058.   operands[5] = operand_subword (operands[1], 1, 1, DFmode);
  2059.  
  2060.   if (operands[2] == 0 || operands[3] == 0
  2061.       || operands[4] == 0 || operands[5] == 0)
  2062.     FAIL;
  2063. }")
  2064.  
  2065. (define_split
  2066.   [(set (match_operand:DI 0 "out_operand" "")
  2067.     (match_operand:DI 1 "in_operand" ""))
  2068.    (clobber (reg:SI 179))]
  2069.   "TARGET_NO_STOREM_BUG
  2070.    && (memory_operand (operands[0], DImode)
  2071.        || memory_operand (operands[1], DImode))"
  2072.   [(set (reg:SI 179) (const_int 1))
  2073.    (parallel [(set (match_dup 0) (match_dup 1))
  2074.           (use (reg:SI 179))
  2075.           (clobber (reg:SI 179))])]
  2076.   "")
  2077.  
  2078. ;; TImode moves are very similar to DImode moves, except that we can't
  2079. ;; have constants.
  2080. (define_insn ""
  2081.   [(set (match_operand:TI 0 "out_operand" "=r,r,m")
  2082.     (match_operand:TI 1 "in_operand" "r,m,r"))
  2083.    (clobber (reg:SI 179))]
  2084.   "(gen_reg_operand (operands[0], TImode)
  2085.     || gen_reg_operand (operands[1], TImode))
  2086.    && ! TARGET_29050"
  2087.   "@
  2088.    sll %0,%1,0\;sll %L0,%L1,0\;sll %O0,%O1,0\;sll %P0,%P1,0
  2089.    mtsrim cr,3\;loadm 0,0,%0,%1
  2090.    mtsrim cr,3\;storem 0,0,%1,%0"
  2091.   [(set_attr "type" "multi,multi,multi")])
  2092.  
  2093. (define_insn ""
  2094.   [(set (match_operand:TI 0 "out_operand" "=r,&r,m")
  2095.     (match_operand:TI 1 "in_operand" "r,m,r"))
  2096.    (clobber (reg:SI 179))]
  2097.   "(gen_reg_operand (operands[0], TImode)
  2098.     || gen_reg_operand (operands[1], TImode))
  2099.    && TARGET_29050"
  2100.   "@
  2101.    sll %0,%1,0\;sll %L0,%L1,0\;sll %O0,%O1,0\;sll %P0,%P1,0
  2102.    mtsrim cr,3\;loadm 0,0,%0,%1
  2103.    mtsrim cr,3\;storem 0,0,%1,%0"
  2104.   [(set_attr "type" "multi,multi,multi")])
  2105.  
  2106. (define_split
  2107.   [(set (match_operand:TI 0 "gen_reg_operand" "")
  2108.     (match_operand:TI 1 "gen_reg_operand" ""))
  2109.    (clobber (reg:SI 179))]
  2110.   "reload_completed"
  2111.   [(set (match_dup 2) (match_dup 3))
  2112.    (set (match_dup 4) (match_dup 5))
  2113.    (set (match_dup 6) (match_dup 7))
  2114.    (set (match_dup 8) (match_dup 9))]
  2115.   "
  2116. { operands[2] = gen_rtx (REG, SImode, REGNO (operands[0]));
  2117.   operands[3] = gen_rtx (REG, SImode, REGNO (operands[1]));
  2118.   operands[4] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
  2119.   operands[5] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
  2120.   operands[6] = gen_rtx (REG, SImode, REGNO (operands[0]) + 2);
  2121.   operands[7] = gen_rtx (REG, SImode, REGNO (operands[1]) + 2);
  2122.   operands[8] = gen_rtx (REG, SImode, REGNO (operands[0]) + 3);
  2123.   operands[9] = gen_rtx (REG, SImode, REGNO (operands[1]) + 3);  }")
  2124.  
  2125. (define_split
  2126.   [(set (match_operand:TI 0 "out_operand" "")
  2127.     (match_operand:TI 1 "in_operand" ""))
  2128.    (clobber (reg:SI 179))]
  2129.   "TARGET_NO_STOREM_BUG
  2130.    && (memory_operand (operands[0], TImode)
  2131.        || memory_operand (operands[1], TImode))"
  2132.   [(set (reg:SI 179) (const_int 1))
  2133.    (parallel [(set (match_dup 0) (match_dup 1))
  2134.           (use (reg:SI 179))
  2135.           (clobber (reg:SI 179))])]
  2136.   "")
  2137.  
  2138. (define_insn ""
  2139.   [(set (match_operand:SI 0 "out_operand" "=r,r,r,r,r,r,r,m,*h,*h")
  2140.         (match_operand:SI 1 "in_operand" "r,J,M,O,i,m,*h,r,r,J"))]
  2141.   "(gen_reg_operand (operands[0], SImode)
  2142.     || gen_reg_operand (operands[1], SImode)
  2143.     || (spec_reg_operand (operands[0], SImode)
  2144.         && cint_16_operand (operands[1], SImode)))
  2145.    && ! TARGET_29050"
  2146.   "@
  2147.    sll %0,%1,0
  2148.    const %0,%1
  2149.    constn %0,%M1
  2150.    cpeq %0,gr1,gr1
  2151.    #
  2152.    load 0,0,%0,%1
  2153.    mfsr %0,%1
  2154.    store 0,0,%1,%0
  2155.    mtsr %0,%1
  2156.    mtsrim %0,%1"
  2157.   [(set_attr "type" "misc,misc,misc,misc,multi,load,misc,store,misc,misc")])
  2158.  
  2159. (define_insn ""
  2160.   [(set (match_operand:SI 0 "out_operand" "=r,r,r,r,r,r,r,m,*h,*h")
  2161.         (match_operand:SI 1 "in_operand" "r,J,M,O,i,m,*h,r,r,J"))]
  2162.   "(gen_reg_operand (operands[0], SImode)
  2163.     || gen_reg_operand (operands[1], SImode)
  2164.     || (spec_reg_operand (operands[0], SImode)
  2165.         && cint_16_operand (operands[1], SImode)))
  2166.    && TARGET_29050"
  2167.   "@
  2168.    sll %0,%1,0
  2169.    const %0,%1
  2170.    constn %0,%M1
  2171.    consthz %0,%1
  2172.    #
  2173.    load 0,0,%0,%1
  2174.    mfsr %0,%1
  2175.    store 0,0,%1,%0
  2176.    mtsr %0,%1
  2177.    mtsrim %0,%1"
  2178.   [(set_attr "type" "misc,misc,misc,misc,multi,load,misc,store,misc,misc")])
  2179.  
  2180. (define_insn ""
  2181.   [(set (match_operand:HI 0 "out_operand" "=r,r,r,m,r,*h,*h")
  2182.         (match_operand:HI 1 "in_operand" "r,i,m,r,*h,r,i"))]
  2183.   "gen_reg_operand (operands[0], HImode)
  2184.    || gen_reg_operand (operands[1], HImode)"
  2185.   "@
  2186.    sll %0,%1,0
  2187.    const %0,%1
  2188.    load 0,2,%0,%1
  2189.    store 0,2,%1,%0
  2190.    mfsr %0,%1
  2191.    mtsr %0,%1
  2192.    mtsrim %0,%1"
  2193.   [(set_attr "type" "misc,misc,load,store,misc,misc,misc")])
  2194.  
  2195. (define_insn ""
  2196.   [(set (match_operand:QI 0 "out_operand" "=r,r,r,m,r,*h,*h")
  2197.         (match_operand:QI 1 "in_operand" "r,i,m,r,*h,r,i"))]
  2198.   "gen_reg_operand (operands[0], QImode)
  2199.    || gen_reg_operand (operands[1], QImode)"
  2200.   "@
  2201.    sll %0,%1,0
  2202.    const %0,%1
  2203.    load 0,1,%0,%1
  2204.    store 0,1,%1,%0
  2205.    mfsr %0,%1
  2206.    mtsr %0,%1
  2207.    mtsrim %0,%1"
  2208.   [(set_attr "type" "misc,misc,load,store,misc,misc,misc")])
  2209.  
  2210. ;; Define move insns for DI, TI, SF, and DF.
  2211. ;;
  2212. ;; In no case do we support mem->mem directly.
  2213. ;;
  2214. ;; For DI move of constant to register, split apart at this time since these
  2215. ;; can require anywhere from 2 to 4 insns and determining which is complex.
  2216. ;;
  2217. ;; In other cases, handle similarly to SImode moves.
  2218. ;;
  2219. ;; However, indicate that DI, TI, and DF moves (can) clobber CR (reg 179).
  2220. (define_expand "movdi"
  2221.   [(parallel [(set (match_operand:DI 0 "general_operand" "")
  2222.            (match_operand:DI 1 "general_operand" ""))
  2223.           (clobber (reg:SI 179))])]
  2224.   ""
  2225.   "
  2226. {
  2227.   if (GET_CODE (operands[0]) == MEM)
  2228.     operands[1] = force_reg (DImode, operands[1]);
  2229. }")
  2230.  
  2231. (define_expand "movsf"
  2232.   [(set (match_operand:SF 0 "general_operand" "")
  2233.     (match_operand:SF 1 "general_operand" ""))]
  2234.   ""
  2235.   "
  2236. { if (GET_CODE (operands[0]) == MEM)
  2237.     operands[1] = force_reg (SFmode, operands[1]);
  2238. }")
  2239.  
  2240. (define_expand "movdf"
  2241.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  2242.            (match_operand:DF 1 "general_operand" ""))
  2243.           (clobber (reg:SI 179))])]
  2244.   ""
  2245.   "
  2246. { if (GET_CODE (operands[0]) == MEM)
  2247.     operands[1] = force_reg (DFmode, operands[1]);
  2248. }")
  2249.  
  2250. (define_expand "movti"
  2251.   [(parallel [(set (match_operand:TI 0 "general_operand" "")
  2252.            (match_operand:TI 1 "general_operand" ""))
  2253.           (clobber (reg:SI 179))])]
  2254.   ""
  2255.   "
  2256. {
  2257.   if (GET_CODE (operands[0]) == MEM)
  2258.     operands[1] = force_reg (TImode, operands[1]);
  2259. }")
  2260.  
  2261. ;; For compare operations, we simply store the comparison operands and
  2262. ;; do nothing else.  The following branch or scc insn will output whatever
  2263. ;; is needed.
  2264. (define_expand "cmpsi"
  2265.   [(set (cc0)
  2266.     (compare (match_operand:SI 0 "gen_reg_operand" "")
  2267.          (match_operand:SI 1 "srcb_operand" "")))]
  2268.   ""
  2269.   "
  2270. {
  2271.   a29k_compare_op0 = operands[0];
  2272.   a29k_compare_op1 = operands[1];
  2273.   a29k_compare_fp_p = 0;
  2274.   DONE;
  2275. }")
  2276.  
  2277. (define_expand "cmpsf"
  2278.   [(set (cc0)
  2279.     (compare (match_operand:SF 0 "gen_reg_operand" "")
  2280.          (match_operand:SF 1 "gen_reg_operand" "")))]
  2281.   ""
  2282.   "
  2283. {
  2284.   a29k_compare_op0 = operands[0];
  2285.   a29k_compare_op1 = operands[1];
  2286.   a29k_compare_fp_p = 1;
  2287.   DONE;
  2288. }")
  2289.  
  2290. (define_expand "cmpdf"
  2291.   [(set (cc0)
  2292.     (compare (match_operand:DF 0 "gen_reg_operand" "")
  2293.          (match_operand:DF 1 "gen_reg_operand" "")))]
  2294.   ""
  2295.   "
  2296. {
  2297.   a29k_compare_op0 = operands[0];
  2298.   a29k_compare_op1 = operands[1];
  2299.   a29k_compare_fp_p = 1;
  2300.   DONE;
  2301. }")
  2302.  
  2303. ;; We can generate bit-tests better if we use NE instead of EQ, but we
  2304. ;; don't have an NE for floating-point.  So we have to have two patterns
  2305. ;; for EQ and two for NE.
  2306.  
  2307. (define_expand "beq"
  2308.   [(set (match_dup 1) (ne:SI (match_dup 2) (match_dup 3)))
  2309.    (set (pc)
  2310.     (if_then_else (ge (match_dup 1) (const_int 0))
  2311.               (label_ref (match_operand 0 "" ""))
  2312.               (pc)))]
  2313.   ""
  2314.   "
  2315. {
  2316.   if (GET_MODE_CLASS (GET_MODE (a29k_compare_op0)) == MODE_FLOAT)
  2317.     {
  2318.       emit_insn (gen_beq_fp (operands[0]));
  2319.       DONE;
  2320.     }
  2321.  
  2322.   operands[1] = gen_reg_rtx (SImode);
  2323.   operands[2] = a29k_compare_op0;
  2324.   operands[3] = a29k_compare_op1;
  2325. }")
  2326.  
  2327. (define_expand "beq_fp"
  2328.   [(set (match_dup 1) (eq:SI (match_dup 2) (match_dup 3)))
  2329.    (set (pc)
  2330.     (if_then_else (lt (match_dup 1) (const_int 0))
  2331.               (label_ref (match_operand 0 "" ""))
  2332.               (pc)))]
  2333.   ""
  2334.   "
  2335. {
  2336.   operands[1] = gen_reg_rtx (SImode);
  2337.   operands[2] = a29k_compare_op0;
  2338.   operands[3] = a29k_compare_op1;
  2339. }")
  2340.  
  2341. (define_expand "bne"
  2342.   [(set (match_dup 1) (ne:SI (match_dup 2) (match_dup 3)))
  2343.    (set (pc)
  2344.     (if_then_else (lt (match_dup 1) (const_int 0))
  2345.               (label_ref (match_operand 0 "" ""))
  2346.               (pc)))]
  2347.   ""
  2348.   "
  2349. {
  2350.   if (GET_MODE_CLASS (GET_MODE (a29k_compare_op0)) == MODE_FLOAT)
  2351.     {
  2352.       emit_insn (gen_bne_fp (operands[0]));
  2353.       DONE;
  2354.     }
  2355.  
  2356.   operands[1] = gen_reg_rtx (SImode);
  2357.   operands[2] = a29k_compare_op0;
  2358.   operands[3] = a29k_compare_op1;
  2359. }")
  2360.  
  2361. (define_expand "bne_fp"
  2362.   [(set (match_dup 1) (eq:SI (match_dup 2) (match_dup 3)))
  2363.    (set (pc)
  2364.     (if_then_else (ge (match_dup 1) (const_int 0))
  2365.               (label_ref (match_operand 0 "" ""))
  2366.               (pc)))]
  2367.   ""
  2368.   "
  2369. {
  2370.   operands[1] = gen_reg_rtx (SImode);
  2371.   operands[2] = a29k_compare_op0;
  2372.   operands[3] = a29k_compare_op1;
  2373. }")
  2374.  
  2375. ;; We don't have a floating-point "lt" insn, so we have to use "gt" in that
  2376. ;; case with the operands swapped.  The operands must both be registers in
  2377. ;; the floating-point case, so we know that swapping them is OK.
  2378. (define_expand "blt"
  2379.   [(set (match_dup 1) (match_dup 2))
  2380.    (set (pc)
  2381.     (if_then_else (lt (match_dup 1) (const_int 0))
  2382.               (label_ref (match_operand 0 "" ""))
  2383.               (pc)))]
  2384.   ""
  2385.   "
  2386. {
  2387.   operands[1] = gen_reg_rtx (SImode);
  2388.   if (a29k_compare_fp_p)
  2389.     operands[2] = gen_rtx (GT, SImode, a29k_compare_op1, a29k_compare_op0);
  2390.   else
  2391.     operands[2] = gen_rtx (LT, SImode, a29k_compare_op0, a29k_compare_op1);
  2392. }")
  2393.  
  2394. ;; Similarly for "le".
  2395. (define_expand "ble"
  2396.   [(set (match_dup 1) (match_dup 2))
  2397.    (set (pc)
  2398.     (if_then_else (lt (match_dup 1) (const_int 0))
  2399.               (label_ref (match_operand 0 "" ""))
  2400.               (pc)))]
  2401.   ""
  2402.   "
  2403. {
  2404.   operands[1] = gen_reg_rtx (SImode);
  2405.   if (a29k_compare_fp_p)
  2406.     operands[2] = gen_rtx (GE, SImode, a29k_compare_op1, a29k_compare_op0);
  2407.   else
  2408.     operands[2] = gen_rtx (LE, SImode, a29k_compare_op0, a29k_compare_op1);
  2409. }")
  2410.  
  2411. (define_expand "bltu"
  2412.   [(set (match_dup 1) (ltu:SI (match_dup 2) (match_dup 3)))
  2413.    (set (pc)
  2414.     (if_then_else (lt (match_dup 1) (const_int 0))
  2415.               (label_ref (match_operand 0 "" ""))
  2416.               (pc)))]
  2417.   ""
  2418.   "
  2419. {
  2420.   operands[1] = gen_reg_rtx (SImode);
  2421.   operands[2] = a29k_compare_op0;
  2422.   operands[3] = a29k_compare_op1;
  2423. }")
  2424.  
  2425. (define_expand "bleu"
  2426.   [(set (match_dup 1) (leu:SI (match_dup 2) (match_dup 3)))
  2427.    (set (pc)
  2428.     (if_then_else (lt (match_dup 1) (const_int 0))
  2429.               (label_ref (match_operand 0 "" ""))
  2430.               (pc)))]
  2431.   ""
  2432.   "
  2433. {
  2434.   operands[1] = gen_reg_rtx (SImode);
  2435.   operands[2] = a29k_compare_op0;
  2436.   operands[3] = a29k_compare_op1;
  2437. }")
  2438.  
  2439. (define_expand "bgt"
  2440.   [(set (match_dup 1) (gt:SI (match_dup 2) (match_dup 3)))
  2441.    (set (pc)
  2442.     (if_then_else (lt (match_dup 1) (const_int 0))
  2443.               (label_ref (match_operand 0 "" ""))
  2444.               (pc)))]
  2445.   ""
  2446.   "
  2447. {
  2448.   operands[1] = gen_reg_rtx (SImode);
  2449.   operands[2] = a29k_compare_op0;
  2450.   operands[3] = a29k_compare_op1;
  2451. }")
  2452.  
  2453. (define_expand "bge"
  2454.   [(set (match_dup 1) (ge:SI (match_dup 2) (match_dup 3)))
  2455.    (set (pc)
  2456.     (if_then_else (lt (match_dup 1) (const_int 0))
  2457.               (label_ref (match_operand 0 "" ""))
  2458.               (pc)))]
  2459.   ""
  2460.   "
  2461. {
  2462.   operands[1] = gen_reg_rtx (SImode);
  2463.   operands[2] = a29k_compare_op0;
  2464.   operands[3] = a29k_compare_op1;
  2465. }")
  2466.  
  2467. (define_expand "bgtu"
  2468.   [(set (match_dup 1) (gtu:SI (match_dup 2) (match_dup 3)))
  2469.    (set (pc)
  2470.     (if_then_else (lt (match_dup 1) (const_int 0))
  2471.               (label_ref (match_operand 0 "" ""))
  2472.               (pc)))]
  2473.   ""
  2474.   "
  2475. {
  2476.   operands[1] = gen_reg_rtx (SImode);
  2477.   operands[2] = a29k_compare_op0;
  2478.   operands[3] = a29k_compare_op1;
  2479. }")
  2480.  
  2481. (define_expand "bgeu"
  2482.   [(set (match_dup 1) (geu:SI (match_dup 2) (match_dup 3)))
  2483.    (set (pc)
  2484.     (if_then_else (lt (match_dup 1) (const_int 0))
  2485.               (label_ref (match_operand 0 "" ""))
  2486.               (pc)))]
  2487.   ""
  2488.   "
  2489. {
  2490.   operands[1] = gen_reg_rtx (SImode);
  2491.   operands[2] = a29k_compare_op0;
  2492.   operands[3] = a29k_compare_op1;
  2493. }")
  2494.  
  2495. (define_expand "seq"
  2496.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2497.     (eq:SI (match_dup 1) (match_dup 2)))]
  2498.   ""
  2499.   "
  2500. {
  2501.   operands[1] = a29k_compare_op0;
  2502.   operands[2] = a29k_compare_op1;
  2503. }")
  2504.          
  2505. ;; This is the most complicated case, because we don't have a floating-point
  2506. ;; "ne" insn.  If integer, handle normally.  If floating-point, write the
  2507. ;; compare and then write an insn to reverse the test.
  2508. (define_expand "sne_fp"
  2509.   [(set (match_dup 3)
  2510.     (eq:SI (match_operand 1 "gen_reg_operand" "")
  2511.            (match_operand 2 "gen_reg_operand" "")))
  2512.    (set (match_operand:SI 0 "gen_reg_operand" "")
  2513.     (ge:SI (match_dup 3) (const_int 0)))]
  2514.   ""
  2515.   "
  2516. { operands[3] = gen_reg_rtx (SImode);
  2517. }");
  2518.  
  2519. (define_expand "sne"
  2520.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2521.     (ne:SI (match_dup 1) (match_dup 2)))]
  2522.   ""
  2523.   "
  2524. {
  2525.   operands[1] = a29k_compare_op0;
  2526.   operands[2] = a29k_compare_op1;
  2527.  
  2528.   if (a29k_compare_fp_p)
  2529.     {
  2530.       emit_insn (gen_sne_fp (operands[0], operands[1], operands[2]));
  2531.       DONE;
  2532.     }
  2533. }")
  2534.          
  2535. ;; We don't have a floating-point "lt" insn, so use "gt" and swap the
  2536. ;; operands, the same as we do "blt".
  2537. (define_expand "slt"
  2538.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2539.     (match_dup 1))]
  2540.   ""
  2541.   "
  2542. {
  2543.   if (a29k_compare_fp_p)
  2544.     operands[1] = gen_rtx (GT, SImode, a29k_compare_op1, a29k_compare_op0);
  2545.   else
  2546.     operands[1] = gen_rtx (LT, SImode, a29k_compare_op0, a29k_compare_op1);
  2547. }")
  2548.  
  2549. ;; Similarly for "le"
  2550. (define_expand "sle"
  2551.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2552.     (match_dup 1))]
  2553.   ""
  2554.   "
  2555. {
  2556.   if (a29k_compare_fp_p)
  2557.     operands[1] = gen_rtx (GE, SImode, a29k_compare_op1, a29k_compare_op0);
  2558.   else
  2559.     operands[1] = gen_rtx (LE, SImode, a29k_compare_op0, a29k_compare_op1);
  2560. }")
  2561.  
  2562. (define_expand "sltu"
  2563.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2564.     (ltu:SI (match_dup 1) (match_dup 2)))]
  2565.   ""
  2566.   "
  2567. {
  2568.   operands[1] = a29k_compare_op0;
  2569.   operands[2] = a29k_compare_op1;
  2570. }")
  2571.  
  2572. (define_expand "sleu"
  2573.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2574.     (leu:SI (match_dup 1) (match_dup 2)))]
  2575.   ""
  2576.   "
  2577. {
  2578.   operands[1] = a29k_compare_op0;
  2579.   operands[2] = a29k_compare_op1;
  2580. }")
  2581.  
  2582. (define_expand "sgt"
  2583.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2584.     (gt:SI (match_dup 1) (match_dup 2)))]
  2585.   ""
  2586.   "
  2587. {
  2588.   operands[1] = a29k_compare_op0;
  2589.   operands[2] = a29k_compare_op1;
  2590. }")
  2591.  
  2592. (define_expand "sge"
  2593.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2594.     (ge:SI (match_dup 1) (match_dup 2)))]
  2595.   ""
  2596.   "
  2597. {
  2598.   operands[1] = a29k_compare_op0;
  2599.   operands[2] = a29k_compare_op1;
  2600. }")
  2601.          
  2602. (define_expand "sgtu"
  2603.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2604.     (gtu:SI (match_dup 1) (match_dup 2)))]
  2605.   ""
  2606.   "
  2607. {
  2608.   operands[1] = a29k_compare_op0;
  2609.   operands[2] = a29k_compare_op1;
  2610. }")
  2611.  
  2612. (define_expand "sgeu"
  2613.   [(set (match_operand:SI 0 "gen_reg_operand" "")
  2614.     (geu:SI (match_dup 1) (match_dup 2)))]
  2615.   ""
  2616.   "
  2617. {
  2618.   operands[1] = a29k_compare_op0;
  2619.   operands[2] = a29k_compare_op1;
  2620. }")
  2621.  
  2622. ;; Now define the actual jump insns.
  2623. (define_insn ""
  2624.   [(set (pc)
  2625.     (if_then_else (match_operator 0 "branch_operator"
  2626.                       [(match_operand:SI 1 "gen_reg_operand" "r")
  2627.                        (const_int 0)])
  2628.               (label_ref (match_operand 2 "" ""))
  2629.               (pc)))]
  2630.   ""
  2631.   "jmp%b0 %1,%l2%#"
  2632.   [(set_attr "type" "branch")])
  2633.  
  2634. (define_insn ""
  2635.   [(set (pc)
  2636.     (if_then_else (match_operator 0 "branch_operator"
  2637.                       [(match_operand:SI 1 "gen_reg_operand" "r")
  2638.                        (const_int 0)])
  2639.               (return)
  2640.               (pc)))]
  2641.   "null_epilogue ()"
  2642.   "jmp%b0i %1,lr0%#"
  2643.   [(set_attr "type" "branch")])
  2644.  
  2645. (define_insn ""
  2646.   [(set (pc)
  2647.     (if_then_else (match_operator 0 "branch_operator"
  2648.                       [(match_operand:SI 1 "gen_reg_operand" "r")
  2649.                        (const_int 0)])
  2650.               (pc)
  2651.               (label_ref (match_operand 2 "" ""))))]
  2652.   ""
  2653.   "jmp%B0 %1,%l2%#"
  2654.   [(set_attr "type" "branch")])
  2655.  
  2656. (define_insn ""
  2657.   [(set (pc)
  2658.     (if_then_else (match_operator 0 "branch_operator"
  2659.                       [(match_operand:SI 1 "gen_reg_operand" "r")
  2660.                        (const_int 0)])
  2661.               (pc)
  2662.               (return)))]
  2663.   "null_epilogue ()"
  2664.   "jmp%B0i %1,lr0%#"
  2665.   [(set_attr "type" "branch")])
  2666.  
  2667. (define_insn "jump"
  2668.   [(set (pc)
  2669.     (label_ref (match_operand 0 "" "")))]
  2670.   ""
  2671.   "jmp %e0%E0"
  2672.   [(set_attr "type" "branch")])
  2673.  
  2674. (define_insn "return"
  2675.   [(return)]
  2676.   "null_epilogue ()"
  2677.   "jmpi lr0%#"
  2678.   [(set_attr "type" "branch")])
  2679.  
  2680. (define_insn "indirect_jump"
  2681.   [(set (pc)
  2682.     (match_operand:SI 0 "gen_reg_operand" "r"))]
  2683.   ""
  2684.   "jmpi %0%#"
  2685.   [(set_attr "type" "branch")])
  2686.  
  2687. (define_insn "tablejump"
  2688.   [(set (pc)
  2689.     (match_operand:SI 0 "gen_reg_operand" "r"))
  2690.    (use (label_ref (match_operand 1 "" "")))]
  2691.   ""
  2692.   "jmpi %0%#"
  2693.   [(set_attr "type" "branch")])
  2694.  
  2695. ;; JMPFDEC
  2696. (define_insn ""
  2697.   [(set (pc)
  2698.     (if_then_else (ge (match_operand:SI 0 "gen_reg_operand" "r")
  2699.               (const_int 0))
  2700.               (label_ref (match_operand 1 "" ""))
  2701.               (pc)))
  2702.    (set (match_dup 0)
  2703.     (plus:SI (match_dup 0)
  2704.          (const_int -1)))]
  2705.   ""
  2706.   "jmpfdec %0,%l1%#"
  2707.   [(set_attr "type" "branch")])
  2708.  
  2709. ;;- Local variables:
  2710. ;;- mode:emacs-lisp
  2711. ;;- comment-start: ";;- "
  2712. ;;- eval: (set-syntax-table (copy-sequence (syntax-table)))
  2713. ;;- eval: (modify-syntax-entry ?[ "(]")
  2714. ;;- eval: (modify-syntax-entry ?] ")[")
  2715. ;;- eval: (modify-syntax-entry ?{ "(}")
  2716. ;;- eval: (modify-syntax-entry ?} "){")
  2717. ;;- End:
  2718.