home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / m88k.md < prev    next >
Text File  |  1991-06-10  |  86KB  |  2,962 lines
  1. ;;- Machine description for the Motorola 88000 for GNU C compiler
  2. ;;  Copyright (C) 1988, 1990 Free Software Foundation, Inc.
  3. ;;  Contributed by Michael Tiemann (tiemann@mcc.com)
  4. ;;  Additional changes by Michael Meissner (meissner@osf.org)
  5. ;;  Currently supported by Tom Wood (wood@dg-rtp.dg.com)
  6.  
  7. ;; This file is part of GNU CC.
  8.  
  9. ;; GNU CC is free software; you can redistribute it and/or modify
  10. ;; it under the terms of the GNU General Public License as published by
  11. ;; the Free Software Foundation; either version 2, or (at your option)
  12. ;; any later version.
  13.  
  14. ;; GNU CC is distributed in the hope that it will be useful,
  15. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. ;; GNU General Public License for more details.
  18.  
  19. ;; You should have received a copy of the GNU General Public License
  20. ;; along with GNU CC; see the file COPYING.  If not, write to
  21. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  
  23.  
  24. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  25.  
  26. ;; SCCS rev field.  This is a NOP, just to get the SCCS id into the
  27. ;; program image.
  28. (define_expand "m88k_sccs_id"
  29.   [(match_operand:SI 0 "" "")]
  30.   ""
  31.   "{ static char sccs_id[] = \"@(#)m88k.md    1.93.5.4 5/29/91 07:30:05\";
  32.      FAIL; }")
  33.  
  34. ;; Attribute specifications
  35.  
  36. ; Type of each instruction.  Default is arithmetic.
  37. ; I'd like to write the list as this, but genattrtab won't accept it.
  38. ;
  39. ; "branch,jump,call,            ; flow-control instructions
  40. ;  load,store,loada,            ; data unit instructions
  41. ;  spadd,dpadd,spdiv,dpdiv,idiv,    ; FPU add instructions
  42. ;  spmul,dpmul,imul,            ; FPU multiply instructions
  43. ;  arith,                ; integer unit instructions
  44. ;  marith,mstore,mfp,wierd"        ; multi-word instructions
  45.  
  46. ; Classification of each insn.  Some insns of TYPE_BRANCH are multi-word.
  47. (define_attr "type"
  48.   "branch,jump,call,load,store,loada,spadd,dpadd,spdiv,dpdiv,idiv,spmul,dpmul,imul,arith,marith,mstore,mfp,wierd"
  49.   (const_string "arith"))
  50.  
  51. ; Convenience attributes.
  52. (define_attr "fpu" "yes,no"
  53.   (if_then_else
  54.    (eq_attr "type" "spmul,dpmul,imul,spadd,dpadd,spdiv,dpdiv,idiv,mfp")
  55.    (const_string "yes") (const_string "no")))
  56.  
  57. ; Length in # of instructions of each insn.  The values are not exact, but
  58. ; are safe.
  59. (define_attr "length" ""
  60.   (cond [(eq_attr "type" "marith,mstore,mfp")
  61.      (const_int 2)]
  62.     (const_int 1)))
  63.  
  64. ; Describe a user's asm statement.
  65. (define_asm_attributes
  66.   [(set_attr "type" "wierd")])
  67.  
  68. ; Define the delay slot requirements for branches and calls.
  69. ; The m88100 annuls instructions if a conditional branch is taken.
  70. ; For insns of TYPE_BRANCH that are multi-word instructions, the
  71. ; delay slot applies to the first instruction.
  72.  
  73. ; @@ For the moment, reorg.c requires that the delay slot of a branch not
  74. ; be a call or branch.
  75.  
  76. (define_delay (eq_attr "type" "branch,jump")
  77.   [(and
  78.     (and
  79.      (eq_attr "type" "!branch,jump,call,marith,mstore,mfp,wierd") ; required.
  80.      (eq_attr "type" "!load")) ; issue as-soon-as-possible.
  81.     (eq_attr "fpu" "no")) ; issue as-soon-as-possible.
  82.    (eq_attr "type" "!call,branch,jump") (nil)]) ; @@ was (const_int 1)
  83.  
  84. ; output_call supports an unconditional branch in the delay slot of
  85. ; a call.  (@@ Support for this case is expected in reorg.c soon.)
  86.  
  87. (define_delay (eq_attr "type" "call")
  88.   [(eq_attr "type" "!branch,call,marith,mstore,mfp,wierd") ; required.
  89.    (nil) (nil)])
  90.  
  91. ; An abstract block diagram of the function units for the m88100.
  92. ;
  93. ;                *
  94. ;                |
  95. ;            +---v----+
  96. ;            | decode |
  97. ;            +-vv-v-v-+     fpu
  98. ;           ,----------'| | `----------------------.
  99. ;           |       | |                  |    ,-----.
  100. ;      load |     store | | arith              |    |     |
  101. ;           |       | |                +-v-v-+   |    dp source
  102. ;           |       | |                | fp1 |---'
  103. ;     store    |       | |        div            +-v-v-+
  104. ;   ,------.   |       | |      ,-----. ,-----------'    `-----------.
  105. ;   |       |   |       | |      |    | |                |
  106. ;   |    +--v---v--+    ,---' |      |   +-v-v---+            +---v---+
  107. ;   |    | stage    2 |    |     |      `---|    add 2 |            | mul 2    |
  108. ;   |    +---------+    |  +--v--+     +-------+          imul    +-------+
  109. ;   |    | stage    1 |    |  | alu    |     |    add 3 |           ,--------| mul 3    |
  110. ;   |    +---------+    |  +--v--+     +-------+           |    +-------+
  111. ;   |    | stage    0 |    |     |          |    add 4 |           |    | mul 4    |
  112. ;   |    +--v---v--+    |     |          +---v---+           |    +-------+
  113. ;   |       |   |       |     |          |           |    | mul 5    |
  114. ;   |       *   |       |     |          |           |    +---v---+
  115. ;   |           |       |     |          |      +----v----+        |
  116. ;   |      load |       |     |       fp add `------>| fp last |<------' fp mul
  117. ;   |           |       |     |              +---v-v--^+
  118. ;   |           |       |     |                  |    |  |
  119. ;   |           |       |     |                  |    `--' dp    dest
  120. ;   |           |    +--v-----v--+              |
  121. ;   |           `--->| writeback    |<--------------------'
  122. ;   |            +--v-----v--+
  123. ;   |               |     |
  124. ;   `------------------'     *
  125. ;
  126. ; The decode unit need not be specified.
  127. ; Consideration of writeback contention is critical to superb scheduling.
  128. ;
  129. ; (define_function_unit NAME MULTIPLICITY SIMULTANEITY
  130. ;            TEST READY-DELAY BUSY-DELAY [CONFLICT-LIST])
  131.  
  132. ;(define_function_unit "decode" 1 1 (const_int 1) 0 1)
  133.  
  134. ; Describing the alu is currently not useful.
  135. ;(define_function_unit "alu" 1 0 (eq_attr "type"
  136. ;                     "!store,mstore,marith,mfp,wierd") 1 0)
  137. ;(define_function_unit "alu" 1 0 (eq_attr "type" "marith,wierd") 2 0)
  138.  
  139. (define_function_unit "memory" 1 3 (eq_attr "type" "load") 3 2)
  140.  
  141. (define_function_unit "fp1" 1 1 (eq_attr "fpu" "yes") 1 2)
  142.  
  143. (define_function_unit "fpmul" 1 4 (eq_attr "type" "spmul") 4 2)
  144. (define_function_unit "fpmul" 1 4 (eq_attr "type" "dpmul,mfp") 7 2)
  145. (define_function_unit "fpmul" 1 4 (eq_attr "type" "imul") 2 2)
  146.  
  147. (define_function_unit "fpadd" 1 3 (eq_attr "type" "spadd") 3 2)
  148. (define_function_unit "fpadd" 1 3 (eq_attr "type" "dpadd") 4 2)
  149. (define_function_unit "fpadd" 1 3 (eq_attr "type" "spdiv") 28 2)
  150. (define_function_unit "fpadd" 1 3 (eq_attr "type" "dpdiv") 58 2)
  151. (define_function_unit "fpadd" 1 3 (eq_attr "type" "idiv") 36 2)
  152.  
  153. (define_function_unit "fplast" 1 1 (eq_attr "fpu" "yes") 1 2)
  154.  
  155. ; Describing writeback contention is currently not useful.
  156. ;(define_function_unit "writeback" 1 1
  157. ;  (eq_attr "type" "!store,mstore,branch,jump,call") 0 1)
  158.  
  159. ; Describing stores is currently not useful.  The suggestion here is that the
  160. ; function unit ordering has already been established (writeback is last) and
  161. ; that store insns use the units in an unusal order.
  162. ;(define_function_unit "writeback" 1 1 (eq_attr "type" "store,mstore") 0 1)
  163. ;(define_function_unit "memory" 1 3 (eq_attr "type" "store,mstore") 1 2)
  164.  
  165. ;; This rich set of complex patterns are mostly due to Torbjorn Granlund
  166. ;; (tege@sics.se).  They've changed since then, so don't complain to him
  167. ;; if they don't work right.
  168.  
  169. ;; Regarding shifts, gen_lshlsi3 generates ASHIFT.  LSHIFT opcodes are
  170. ;; not produced and should not normally occur.  Also, the gen functions
  171. ;; produce the necessary insns to support TARGET_*_LARGE_SHIFT, so nothing
  172. ;; special needs to be done here.
  173.  
  174. ;; (a << int1) >> int2 optimizations into a single extract.
  175. ;; These patterns need to occur before the normal shift patterns
  176.  
  177. (define_insn ""
  178.   [(set (match_operand:SI 0 "register_operand" "=r")
  179.     (ashiftrt:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
  180.                 (match_operand:SI 2 "int5_operand" ""))
  181.              (match_operand:SI 3 "int5_operand" "")))]
  182.   "INTVAL (operands [2]) <= INTVAL (operands [3])"
  183.   "ext %0,%1,%w3<(%3-%2)>")
  184.  
  185. (define_insn ""
  186.   [(set (match_operand:SI 0 "register_operand" "=r")
  187.     (lshiftrt:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
  188.                 (match_operand:SI 2 "int5_operand" ""))
  189.              (match_operand:SI 3 "int5_operand" "")))]
  190.   "INTVAL (operands [2]) <= INTVAL (operands [3])"
  191.   "extu %0,%1,%w3<(%3-%2)>")
  192.  
  193. ;; Optimize possible cases of the set instruction.
  194.  
  195. (define_insn ""
  196.   [(set (match_operand:SI 0 "register_operand" "=r")
  197.         (ashift:SI (const_int -1)
  198.                (match_operand:SI 1 "register_operand" "r")))]
  199.   ""
  200.   "set %0,%#r0,%1")
  201.  
  202. (define_insn ""
  203.   [(set (match_operand:SI 0 "register_operand" "=r")
  204.         (ior:SI (ashift:SI (const_int -1)
  205.                    (match_operand:SI 1 "register_operand" "r"))
  206.             (match_operand:SI 2 "register_operand" "r")))]
  207.   ""
  208.   "set %0,%2,%1")
  209.  
  210. (define_insn ""
  211.   [(set (match_operand:SI 0 "register_operand" "=r")
  212.         (ior:SI (match_operand:SI 1 "register_operand" "r")
  213.             (ashift:SI (const_int -1)
  214.                    (match_operand:SI 2 "register_operand" "r"))))]
  215.   ""
  216.   "set %0,%1,%2")
  217.  
  218. ;; Optimize possible cases of the mak instruction.
  219.  
  220. (define_insn ""
  221.   [(set (match_operand:SI 0 "register_operand" "=r")
  222.     (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
  223.                (match_operand:SI 2 "int5_operand" ""))
  224.         (match_operand:SI 3 "immediate_operand" "n")))]
  225.   "mak_mask_p (INTVAL (operands[3]) >> INTVAL (operands[2]))"
  226.   "*
  227. {
  228.   operands[4] = gen_rtx (CONST_INT, SImode,
  229.              exact_log2 (1 + (INTVAL (operands[3])
  230.                       >> INTVAL(operands[2]))));
  231.   return \"mak %0,%1,%4<%2>\";
  232. }")
  233.  
  234. ;; Optimize possible cases of output_and.
  235.  
  236. (define_insn ""
  237.   [(set (match_operand:SI 0 "register_operand" "=r")
  238.     (ashift:SI (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  239.                     (match_operand:SI 2 "int5_operand" "")
  240.                     (match_operand:SI 3 "int5_operand" ""))
  241.            (match_operand:SI 4 "int5_operand" "")))]
  242.   "INTVAL (operands[2]) + INTVAL (operands[3]) + INTVAL (operands[4]) == 32"
  243.   "*
  244. {
  245.   operands[2]
  246.     = gen_rtx (CONST_INT, SImode,
  247.            ((1 << INTVAL (operands[2])) - 1) << INTVAL (operands[4]));
  248.   return output_and (operands);
  249. }"
  250.   [(set_attr "type" "marith")]) ; length is 1 or 2.
  251.  
  252. ;; Recognize bcnd instructions for integer values.  This is distinguished
  253. ;; from a conditional branch instruction (below) with SImode instead of
  254. ;; CCmode.
  255.  
  256. (define_insn ""
  257.   [(set (pc)
  258.     (if_then_else
  259.      (match_operator 0 "relop_no_unsigned"
  260.              [(match_operand:SI 1 "register_operand" "r")
  261.               (const_int 0)])
  262.      (match_operand 2 "pc_or_label_ref" "")
  263.      (match_operand 3 "pc_or_label_ref" "")))]
  264.   ""
  265.   "bcnd%. %R3%B0,%1,%P2%P3"
  266.   [(set_attr "type" "branch")])
  267.  
  268. ;; Recognize tests for sign and zero.
  269.  
  270. (define_insn ""
  271.   [(set (pc)
  272.     (if_then_else
  273.      (match_operator 0 "equality_op"
  274.              [(match_operand:SI 1 "register_operand" "r")
  275.               (const_int -2147483648)])
  276.      (match_operand 2 "pc_or_label_ref" "")
  277.      (match_operand 3 "pc_or_label_ref" "")))]
  278.   ""
  279.   "bcnd%. %R3%E0,%1,%P2%P3"
  280.   [(set_attr "type" "branch")])
  281.  
  282. (define_insn ""
  283.   [(set (pc)
  284.     (if_then_else
  285.      (match_operator 0 "equality_op"
  286.              [(zero_extract:SI
  287.                (match_operand:SI 1 "register_operand" "r")
  288.                (const_int 31)
  289.                (const_int 1))
  290.               (const_int 0)])
  291.      (match_operand 2 "pc_or_label_ref" "")
  292.      (match_operand 3 "pc_or_label_ref" "")))]
  293.   ""
  294.   "bcnd%. %R3%D0,%1,%P2%P3"
  295.   [(set_attr "type" "branch")])
  296.  
  297. ;; Recognize bcnd instructions for double integer values
  298.  
  299. (define_insn ""
  300.   [(set (pc)
  301.     (if_then_else
  302.      (match_operator 0 "relop_no_unsigned"
  303.              [(sign_extend:DI
  304.                (match_operand:SI 1 "register_operand" "r"))
  305.               (const_int 0)])
  306.      (match_operand 2 "pc_or_label_ref" "")
  307.      (match_operand 3 "pc_or_label_ref" "")))]
  308.   ""
  309.   "bcnd%. %R3%B0,%1,%P2%P3"
  310.   [(set_attr "type" "branch")])
  311.  
  312. (define_insn ""
  313.   [(set (pc)
  314.     (if_then_else
  315.      (match_operator 0 "equality_op"
  316.              [(zero_extend:DI
  317.                (match_operand:SI 1 "register_operand" "r"))
  318.               (const_int 0)])
  319.      (match_operand 2 "pc_or_label_ref" "")
  320.      (match_operand 3 "pc_or_label_ref" "")))]
  321.   ""
  322.   "bcnd%. %R3%B0,%1,%P2%P3"
  323.   [(set_attr "type" "branch")])
  324.  
  325. ; @@ I doubt this is interesting until cmpdi is provided.  Anyway, it needs
  326. ; to be reworked.
  327. ;
  328. ;(define_insn ""
  329. ;  [(set (pc)
  330. ;    (if_then_else
  331. ;     (match_operator 0 "relop_no_unsigned"
  332. ;             [(match_operand:DI 1 "register_operand" "r")
  333. ;              (const_int 0)])
  334. ;     (match_operand 2 "pc_or_label_ref" "")
  335. ;     (match_operand 3 "pc_or_label_ref" "")))]
  336. ;  ""
  337. ;  "*
  338. ;{
  339. ;  switch (GET_CODE (operands[0]))
  340. ;    {
  341. ;    case EQ:
  342. ;    case NE:
  343. ;      /* I'm not sure if it's safe to use .n here.  */
  344. ;      return \"or %!,%1,%d1\;bcnd %R3%B0,%!,%P2%P3\";
  345. ;    case GE:
  346. ;    case LT:
  347. ;      return \"bcnd%. %R3%B0,%1,%P2%P3\";
  348. ;    case GT:
  349. ;      {
  350. ;    rtx op2 = operands[2];
  351. ;    operands[2] = operands[3];
  352. ;    operands[3] = op2;
  353. ;      }
  354. ;    case LE:
  355. ;      if (GET_CODE (operands[3]) == LABEL_REF)
  356. ;    {
  357. ;      int label_num;
  358. ;      operands[2] = gen_label_rtx ();
  359. ;      label_num = XINT (operands[2], 3);
  360. ;      output_asm_insn
  361. ;        (\"bcnd%. %#lt0,%1,%2\;or %!,%1,%d1\;bcnd %#ne0,%!,%3\", operands);
  362. ;      output_label (label_num);
  363. ;      return \"\";
  364. ;    }
  365. ;      else
  366. ;    return \"bcnd%. %#lt0,%1,%2\;or %!,%1,%d1\;bcnd %#eq0,%!,%2\";
  367. ;    }
  368. ;}")
  369.  
  370. ;; Recognize bcnd instructions for single precision float values
  371. ;; Exclude relational operations as they must signal NaNs.
  372.  
  373. ;; @@ These bcnd insns for float and double values don't seem to be recognized.
  374.  
  375. (define_insn ""
  376.   [(set (pc)
  377.     (if_then_else
  378.      (match_operator 0 "equality_op"
  379.              [(float_extend:DF
  380.                (match_operand:SF 1 "register_operand" "r"))
  381.               (const_int 0)])
  382.      (match_operand 2 "pc_or_label_ref" "")
  383.      (match_operand 3 "pc_or_label_ref" "")))]
  384.   ""
  385.   "bcnd%. %R3%D0,%1,%P2%P3"
  386.   [(set_attr "type" "branch")])
  387.  
  388. (define_insn ""
  389.   [(set (pc)
  390.     (if_then_else
  391.      (match_operator 0 "equality_op"
  392.              [(match_operand:SF 1 "register_operand" "r")
  393.               (const_int 0)])
  394.      (match_operand 2 "pc_or_label_ref" "")
  395.      (match_operand 3 "pc_or_label_ref" "")))]
  396.   ""
  397.   "bcnd%. %R3%D0,%1,%P2%P3"
  398.   [(set_attr "type" "branch")])
  399.  
  400. ;; Recognize bcnd instructions for double precision float values
  401. ;; Exclude relational operations as they must signal NaNs.
  402.  
  403. (define_insn ""
  404.   [(set (pc)
  405.     (if_then_else
  406.      (match_operator 0 "equality_op"
  407.              [(match_operand:DF 1 "register_operand" "r")
  408.               (const_int 0)])
  409.      (match_operand 2 "pc_or_label_ref" "")
  410.      (match_operand 3 "pc_or_label_ref" "")))]
  411.   ""
  412.   "*
  413. {
  414.   int label_num;
  415.  
  416.   if (GET_CODE (operands[0]) == NE)
  417.     {
  418.       rtx op2 = operands[2];
  419.       operands[2] = operands[3];
  420.       operands[3] = op2;
  421.     }
  422.   if (GET_CODE (operands[3]) == LABEL_REF)
  423.     return \"bcnd%. 0x5,%1,%3\;bcnd %#ne0,%d1,%3\";
  424.  
  425.   operands[3] = gen_label_rtx ();
  426.   label_num = XINT (operands[3], 3);
  427.   output_asm_insn (\"bcnd%. 0x5,%1,%3\;bcnd %#eq0,%d1,%2\", operands);
  428.   output_label (label_num);
  429.   return \"\";
  430. }"
  431.   [(set_attr "type" "branch")])
  432.  
  433. ;; Recognize bb0 and bb1 instructions.  These use two unusual template
  434. ;; patterns, %Lx and %Px.  %Lx outputs a 1 if operand `x' is a LABEL_REF
  435. ;; otherwise it outputs a 0.  It then may print ".n" if the delay slot
  436. ;; is used.  %Px does noting if `x' is PC and outputs the operand if `x'
  437. ;; is a LABEL_REF.
  438.  
  439. (define_insn ""
  440.   [(set (pc)
  441.     (if_then_else
  442.      (ne (sign_extract:SI (match_operand:SI 0 "register_operand" "r")
  443.                   (const_int 1)
  444.                   (match_operand:SI 1 "int5_operand" ""))
  445.          (const_int 0))
  446.      (match_operand 2 "pc_or_label_ref" "")
  447.      (match_operand 3 "pc_or_label_ref" "")))]
  448.   ""
  449.   "bb%L2 (31-%1),%0,%P2%P3"
  450.   [(set_attr "type" "branch")])
  451.  
  452. (define_insn ""
  453.   [(set (pc)
  454.     (if_then_else
  455.      (eq (sign_extract:SI (match_operand:SI 0 "register_operand" "r")
  456.                   (const_int 1)
  457.                   (match_operand:SI 1 "int5_operand" ""))
  458.          (const_int 0))
  459.      (match_operand 2 "pc_or_label_ref" "")
  460.      (match_operand 3 "pc_or_label_ref" "")))]
  461.   ""
  462.   "bb%L3 (31-%1),%0,%P2%P3"
  463.   [(set_attr "type" "branch")])
  464.  
  465. (define_insn ""
  466.   [(set (pc)
  467.     (if_then_else
  468.      (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
  469.                   (const_int 1)
  470.                   (match_operand:SI 1 "int5_operand" ""))
  471.          (const_int 0))
  472.      (match_operand 2 "pc_or_label_ref" "")
  473.      (match_operand 3 "pc_or_label_ref" "")))]
  474.   ""
  475.   "bb%L2 (31-%1),%0,%P2%P3"
  476.   [(set_attr "type" "branch")])
  477.  
  478. (define_insn ""
  479.   [(set (pc)
  480.     (if_then_else
  481.      (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
  482.                   (const_int 1)
  483.                   (match_operand:SI 1 "int5_operand" ""))
  484.          (const_int 0))
  485.      (match_operand 2 "pc_or_label_ref" "")
  486.      (match_operand 3 "pc_or_label_ref" "")))]
  487.   ""
  488.   "bb%L3 (31-%1),%0,%P2%P3"
  489.   [(set_attr "type" "branch")])
  490.  
  491. (define_insn ""
  492.   [(set (pc)
  493.     (if_then_else
  494.      (eq (and:SI (match_operand:SI 0 "reg_or_bbx_mask_operand" "%r")
  495.              (match_operand:SI 1 "reg_or_bbx_mask_operand" "n"))
  496.           (const_int 0))
  497.      (match_operand 2 "pc_or_label_ref" "")
  498.      (match_operand 3 "pc_or_label_ref" "")))]
  499.   "(GET_CODE (operands[0]) == CONST_INT)
  500.    != (GET_CODE (operands[1]) == CONST_INT)"
  501.   "bb%L3 %p1,%0,%P2%P3"
  502.   [(set_attr "type" "branch")])
  503.  
  504. (define_insn ""
  505.   [(set (pc)
  506.     (if_then_else
  507.      (ne (and:SI (match_operand:SI 0 "reg_or_bbx_mask_operand" "%r")
  508.              (match_operand:SI 1 "reg_or_bbx_mask_operand" "n"))
  509.          (const_int 0))
  510.      (match_operand 2 "pc_or_label_ref" "")
  511.      (match_operand 3 "pc_or_label_ref" "")))]
  512.   "(GET_CODE (operands[0]) == CONST_INT)
  513.    != (GET_CODE (operands[1]) == CONST_INT)"
  514.   "bb%L2 %p1,%0,%P2%P3"
  515.   [(set_attr "type" "branch")])
  516.  
  517. ;; The comparison operations store the comparison into a register and
  518. ;; record that register.  The following Bxx or Sxx insn uses that
  519. ;; register as an input.  To facilitate use of bcnd instead of cmp/bb1,
  520. ;; cmpsi records it's operands and produces no code when any operand
  521. ;; is constant.  In this case, the Bxx insns use gen_bcnd and the
  522. ;; Sxx insns use gen_test to ensure a cmp has been emitted.
  523. ;;
  524. ;; This could also be done for SFmode and DFmode having only beq and bne
  525. ;; use gen_bcnd.  The others must signal NaNs.  It seems though that zero
  526. ;; has already been copied into a register.
  527. ;;
  528. ;; cmpsi/beq and cmpsi/bne can always be done with bcnd if any operand
  529. ;; is a constant.  (This idea is due to Torbjorn Granlund.)  Others can
  530. ;; use bcnd only if an operand is zero.
  531. ;;
  532. ;; It is necessary to distinguish a register holding condition codes.
  533. ;; This is done by context.
  534.  
  535. (define_expand "test"
  536.   [(set (match_dup 2)
  537.     (compare:CC (match_operand 0 "" "")
  538.             (match_operand 1 "" "")))]
  539.   ""
  540.   "
  541. {
  542.   if (m88k_compare_reg)
  543.     abort ();
  544.  
  545.   if (GET_CODE (operands[0]) == CONST_INT
  546.       && ! SMALL_INT (operands[0]))
  547.     operands[0] = force_reg (SImode, operands[0]);
  548.  
  549.   if (GET_CODE (operands[1]) == CONST_INT
  550.       && ! SMALL_INT (operands[1]))
  551.     operands[1] = force_reg (SImode, operands[1]);
  552.  
  553.   operands[2] = m88k_compare_reg = gen_reg_rtx (CCmode);
  554. }")
  555.  
  556. ; @@ The docs say don't do this.  It's probably a nop since the insn looks
  557. ; identical to cmpsi against zero.  Is there an advantage to providing
  558. ; this, perhaps with a different form?
  559.  
  560. ;(define_expand "tstsi"
  561. ;  [(set (match_dup 1)
  562. ;    (compare:CC (match_operand:SI 0 "register_operand" "")
  563. ;            (const_int 0)))]
  564. ; ""
  565. ; "
  566. ;{
  567. ;  m88k_compare_reg = 0;
  568. ;  m88k_compare_op0 = operands[0];
  569. ;  m88k_compare_op1 = const0_rtx;
  570. ;  DONE;
  571. ;}")
  572.  
  573. ;; (NeXT) Changed arith32_operand to reg_or_0_operand to match
  574. ;; the actual compare insn.
  575.  
  576. (define_expand "cmpsi"
  577.   [(set (match_dup 2)
  578.     (compare:CC (match_operand:SI 0 "reg_or_0_operand" "")
  579.             (match_operand:SI 1 "arith32_operand" "")))]
  580.   ""
  581.   "
  582. {
  583.   if (GET_CODE (operands[0]) == CONST_INT
  584.       || GET_CODE (operands[1]) == CONST_INT)
  585.     {
  586.       m88k_compare_reg = 0;
  587.       m88k_compare_op0 = operands[0];
  588.       m88k_compare_op1 = operands[1];
  589.       DONE;
  590.     }
  591.   operands[2] = m88k_compare_reg = gen_reg_rtx (CCmode);
  592. }")
  593.  
  594. (define_expand "cmpsf"
  595.   [(set (match_dup 2)
  596.     (compare:CC (match_operand:SF 0 "register_operand" "")
  597.             (match_operand:SF 1 "register_operand" "")))]
  598.   ""
  599.   "operands[2] = m88k_compare_reg = gen_reg_rtx (CCmode);")
  600.  
  601. (define_expand "cmpdf"
  602.   [(set (match_dup 2)
  603.     (compare:CC (match_operand:DF 0 "register_operand" "")
  604.             (match_operand:DF 1 "register_operand" "")))]
  605.   ""
  606.   "operands[2] = m88k_compare_reg = gen_reg_rtx (CCmode);")
  607.  
  608. ; @@ Get back to this later on.
  609. ;
  610. ;(define_insn "cmpdi"
  611. ;  [(set (cc0)
  612. ;    (compare:CC (match_operand:DI 0 "register_operand" "r")
  613. ;            (match_operand:DI 1 "register_operand" "r")))]
  614. ;  ""
  615. ;  "*
  616. ;{
  617. ;  if ((cc_status.mdep & MDEP_LS_CHANGE) != 0)
  618. ;    abort ();    /* output_move_double MDEP_LS_CHANGE bits were set. */
  619. ;
  620. ;  cc_status.mdep &= ~ MDEP_LS_MASK;
  621. ;
  622. ;  operands[2] = gen_label_rtx ();
  623. ;  /* Remember, %! is the condition code register and %@ is the
  624. ;     literal synthesis register.  */
  625. ;
  626. ;  output_asm_insn (\"cmp %!,%0,%1\;bb0 %#eq,%!,%l2\;cmp %!,%d0,%d1\",
  627. ;           operands);
  628. ;
  629. ;  output_asm_insn (\"extu %@,%!,4<8>\;clr %!,%!,4<4>\", operands);
  630. ;  output_asm_insn (\"mak %@,%@,4<4>\;or %!,%!,%@\", operands);
  631. ;  output_label (XINT (operands[2], 3));
  632. ;  return \"\";
  633. ;}"
  634.  
  635. ;; The actual compare instructions.
  636.  
  637. ;; (NeXT) The second alternative is completely bugus!!!
  638. ;; It gets the wrong answer for tests of equality.
  639. ;; Besides, we shouldn't have to clutter up the md with this.
  640. ;; The compiler should be able to reverse the comparison.
  641. ;; 
  642. ;; (define_insn ""
  643. ;;   [(set (match_operand:CC 0 "register_operand" "=r,r")
  644. ;;     (compare:CC (match_operand:SI 1 "reg_or_0_operand" "rO,I")
  645. ;;             (match_operand:SI 2 "arith_operand" "rI,r")))]
  646. ;;   ""
  647. ;;   "@
  648. ;;    cmp %0,%r1,%2
  649. ;;    cmp %0,%2,%1\;xor.c %0,%#r0,%0"
  650. ;;   [(set_attr "type" "arith,marith")])
  651.  
  652. (define_insn ""
  653.   [(set (match_operand:CC 0 "register_operand" "=r")
  654.     (compare:CC (match_operand:SI 1 "reg_or_0_operand" "rO")
  655.             (match_operand:SI 2 "arith_operand" "rI")))]
  656.   ""
  657.   "cmp %0,%r1,%2"
  658.   [(set_attr "type" "arith")])
  659.  
  660. (define_insn ""
  661.   [(set (match_operand:CC 0 "register_operand" "=r,r")
  662.     (compare:CC (match_operand:SF 1 "register_operand" "r,r")
  663.             (match_operand:SF 2 "real_or_0_operand" "r,G")))]
  664.   ""
  665.   "@
  666.    fcmp.sss %0,%1,%2
  667.    fcmp.sss %0,%1,%#r0"
  668.   [(set_attr "type" "spadd")])
  669.  
  670. (define_insn ""
  671.   [(set (match_operand:CC 0 "register_operand" "=r")
  672.     (compare:CC (match_operand:DF 1 "register_operand" "r")
  673.             (float_extend:DF
  674.              (match_operand:SF 2 "register_operand" "r"))))]
  675.   ""
  676.   "fcmp.sds %0,%1,%2"
  677.   [(set_attr "type" "dpadd")])
  678.  
  679. (define_insn ""
  680.   [(set (match_operand:CC 0 "register_operand" "=r")
  681.     (compare:CC (float_extend:DF
  682.              (match_operand:SF 1 "register_operand" "r"))
  683.             (match_operand:DF 2 "register_operand" "r")))]
  684.   ""
  685.   "fcmp.ssd %0,%1,%2"
  686.   [(set_attr "type" "dpadd")])
  687.  
  688. (define_insn ""
  689.   [(set (match_operand:CC 0 "register_operand" "=r,r")
  690.     (compare:CC (match_operand:DF 1 "register_operand" "r,r")
  691.             (match_operand:DF 2 "real_or_0_operand" "r,G")))]
  692.   ""
  693.   "@
  694.    fcmp.sdd %0,%1,%2
  695.    fcmp.sds %0,%1,%#r0"
  696.   [(set_attr "type" "dpadd")])
  697.  
  698. ;; Store condition code insns.  The compare insns set a register
  699. ;; rather than cc0 and record that register for use here.  See above
  700. ;; for the special treatment of cmpsi with a constant operand.
  701.  
  702. (define_expand "seq"
  703.   [(set (match_operand:SI 0 "register_operand" "")
  704.     (match_dup 1))]
  705.   ""
  706.   "operands[1] = emit_test (EQ, SImode);")
  707.  
  708. (define_expand "sne"
  709.   [(set (match_operand:SI 0 "register_operand" "")
  710.     (match_dup 1))]
  711.   ""
  712.   "operands[1] = emit_test (NE, SImode);")
  713.  
  714. (define_expand "sgt"
  715.   [(set (match_operand:SI 0 "register_operand" "")
  716.     (match_dup 1))]
  717.   ""
  718.   "operands[1] = emit_test (GT, SImode);")
  719.  
  720. (define_expand "sgtu"
  721.   [(set (match_operand:SI 0 "register_operand" "")
  722.     (match_dup 1))]
  723.   ""
  724.   "operands[1] = emit_test (GTU, SImode);")
  725.  
  726. (define_expand "slt"
  727.   [(set (match_operand:SI 0 "register_operand" "")
  728.     (match_dup 1))]
  729.   ""
  730.   "operands[1] = emit_test (LT, SImode);")
  731.  
  732. (define_expand "sltu"
  733.   [(set (match_operand:SI 0 "register_operand" "")
  734.     (match_dup 1))]
  735.   ""
  736.   "operands[1] = emit_test (LTU, SImode);")
  737.  
  738. (define_expand "sge"
  739.   [(set (match_operand:SI 0 "register_operand" "")
  740.     (match_dup 1))]
  741.   ""
  742.   "operands[1] = emit_test (GE, SImode);")
  743.  
  744. (define_expand "sgeu"
  745.   [(set (match_operand:SI 0 "register_operand" "")
  746.     (match_dup 1))]
  747.   ""
  748.   "operands[1] = emit_test (GEU, SImode);")
  749.  
  750. (define_expand "sle"
  751.   [(set (match_operand:SI 0 "register_operand" "")
  752.     (match_dup 1))]
  753.   ""
  754.   "operands[1] = emit_test (LE, SImode);")
  755.  
  756. (define_expand "sleu"
  757.   [(set (match_operand:SI 0 "register_operand" "")
  758.     (match_dup 1))]
  759.   ""
  760.   "operands[1] = emit_test (LEU, SImode);")
  761.  
  762. ;; The actual set condition code instruction.
  763.  
  764. (define_insn ""
  765.   [(set (match_operand:SI 0 "register_operand" "=r")
  766.     (match_operator:SI 1 "relop"
  767.                [(match_operand:CC 2 "register_operand" "r")
  768.                 (const_int 0)]))]
  769.   ""
  770.   "extu %0,%2,1<%C1>")
  771.  
  772. ;; Special cases to support TARGET_HANDLE_LARGE_SHIFT.
  773.  
  774. (define_expand "extendsleu"
  775.   [(set (match_operand:SI 0 "register_operand" "")
  776.     (neg:SI (match_dup 1)))]
  777.   ""
  778.   "operands[1] = emit_test (LEU, SImode);")
  779.  
  780. (define_expand "extendsgtu"
  781.   [(set (match_operand:SI 0 "register_operand" "")
  782.     (neg:SI (match_dup 1)))]
  783.   ""
  784.   "operands[1] = emit_test (GTU, SImode);")
  785.  
  786. ;; The actual sign-extend set condition code instruction.
  787.  
  788. (define_insn ""
  789.   [(set (match_operand:SI 0 "register_operand" "=r")
  790.     (neg:SI
  791.      (match_operator:SI 1 "relop"
  792.                 [(match_operand:CC 2 "register_operand" "r")
  793.                  (const_int 0)])))]
  794.   ""
  795.   "ext %0,%2,1<%C1>")
  796.  
  797. ;; Conditional branch insns.  The compare insns set a register
  798. ;; rather than cc0 and record that register for use here.  See above
  799. ;; for the special case of cmpsi with a constant operand.
  800.  
  801. (define_expand "bcnd"
  802.   [(set (pc)
  803.     (if_then_else (match_operand 0 "" "")
  804.               (label_ref (match_operand 1 "" ""))
  805.               (pc)))]
  806.   ""
  807.   "if (m88k_compare_reg) abort ();")
  808.  
  809. (define_expand "bxx"
  810.   [(set (pc)
  811.     (if_then_else (match_operand 0 "" "")
  812.               (label_ref (match_operand 1 "" ""))
  813.               (pc)))]
  814.   ""
  815.   "if (m88k_compare_reg == 0) abort ();")
  816.  
  817. (define_expand "beq"
  818.   [(set (pc)
  819.     (if_then_else (eq (match_dup 1) (const_int 0))
  820.               (label_ref (match_operand 0 "" ""))
  821.               (pc)))]
  822.   ""
  823.   "if (m88k_compare_reg == 0)
  824.      {
  825.        emit_bcnd (EQ, operands[0]);
  826.        DONE;
  827.      }
  828.    operands[1] = m88k_compare_reg;")
  829.  
  830. (define_expand "bne"
  831.   [(set (pc)
  832.     (if_then_else (ne (match_dup 1) (const_int 0))
  833.               (label_ref (match_operand 0 "" ""))
  834.               (pc)))]
  835.   ""
  836.   "if (m88k_compare_reg == 0)
  837.      {
  838.        emit_bcnd (NE, operands[0]);
  839.        DONE;
  840.      }
  841.    operands[1] = m88k_compare_reg;")
  842.  
  843. (define_expand "bgt"
  844.   [(set (pc)
  845.     (if_then_else (gt (match_dup 1) (const_int 0))
  846.               (label_ref (match_operand 0 "" ""))
  847.               (pc)))]
  848.   ""
  849.   "if (m88k_compare_reg == 0)
  850.      {
  851.        emit_bcnd (GT, operands[0]);
  852.        DONE;
  853.      }
  854.    operands[1] = m88k_compare_reg;")
  855.  
  856. (define_expand "bgtu"
  857.   [(set (pc)
  858.     (if_then_else (gtu (match_dup 1) (const_int 0))
  859.               (label_ref (match_operand 0 "" ""))
  860.               (pc)))]
  861.   ""
  862.   "if (m88k_compare_reg == 0)
  863.      {
  864.        emit_jump_insn (gen_bxx (emit_test (GTU, VOIDmode), operands[0]));
  865.        DONE;
  866.      }
  867.    operands[1] = m88k_compare_reg;")
  868.  
  869. (define_expand "blt"
  870.   [(set (pc)
  871.     (if_then_else (lt (match_dup 1) (const_int 0))
  872.               (label_ref (match_operand 0 "" ""))
  873.               (pc)))]
  874.   ""
  875.   "if (m88k_compare_reg == 0)
  876.      {
  877.        emit_bcnd (LT, operands[0]);
  878.        DONE;
  879.      }
  880.    operands[1] = m88k_compare_reg;")
  881.  
  882. (define_expand "bltu"
  883.   [(set (pc)
  884.     (if_then_else (ltu (match_dup 1) (const_int 0))
  885.               (label_ref (match_operand 0 "" ""))
  886.               (pc)))]
  887.   ""
  888.   "if (m88k_compare_reg == 0)
  889.      {
  890.        emit_jump_insn (gen_bxx (emit_test (LTU, VOIDmode), operands[0]));
  891.        DONE;
  892.      }
  893.    operands[1] = m88k_compare_reg;")
  894.  
  895. (define_expand "bge"
  896.   [(set (pc)
  897.     (if_then_else (ge (match_dup 1) (const_int 0))
  898.               (label_ref (match_operand 0 "" ""))
  899.               (pc)))]
  900.   ""
  901.   "if (m88k_compare_reg == 0)
  902.      {
  903.        emit_bcnd (GE, operands[0]);
  904.        DONE;
  905.      }
  906.    operands[1] = m88k_compare_reg;")
  907.  
  908. (define_expand "bgeu"
  909.   [(set (pc)
  910.     (if_then_else (geu (match_dup 1) (const_int 0))
  911.               (label_ref (match_operand 0 "" ""))
  912.               (pc)))]
  913.   ""
  914.   "if (m88k_compare_reg == 0)
  915.      {
  916.        emit_jump_insn (gen_bxx (emit_test (GEU, VOIDmode), operands[0]));
  917.        DONE;
  918.      }
  919.    operands[1] = m88k_compare_reg;")
  920.  
  921. (define_expand "ble"
  922.   [(set (pc)
  923.     (if_then_else (le (match_dup 1) (const_int 0))
  924.               (label_ref (match_operand 0 "" ""))
  925.               (pc)))]
  926.   ""
  927.   "if (m88k_compare_reg == 0)
  928.      {
  929.        emit_bcnd (LE, operands[0]);
  930.        DONE;
  931.      }
  932.    operands[1] = m88k_compare_reg;")
  933.  
  934. (define_expand "bleu"
  935.   [(set (pc)
  936.     (if_then_else (leu (match_dup 1) (const_int 0))
  937.               (label_ref (match_operand 0 "" ""))
  938.               (pc)))]
  939.   ""
  940.   "if (m88k_compare_reg == 0)
  941.      {
  942.        emit_jump_insn (gen_bxx (emit_test (LEU, VOIDmode), operands[0]));
  943.        DONE;
  944.      }
  945.    operands[1] = m88k_compare_reg;")
  946.  
  947. ;; The actual conditional branch instruction (both directions).  This
  948. ;; uses two unusual template patterns, %Rx and %Px.  %Rx is a prefix code
  949. ;; for the immediately following condition and reverses the condition iff
  950. ;; operand `x' is a LABEL_REF.  %Px does nothing if `x' is PC and outputs
  951. ;; the operand if `x' is a LABEL_REF.
  952.  
  953. (define_insn ""
  954.   [(set (pc) (if_then_else
  955.           (match_operator 0 "relop"
  956.                   [(match_operand:CC 1 "register_operand" "r")
  957.                    (const_int 0)])
  958.           (match_operand 2 "pc_or_label_ref" "")
  959.           (match_operand 3 "pc_or_label_ref" "")))]
  960.   ""
  961.   "bb1%. %R3%C0,%1,%P2%P3"
  962.   [(set_attr "type" "branch")])
  963.  
  964. ;; SImode move instructions
  965.  
  966. (define_expand "movsi"
  967.   [(set (match_operand:SI 0 "general_operand" "")
  968.     (match_operand:SI 1 "general_operand" ""))]
  969.   ""
  970.   "
  971. {
  972.   rtx temp = emit_move_sequence (operands, SImode);
  973.   if (temp)
  974.     return temp;
  975. }")
  976.  
  977. (define_insn ""
  978.   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r")
  979.     (match_operand:SI 1 "move_operand" "rI,m,rO,J,M"))]
  980.   "(register_operand (operands[0], SImode)
  981.     || register_operand (operands[1], SImode)
  982.     || operands[1] == const0_rtx)"
  983.   "@
  984.    or %0,%#r0,%1
  985.    ld %0,%1
  986.    st %r1,%0
  987.    subu %0,%#r0,%n1
  988.    set %0,%#r0,%s1"
  989.   [(set_attr "type" "arith,load,store,arith,arith")])
  990.  
  991. (define_insn ""
  992.   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,r")
  993.     (match_operand:SI 1 "arith32_operand" "rI,J,L,M,n"))]
  994.   ""
  995.   "@
  996.    or %0,%#r0,%1
  997.    subu %0,%#r0,%n1
  998.    or.u %0,%#r0,%X1
  999.    set %0,%#r0,%s1
  1000.    or.u %0,%#r0,%X1\;or %0,%0,%x1"
  1001.   [(set_attr "type" "arith,arith,arith,arith,marith")])
  1002.  
  1003. ;; @@ Why the constraint "in"?  Doesn't `i' include `n'?
  1004. (define_insn ""
  1005.   [(set (match_operand:SI 0 "register_operand" "=r")
  1006.     (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1007.            (match_operand:SI 2 "immediate_operand" "in")))]
  1008.   ""
  1009.   "or %0,%1,%#lo16(%g2)")
  1010.  
  1011. (define_insn ""
  1012.   [(set (match_operand:SI 0 "register_operand" "=r")
  1013.     (high:SI (match_operand 1 "" "")))]
  1014.   ""
  1015.   "or.u %0,%#r0,%#hi16(%g1)")
  1016.  
  1017. ;; HImode move instructions
  1018.  
  1019. (define_expand "movhi"
  1020.   [(set (match_operand:HI 0 "general_operand" "")
  1021.     (match_operand:HI 1 "general_operand" ""))]
  1022.   ""
  1023.   "
  1024. {
  1025.   rtx temp = emit_move_sequence (operands, HImode);
  1026.   if (temp)
  1027.     return temp;
  1028. }")
  1029.  
  1030. (define_insn ""
  1031.   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r")
  1032.     (match_operand:HI 1 "move_operand" "rP,m,rO,N"))]
  1033.   "(register_operand (operands[0], HImode)
  1034.     || register_operand (operands[1], HImode)
  1035.     || operands[1] == const0_rtx)"
  1036.   "@
  1037.    or %0,%#r0,%h1
  1038.    ld.hu %0,%1
  1039.    st.h %r1,%0
  1040.    subu %0,%#r0,%H1"
  1041.   [(set_attr "type" "arith,load,store,arith")])
  1042.  
  1043. (define_insn ""
  1044.   [(set (match_operand:HI 0 "register_operand" "=r")
  1045.     (subreg:HI (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1046.                   (match_operand:SI 2 "immediate_operand" "in")) 0))]
  1047.   "!flag_pic"
  1048.   "or %0,%1,%#lo16(%2)")
  1049.  
  1050. ;; QImode move instructions
  1051.  
  1052. (define_expand "movqi"
  1053.   [(set (match_operand:QI 0 "general_operand" "")
  1054.     (match_operand:QI 1 "general_operand" ""))]
  1055.   ""
  1056.   "
  1057. {
  1058.   rtx temp = emit_move_sequence (operands, QImode);
  1059.   if (temp)
  1060.     return temp;
  1061. }")
  1062.  
  1063. (define_insn ""
  1064.   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r")
  1065.     (match_operand:QI 1 "move_operand" "rP,m,rO,N"))]
  1066.   "(register_operand (operands[0], QImode)
  1067.     || register_operand (operands[1], QImode)
  1068.     || operands[1] == const0_rtx)"
  1069.   "@
  1070.    or %0,%#r0,%q1
  1071.    ld.bu %0,%1
  1072.    st.b %r1,%0
  1073.    subu %r0,%#r0,%Q1"
  1074.   [(set_attr "type" "arith,load,store,arith")])
  1075.  
  1076. (define_insn ""
  1077.   [(set (match_operand:QI 0 "register_operand" "=r")
  1078.     (subreg:QI (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1079.                   (match_operand:SI 2 "immediate_operand" "in")) 0))]
  1080.   "!flag_pic"
  1081.   "or %0,%1,%#lo16(%2)")
  1082.  
  1083. ;; DImode move instructions
  1084.  
  1085. (define_expand "movdi"
  1086.   [(set (match_operand:DI 0 "general_operand" "")
  1087.     (match_operand:DI 1 "general_operand" ""))]
  1088.   ""
  1089.   "
  1090. {
  1091.   rtx temp = emit_move_sequence (operands, DImode);
  1092.   if (temp)
  1093.     return temp;
  1094. }")
  1095.  
  1096. (define_insn ""
  1097.   [(set (match_operand:DI 0 "register_operand" "=r")
  1098.     (const_int 0))]
  1099.   ""
  1100.   "or %0,%#r0,0\;or %d0,%#r0,0"
  1101.   [(set_attr "type" "marith")])
  1102.  
  1103. (define_insn ""
  1104.   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m")
  1105.     (match_operand:DI 1 "nonimmediate_operand" "r,m,r"))]
  1106.   ""
  1107.   "@
  1108.    or %0,%#r0,%1\;or %d0,%#r0,%d1
  1109.    ld.d %0,%1
  1110.    st.d %1,%0"
  1111.   [(set_attr "type" "marith,load,store")])
  1112.  
  1113. (define_insn ""
  1114.   [(set (match_operand:DI 0 "register_operand" "=r")
  1115.     (subreg:DI (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1116.                   (match_operand:SI 2 "immediate_operand" "in")) 0))]
  1117.   "!flag_pic"
  1118.   "or %0,%1,%#lo16(%2)")
  1119.  
  1120. (define_insn ""
  1121.   [(set (match_operand:DI 0 "register_operand" "=r")
  1122.     (match_operand:DI 1 "immediate_operand" "n"))]
  1123.    ""
  1124.    "* return output_load_const_dimode (operands);"
  1125.   [(set_attr "type" "marith")
  1126.    (set_attr "length" "4")]) ; length is 2, 3 or 4.
  1127.  
  1128. ;; DFmode move instructions
  1129.  
  1130. (define_expand "movdf"
  1131.   [(set (match_operand:DF 0 "general_operand" "")
  1132.     (match_operand:DF 1 "general_operand" ""))]
  1133.   ""
  1134.   "
  1135. {
  1136.   rtx temp = emit_move_sequence (operands, DFmode);
  1137.   if (temp)
  1138.     return temp;
  1139. }")
  1140.  
  1141. ;; @@ This pattern is incomplete and doesn't appear necessary.
  1142. ;;
  1143. ;; This pattern forces (set (reg:DF ...) (const_double ...))
  1144. ;; to be reloaded by putting the constant into memory.
  1145. ;; It must come before the more general movdf pattern.
  1146.  
  1147. ;(define_insn ""
  1148. ;  [(set (match_operand:DF 0 "general_operand" "=r,o")
  1149. ;    (match_operand:DF 1 "" "G,G"))]
  1150. ;  "GET_CODE (operands[1]) == CONST_DOUBLE"
  1151. ;  "*
  1152. ;{
  1153. ;  switch (which_alternative)
  1154. ;    {
  1155. ;    case 0:
  1156. ;      return \"or %0,%#r0,0\;or %d0,%#r0,0\";
  1157. ;    case 1:
  1158. ;      operands[1] = adj_offsettable_operand (operands[0], 4);
  1159. ;      return \"st %#r0,%0\;st %#r0,%1\";
  1160. ;    }
  1161. ;}")
  1162.  
  1163. (define_insn ""
  1164.   [(set (match_operand:DF 0 "register_operand" "=r")
  1165.     (const_int 0))]
  1166.   ""
  1167.   "or %0,%#r0,0\;or %d0,%#r0,0"
  1168.   [(set_attr "type" "marith")])
  1169.  
  1170. (define_insn ""
  1171.   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m")
  1172.     (match_operand:DF 1 "nonimmediate_operand" "r,m,r"))]
  1173.   ""
  1174.   "@
  1175.    or %0,%#r0,%1\;or %d0,%#r0,%d1
  1176.    ld.d %0,%1
  1177.    st.d %1,%0"
  1178.   [(set_attr "type" "marith,load,store")])
  1179.  
  1180. (define_insn ""
  1181.   [(set (match_operand:DF 0 "register_operand" "=r")
  1182.     (subreg:DF (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1183.                   (match_operand:SI 2 "immediate_operand" "in")) 0))]
  1184.   "!flag_pic"
  1185.   "or %0,%1,%#lo16(%2)")
  1186.  
  1187. (define_insn ""
  1188.   [(set (match_operand:DF 0 "register_operand" "=r")
  1189.     (match_operand:DF 1 "immediate_operand" "F"))]
  1190.    ""
  1191.    "* return output_load_const_double (operands);"
  1192.   [(set_attr "type" "marith")
  1193.    (set_attr "length" "4")]) ; length is 2, 3, or 4.
  1194.  
  1195. ;; SFmode move instructions
  1196.  
  1197. (define_expand "movsf"
  1198.   [(set (match_operand:SF 0 "general_operand" "")
  1199.     (match_operand:SF 1 "general_operand" ""))]
  1200.   ""
  1201.   "
  1202. {
  1203.   rtx temp = emit_move_sequence (operands, SFmode);
  1204.   if (temp)
  1205.     return temp;
  1206. }")
  1207.  
  1208. ;; @@ What happens to fconst0_rtx?
  1209. (define_insn ""
  1210.   [(set (match_operand:SF 0 "register_operand" "=r")
  1211.     (const_int 0))]
  1212.   ""
  1213.   "or %0,%#r0,0")
  1214.  
  1215. (define_insn ""
  1216.   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m")
  1217.     (match_operand:SF 1 "nonimmediate_operand" "r,m,r"))]
  1218.   ""
  1219.   "@
  1220.    or %0,%#r0,%1
  1221.    ld %0,%1
  1222.    st %r1,%0"
  1223.   [(set_attr "type" "arith,load,store")])
  1224.  
  1225. (define_insn ""
  1226.   [(set (match_operand:SF 0 "register_operand" "=r")
  1227.     (subreg:SF (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
  1228.                   (match_operand:SI 2 "immediate_operand" "in")) 0))]
  1229.   "!flag_pic"
  1230.   "or %0,%1,%#lo16(%2)")
  1231.  
  1232. (define_insn ""
  1233.   [(set (match_operand:SF 0 "register_operand" "=r")
  1234.     (match_operand:SF 1 "immediate_operand" "F"))]
  1235.   "operands[1] != const0_rtx"
  1236.   "* return output_load_const_float (operands);"
  1237.   [(set_attr "type" "marith")]) ; length is 1 or 2.
  1238.  
  1239. ;; String/block move insn.  See out-m88k.c for details.
  1240.  
  1241. (define_expand "movstrsi"
  1242.   [(parallel [(set (mem:BLK (match_operand:BLK 0 "general_operand" ""))
  1243.            (mem:BLK (match_operand:BLK 1 "general_operand" "")))
  1244.           (use (match_operand:SI 2 "arith32_operand" ""))
  1245.           (use (match_operand:SI 3 "immediate_operand" ""))])]
  1246.   ""
  1247.   "
  1248. {
  1249.   rtx dest_mem = operands[0];
  1250.   rtx src_mem = operands[1];
  1251.   operands[0] = copy_to_mode_reg (SImode, XEXP (operands[0], 0));
  1252.   operands[1] = copy_to_mode_reg (SImode, XEXP (operands[1], 0));
  1253.   expand_block_move (dest_mem, src_mem, operands);
  1254.   DONE;
  1255. }")
  1256.  
  1257. ;; Call a non-looping block move library function (e.g. __movstrSI96x64).
  1258. ;; operand 0 is the function name
  1259. ;; operand 1 is the destination pointer
  1260. ;; operand 2 is the source pointer
  1261. ;; operand 3 is the offset for the source and destination pointers
  1262. ;; operand 4 is the first value to be loaded
  1263. ;; operand 5 is the register to hold the value (r4 or r5)
  1264. ;; Upon completion, r2 and r3 are unchanged
  1265.  
  1266. (define_expand "call_block_move"
  1267.   [(set (reg:SI 3) (minus:SI (match_operand:SI 2 "register_operand" "r")
  1268.                  (match_operand:SI 3 "immediate_operand" "i")))
  1269.    (use (reg:SI 3))
  1270.    (set (match_operand 5 "register_operand" "r")
  1271.     (match_operand 4 "memory_operand" "m"))
  1272.    (use (reg:SI 4))
  1273.    (use (reg:SI 5))
  1274.    (set (reg:SI 2) (minus:SI (match_operand:SI 1 "register_operand" "r")
  1275.                  (match_dup 3)))
  1276.    (use (reg:SI 2))
  1277.    (parallel [(call (mem:SI (match_operand 0 "" ""))
  1278.             (const_int 0))
  1279.           (use (reg:SI 1))])
  1280.    (clobber (reg:SI 4))
  1281.    (clobber (reg:SI 5))]
  1282.   ""
  1283.   "")
  1284.  
  1285. ;; Call a looping block move library function (e.g. __movstrSI64n68).
  1286. ;; operands 0-5 as in the non-looping interface
  1287. ;; operand 6 is the loop count
  1288.  
  1289. (define_expand "call_block_move_loop"
  1290.   [(set (reg:SI 3) (minus:SI (match_operand:SI 2 "register_operand" "r")
  1291.                  (match_operand:SI 3 "immediate_operand" "i")))
  1292.    (use (reg:SI 3))
  1293.    (set (match_operand:SI 5 "register_operand" "r")
  1294.     (match_operand:SI 4 "memory_operand" "m"))
  1295.    (use (reg:SI 4))
  1296.    (use (reg:SI 5))
  1297.    (set (reg:SI 2) (minus:SI (match_operand:SI 1 "register_operand" "r")
  1298.                  (match_dup 3)))
  1299.    (use (reg:SI 2))
  1300.    (set (reg:SI 6) (match_operand:SI 6 "immediate_operand" "i"))
  1301.    (use (reg:SI 6))
  1302.    (parallel [(call (mem:SI (match_operand 0 "" ""))
  1303.             (const_int 0))
  1304.           (use (reg:SI 1))])
  1305.    (clobber (reg:SI 4))
  1306.    (clobber (reg:SI 5))
  1307.    (clobber (reg:SI 6))]
  1308.   ""
  1309.   "")
  1310.  
  1311. ;;- zero extension instructions
  1312.  
  1313. ;; Note that the one starting from HImode comes before those for QImode
  1314. ;; so that a constant operand will match HImode, not QImode.
  1315.  
  1316. (define_expand "zero_extendhisi2"
  1317.   [(set (match_operand:SI 0 "register_operand" "")
  1318.     (zero_extend:SI
  1319.      (match_operand:HI 1 "general_operand" "")))]
  1320.   ""
  1321.   "
  1322. {
  1323.   if (GET_CODE (operands[1]) == MEM
  1324.       && symbolic_address_p (XEXP (operands[1], 0)))
  1325.     operands[1]
  1326.       = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1327. }")
  1328.  
  1329. (define_insn ""
  1330.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  1331.     (zero_extend:SI
  1332.      (match_operand:HI 1 "move_operand" "!r,n,m")))]
  1333.   ""
  1334.   "@
  1335.    mask %0,%1,0xffff
  1336.    or %0,%#r0,%h1
  1337.    ld.hu %0,%1"
  1338.   [(set_attr "type" "arith,arith,load")])
  1339.  
  1340. (define_expand "zero_extendqihi2"
  1341.   [(set (match_operand:HI 0 "register_operand" "")
  1342.     (zero_extend:HI
  1343.      (match_operand:QI 1 "general_operand" "")))]
  1344.   ""
  1345.   "
  1346. {
  1347.   if (GET_CODE (operands[1]) == MEM
  1348.       && symbolic_address_p (XEXP (operands[1], 0)))
  1349.     operands[1]
  1350.       = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1351. }")
  1352.  
  1353. (define_insn ""
  1354.   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
  1355.     (zero_extend:HI
  1356.      (match_operand:QI 1 "move_operand" "r,n,m")))]
  1357.   ""
  1358.   "@
  1359.    mask %0,%1,0xff
  1360.    or %0,%#r0,%q1
  1361.    ld.bu %0,%1"
  1362.   [(set_attr "type" "arith,arith,load")])
  1363.  
  1364. (define_expand "zero_extendqisi2"
  1365.   [(set (match_operand:SI 0 "register_operand" "")
  1366.     (zero_extend:SI
  1367.      (match_operand:QI 1 "general_operand" "")))]
  1368.   ""
  1369.   "
  1370. {
  1371.   if (GET_CODE (operands[1]) == MEM
  1372.       && symbolic_address_p (XEXP (operands[1], 0)))
  1373.     {
  1374.       operands[1]
  1375.     = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1376.       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
  1377.               gen_rtx (ZERO_EXTEND, SImode, operands[1])));
  1378.       DONE;
  1379.     }
  1380. }")
  1381.  
  1382. (define_insn ""
  1383.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  1384.     (zero_extend:SI
  1385.      (match_operand:QI 1 "move_operand" "r,n,m")))]
  1386.   ""
  1387.   "@
  1388.    mask %0,%1,0xff
  1389.    or %0,%#r0,%q1
  1390.    ld.bu %0,%1"
  1391.   [(set_attr "type" "arith,arith,load")])
  1392.  
  1393. ;;- sign extension instructions
  1394. ;; Note that the one starting from HImode comes before those for QImode
  1395. ;; so that a constant operand will match HImode, not QImode.
  1396.  
  1397. (define_expand "extendsidi2"
  1398.   [(set (subreg:SI (match_operand:DI 0 "register_operand" "=r") 1)
  1399.         (match_operand:SI 1 "general_operand" "g"))
  1400.    (set (subreg:SI (match_dup 0) 0)
  1401.         (ashiftrt:SI (subreg:SI (match_dup 0) 1)
  1402.                      (const_int 31)))]
  1403.   ""
  1404.   "")
  1405.  
  1406. (define_expand "extendhisi2"
  1407.   [(set (match_operand:SI 0 "register_operand" "")
  1408.     (sign_extend:SI
  1409.      (match_operand:HI 1 "general_operand" "")))]
  1410.   ""
  1411.   "
  1412. {
  1413.   if (GET_CODE (operands[1]) == MEM
  1414.       && symbolic_address_p (XEXP (operands[1], 0)))
  1415.     operands[1]
  1416.       = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1417. }")
  1418.  
  1419. (define_insn ""
  1420.   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
  1421.     (sign_extend:SI
  1422.      (match_operand:HI 1 "move_operand" "!r,P,N,m")))]
  1423.   ""
  1424.   "@
  1425.    ext %0,%1,16<0>
  1426.    or %0,%#r0,%h1
  1427.    subu %0,%#r0,%H1
  1428.    ld.h %0,%1"
  1429.   [(set_attr "type" "arith,arith,arith,load")])
  1430.  
  1431. (define_expand "extendqihi2"
  1432.   [(set (match_operand:HI 0 "register_operand" "")
  1433.     (sign_extend:HI
  1434.      (match_operand:QI 1 "general_operand" "")))]
  1435.   ""
  1436.   "
  1437. {
  1438.   if (GET_CODE (operands[1]) == MEM
  1439.       && symbolic_address_p (XEXP (operands[1], 0)))
  1440.     operands[1]
  1441.       = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1442. }")
  1443.  
  1444. (define_insn ""
  1445.   [(set (match_operand:HI 0 "register_operand" "=r,r,r,r")
  1446.     (sign_extend:HI
  1447.      (match_operand:QI 1 "move_operand" "!r,P,N,m")))]
  1448.   ""
  1449.   "@
  1450.    ext %0,%1,8<0>
  1451.    or %0,%#r0,%q1
  1452.    subu %0,%#r0,%Q1
  1453.    ld.b %0,%1"
  1454.   [(set_attr "type" "arith,arith,arith,load")])
  1455.  
  1456. (define_expand "extendqisi2"
  1457.   [(set (match_operand:SI 0 "register_operand" "")
  1458.     (sign_extend:SI
  1459.      (match_operand:QI 1 "general_operand" "")))]
  1460.   ""
  1461.   "
  1462. {
  1463.   if (GET_CODE (operands[1]) == MEM
  1464.       && symbolic_address_p (XEXP (operands[1], 0)))
  1465.     operands[1]
  1466.       = legitimize_address (flag_pic, operands[1], gen_reg_rtx (Pmode));
  1467. }")
  1468.  
  1469. (define_insn ""
  1470.   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
  1471.     (sign_extend:SI
  1472.      (match_operand:QI 1 "move_operand" "!r,P,N,m")))]
  1473.   ""
  1474.   "@
  1475.    ext %0,%1,8<0>
  1476.    or %0,%#r0,%q1
  1477.    subu %0,%#r0,%Q1
  1478.    ld.b %0,%1"
  1479.   [(set_attr "type" "arith,arith,arith,load")])
  1480.  
  1481. ;; Conversions between float and double.
  1482.  
  1483. (define_insn "extendsfdf2"
  1484.   [(set (match_operand:DF 0 "register_operand" "=r")
  1485.     (float_extend:DF (match_operand:SF 1 "register_operand" "r")))]
  1486.   ""
  1487.   "fadd.dss %0,%#r0,%1"
  1488.   [(set_attr "type" "spadd")])
  1489.  
  1490. (define_insn "truncdfsf2"
  1491.   [(set (match_operand:SF 0 "register_operand" "=r")
  1492.     (float_truncate:SF (match_operand:DF 1 "register_operand" "r")))]
  1493.   ""
  1494.   "fadd.ssd %0,%#r0,%1"
  1495.   [(set_attr "type" "dpadd")])
  1496.  
  1497. ;; Conversions between floating point and integer
  1498.  
  1499. (define_insn "floatsidf2"
  1500.   [(set (match_operand:DF 0 "register_operand" "=r")
  1501.     (float:DF (match_operand:SI 1 "register_operand" "r")))]
  1502.   ""
  1503.   "flt.ds %0,%1"
  1504.   [(set_attr "type" "spadd")])
  1505.  
  1506. (define_insn "floatsisf2"
  1507.   [(set (match_operand:SF 0 "register_operand" "=r")
  1508.     (float:SF (match_operand:SI 1 "register_operand" "r")))]
  1509.   ""
  1510.   "flt.ss %0,%1"
  1511.   [(set_attr "type" "spadd")])
  1512.  
  1513. (define_insn "fix_truncdfsi2"
  1514.   [(set (match_operand:SI 0 "register_operand" "=r")
  1515.     (fix:SI (match_operand:DF 1 "register_operand" "r")))]
  1516.   ""
  1517.   "trnc.sd %0,%1"
  1518.   [(set_attr "type" "dpadd")])
  1519.  
  1520. (define_insn "fix_truncsfsi2"
  1521.   [(set (match_operand:SI 0 "register_operand" "=r")
  1522.     (fix:SI (match_operand:SF 1 "register_operand" "r")))]
  1523.   ""
  1524.   "trnc.ss %0,%1"
  1525.   [(set_attr "type" "spadd")])
  1526.  
  1527.  
  1528. ;;- arithmetic instructions
  1529. ;;- add instructions
  1530.  
  1531. (define_insn "addsi3"
  1532.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  1533.     (plus:SI (match_operand:SI 1 "add_operand" "%r,r")
  1534.          (match_operand:SI 2 "add_operand" "rI,J")))]
  1535.   ""
  1536.   "@
  1537.    addu %0,%1,%2
  1538.    subu %0,%1,%n2")
  1539.  
  1540. ;; In unusual contexts, an add of a large value is generated (case statements
  1541. ;; for example).  In these contexts, it is sufficient to accept only those
  1542. ;; cases where the two registers are different.
  1543.  
  1544. (define_insn ""
  1545.   [(set (match_operand:SI 0 "register_operand" "=r,&r")
  1546.     (plus:SI (match_operand:SI 1 "arith32_operand" "%r,r")
  1547.          (match_operand:SI 2 "arith32_operand" "r,!n")))]
  1548.   ""
  1549.   "*
  1550. {
  1551.   rtx xoperands[10];
  1552.  
  1553.   if (which_alternative == 0)
  1554.     return \"addu %0,%1,%2\";
  1555.  
  1556.   xoperands[0] = operands[0];
  1557.   xoperands[1] = operands[2];
  1558.   output_asm_insn (output_load_const_int (SImode, xoperands),
  1559.            xoperands);
  1560.  
  1561.   return \"addu %0,%1,%0\";
  1562. }"
  1563.   [(set_attr "type" "arith,marith")
  1564.    (set_attr "length" "1,3")]) ; may be 2 or 3.
  1565.  
  1566. ;; patterns for mixed mode floating point.
  1567. ;; Do not define patterns that utilize mixed mode arithmetic that result
  1568. ;; in narrowing the precision, because it loses accuracy, since the standard
  1569. ;; requires double rounding, whereas the 88000 instruction only rounds once.
  1570.  
  1571. (define_insn ""
  1572.   [(set (match_operand:DF 0 "register_operand" "=r")
  1573.     (plus:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1574.          (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1575.   ""
  1576.   "fadd.dss %0,%1,%2"
  1577.   [(set_attr "type" "spadd")])
  1578.  
  1579. (define_insn ""
  1580.   [(set (match_operand:DF 0 "register_operand" "=r")
  1581.     (plus:DF (match_operand:DF 1 "register_operand" "r")
  1582.          (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1583.   ""
  1584.   "fadd.dds %0,%1,%2"
  1585.   [(set_attr "type" "dpadd")])
  1586.  
  1587. (define_insn ""
  1588.   [(set (match_operand:DF 0 "register_operand" "=r")
  1589.     (plus:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1590.          (match_operand:DF 2 "register_operand" "r")))]
  1591.   ""
  1592.   "fadd.dsd %0,%1,%2"
  1593.   [(set_attr "type" "dpadd")])
  1594.  
  1595. (define_insn "adddf3"
  1596.   [(set (match_operand:DF 0 "register_operand" "=r")
  1597.     (plus:DF (match_operand:DF 1 "register_operand" "%r")
  1598.          (match_operand:DF 2 "register_operand" "r")))]
  1599.   ""
  1600.   "fadd.ddd %0,%1,%2"
  1601.   [(set_attr "type" "dpadd")])
  1602.  
  1603. (define_insn "addsf3"
  1604.   [(set (match_operand:SF 0 "register_operand" "=r")
  1605.     (plus:SF (match_operand:SF 1 "register_operand" "%r")
  1606.          (match_operand:SF 2 "register_operand" "r")))]
  1607.   ""
  1608.   "fadd.sss %0,%1,%2"
  1609.   [(set_attr "type" "spadd")])
  1610.  
  1611. (define_insn ""
  1612.   [(set (match_operand:DI 0 "register_operand" "=r")
  1613.     (plus:DI (match_operand:DI 1 "register_operand" "r")
  1614.          (zero_extend:DI
  1615.           (match_operand:SI 2 "register_operand" "r"))))]
  1616.   ""
  1617.   "addu.co %d0,%d1,%2\;addu.ci %0,%1,%#r0"
  1618.   [(set_attr "type" "marith")])
  1619.  
  1620. (define_insn ""
  1621.   [(set (match_operand:DI 0 "register_operand" "=r")
  1622.     (plus:DI (zero_extend:DI
  1623.           (match_operand:SI 1 "register_operand" "r"))
  1624.          (match_operand:DI 2 "register_operand" "r")))]
  1625.   ""
  1626.   "addu.co %d0,%1,%d2\;addu.ci %0,%#r0,%2"
  1627.   [(set_attr "type" "marith")])
  1628.  
  1629. (define_insn "adddi3"
  1630.   [(set (match_operand:DI 0 "register_operand" "=r")
  1631.     (plus:DI (match_operand:DI 1 "register_operand" "%r")
  1632.          (match_operand:DI 2 "register_operand" "r")))]
  1633.   ""
  1634.   "addu.co %d0,%d1,%d2\;addu.ci %0,%1,%2"
  1635.   [(set_attr "type" "marith")])
  1636.  
  1637. ;;- subtract instructions
  1638.  
  1639. (define_insn "subsi3"
  1640.   [(set (match_operand:SI 0 "register_operand" "=r")
  1641.     (minus:SI (match_operand:SI 1 "register_operand" "r")
  1642.           (match_operand:SI 2 "arith32_operand" "rI")))]
  1643.   ""
  1644.   "subu %0,%1,%2")
  1645.  
  1646. ;; patterns for mixed mode floating point
  1647. ;; Do not define patterns that utilize mixed mode arithmetic that result
  1648. ;; in narrowing the precision, because it loses accuracy, since the standard
  1649. ;; requires double rounding, whereas the 88000 instruction only rounds once.
  1650.  
  1651. (define_insn ""
  1652.   [(set (match_operand:DF 0 "register_operand" "=r")
  1653.     (minus:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1654.           (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1655.   ""
  1656.   "fsub.dss %0,%1,%2"
  1657.   [(set_attr "type" "spadd")])
  1658.  
  1659. (define_insn ""
  1660.   [(set (match_operand:DF 0 "register_operand" "=r")
  1661.     (minus:DF (match_operand:DF 1 "register_operand" "r")
  1662.           (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1663.   ""
  1664.   "fsub.dds %0,%1,%2"
  1665.   [(set_attr "type" "dpadd")])
  1666.  
  1667. (define_insn ""
  1668.   [(set (match_operand:DF 0 "register_operand" "=r")
  1669.     (minus:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1670.           (match_operand:DF 2 "register_operand" "r")))]
  1671.   ""
  1672.   "fsub.dsd %0,%1,%2"
  1673.   [(set_attr "type" "dpadd")])
  1674.  
  1675. (define_insn "subdf3"
  1676.   [(set (match_operand:DF 0 "register_operand" "=r")
  1677.     (minus:DF (match_operand:DF 1 "register_operand" "r")
  1678.           (match_operand:DF 2 "register_operand" "r")))]
  1679.   ""
  1680.   "fsub.ddd %0,%1,%2"
  1681.   [(set_attr "type" "dpadd")])
  1682.  
  1683. (define_insn "subsf3"
  1684.   [(set (match_operand:SF 0 "register_operand" "=r")
  1685.     (minus:SF (match_operand:SF 1 "register_operand" "r")
  1686.           (match_operand:SF 2 "register_operand" "r")))]
  1687.   ""
  1688.   "fsub.sss %0,%1,%2"
  1689.   [(set_attr "type" "spadd")])
  1690.  
  1691. (define_insn ""
  1692.   [(set (match_operand:DI 0 "register_operand" "=r")
  1693.     (minus:DI (match_operand:DI 1 "register_operand" "r")
  1694.           (zero_extend:DI
  1695.            (match_operand:SI 2 "register_operand" "r"))))]
  1696.   ""
  1697.   "subu.co %d0,%d1,%2\;subu.ci %0,%1,%#r0"
  1698.   [(set_attr "type" "marith")])
  1699.  
  1700. (define_insn ""
  1701.   [(set (match_operand:DI 0 "register_operand" "=r")
  1702.     (minus:DI (zero_extend:DI
  1703.            (match_operand:SI 1 "register_operand" "r"))
  1704.           (match_operand:DI 2 "register_operand" "r")))]
  1705.   ""
  1706.   "subu.co %d0,%1,%d2\;subu.ci %0,%#r0,%2"
  1707.   [(set_attr "type" "marith")])
  1708.  
  1709. (define_insn "subdi3"
  1710.   [(set (match_operand:DI 0 "register_operand" "=r")
  1711.     (minus:DI (match_operand:DI 1 "register_operand" "r")
  1712.           (match_operand:DI 2 "register_operand" "r")))]
  1713.   ""
  1714.   "subu.co %d0,%d1,%d2\;subu.ci %0,%1,%2"
  1715.   [(set_attr "type" "marith")])
  1716.  
  1717. ;;- multiply instructions
  1718. ;;
  1719. ;; There is an unfounded silicon eratta for E.1 requiring that an
  1720. ;; immediate constant value in div/divu/mul instructions be less than
  1721. ;; 0x800.  This is no longer provided for.
  1722.  
  1723. (define_insn "mulsi3"
  1724.   [(set (match_operand:SI 0 "register_operand" "=r")
  1725.     (mult:SI (match_operand:SI 1 "arith32_operand" "%r")
  1726.          (match_operand:SI 2 "arith32_operand" "rI")))]
  1727.   ""
  1728.   "mul %0,%1,%2"
  1729.   [(set_attr "type" "imul")])
  1730.  
  1731. ;; patterns for mixed mode floating point
  1732. ;; Do not define patterns that utilize mixed mode arithmetic that result
  1733. ;; in narrowing the precision, because it loses accuracy, since the standard
  1734. ;; requires double rounding, whereas the 88000 instruction only rounds once.
  1735.  
  1736. (define_expand "muldf3"
  1737.   [(set (match_operand:DF 0 "register_operand" "=r")
  1738.     (mult:DF (match_operand:DF 1 "register_operand" "%r")
  1739.          (match_operand:DF 2 "general_operand" "r")))]
  1740.   ""
  1741.   "
  1742. {
  1743.   rtx temp;
  1744.  
  1745.   /* If constant can be represented in SFmode without loss of accuracy
  1746.      (for now we just do this for powers of two), use fmul.dsd.  */
  1747.   if (real_power_of_2_operand (operands[2])
  1748.       && (temp = simplify_unary_operation (FLOAT_TRUNCATE, SFmode,
  1749.                        operands[2], DFmode)) != 0)
  1750.     {
  1751.       operands[2] = operands[1];
  1752.       operands[1] = gen_rtx (FLOAT_EXTEND, DFmode, force_reg (SFmode, temp));
  1753.     }
  1754.   else if (! register_operand (operands[2], DFmode))
  1755.     operands[2] = force_reg (DFmode, operands[2]);
  1756. }")
  1757.  
  1758. (define_insn ""
  1759.   [(set (match_operand:DF 0 "register_operand" "=r")
  1760.     (mult:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1761.          (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1762.   ""
  1763.   "fmul.dss %0,%1,%2"
  1764.   [(set_attr "type" "spmul")])
  1765.  
  1766. (define_insn ""
  1767.   [(set (match_operand:DF 0 "register_operand" "=r")
  1768.     (mult:DF (match_operand:DF 1 "register_operand" "r")
  1769.          (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  1770.   ""
  1771.   "fmul.dds %0,%1,%2"
  1772.   [(set_attr "type" "spmul")])
  1773.  
  1774. (define_insn ""
  1775.   [(set (match_operand:DF 0 "register_operand" "=r")
  1776.     (mult:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  1777.          (match_operand:DF 2 "register_operand" "r")))]
  1778.   ""
  1779.   "fmul.dsd %0,%1,%2"
  1780.   [(set_attr "type" "spmul")])
  1781.  
  1782. (define_insn ""
  1783.   [(set (match_operand:DF 0 "register_operand" "=r")
  1784.     (mult:DF (match_operand:DF 1 "register_operand" "%r")
  1785.          (match_operand:DF 2 "register_operand" "r")))]
  1786.   ""
  1787.   "fmul.ddd %0,%1,%2"
  1788.   [(set_attr "type" "dpmul")])
  1789.  
  1790. (define_insn "mulsf3"
  1791.   [(set (match_operand:SF 0 "register_operand" "=r")
  1792.     (mult:SF (match_operand:SF 1 "register_operand" "%r")
  1793.          (match_operand:SF 2 "register_operand" "r")))]
  1794.   ""
  1795.   "fmul.sss %0,%1,%2"
  1796.   [(set_attr "type" "spmul")])
  1797.  
  1798. ;;- divide instructions
  1799. ;;
  1800. ;; The 88k div and divu instructions don't reliably trap on
  1801. ;; divide-by-zero.  A trap to vector 503 asserts divide-by-zero.  The
  1802. ;; general scheme for doing divide is to do a 4-way split based on the
  1803. ;; sign of the two operand and do the appropriate negates.
  1804. ;;
  1805. ;; The conditional trap instruction is not used as this serializes the
  1806. ;; processor.  Instead a conditional branch and an unconditional trap
  1807. ;; are used, but after the divu.  Since the divu takes up to 38 cycles,
  1808. ;; the conditional branch is essentially free.
  1809. ;;
  1810. ;; Two target options control how divide is done.  One options selects
  1811. ;; whether to do the branch and negate scheme instead of using the div
  1812. ;; instruction; the other option selects whether to explicitly check
  1813. ;; for divide-by-zero or take your chances.  If the div instruction is
  1814. ;; used, the O/S must complete the operation if the operands are
  1815. ;; negative.  The O/S will signal an overflow condition if the most
  1816. ;; negative number (-214783648) is divided by negative 1.
  1817. ;;
  1818. ;; There is an unfounded silicon eratta for E.1 requiring that an
  1819. ;; immediate constant value in div/divu/mul instructions be less than
  1820. ;; 0x800.  This is no longer provided for.
  1821.  
  1822. ;; Division by 0 trap
  1823. (define_insn "trap_divide_by_zero"
  1824.   [(set (pc) (const_int 503))]
  1825.   ""
  1826.   "tb0 0,%#r0,503"
  1827.   [(set_attr "type" "wierd")])
  1828.  
  1829. ;; Conditional division by 0 trap.
  1830. (define_expand "tcnd_divide_by_zero"
  1831.   [(set (pc)
  1832.     (if_then_else (eq (match_operand:SI 0 "register_operand" "")
  1833.               (const_int 0))
  1834.               (const_int 503)
  1835.               (match_operand 1 "" "")))]
  1836.   ""
  1837.   "
  1838. {
  1839.   emit_insn (gen_cmpsi (operands[0], const0_rtx));
  1840.   emit_jump_insn (gen_bne (operands[1]));
  1841.   emit_insn (gen_trap_divide_by_zero ());
  1842.   emit_barrier ();
  1843.   DONE;
  1844. }")
  1845.  
  1846. (define_expand "divsi3"
  1847.   [(set (match_operand:SI 0 "register_operand" "")
  1848.     (div:SI (match_operand:SI 1 "arith32_operand" "")
  1849.         (match_operand:SI 2 "arith32_operand" "")))]
  1850.   ""
  1851.   "
  1852. {
  1853.   rtx op1 = operands[1];
  1854.   rtx op2 = operands[2];
  1855.   rtx join_label;
  1856.  
  1857.   /* @@ This needs to be reworked.  Torbjorn Granlund has suggested making
  1858.      it a runtime (perhaps quite special).  */
  1859.  
  1860.   if (GET_CODE (op1) == CONST_INT)
  1861.     op1 = force_reg (SImode, op1);
  1862.  
  1863.   else if (GET_CODE (op2) == CONST_INT
  1864.        && ! SMALL_INT (operands[2]))
  1865.     op2 = force_reg (SImode, op2);
  1866.  
  1867.   if (op2 == const0_rtx)
  1868.     {
  1869.       emit_insn (gen_trap_divide_by_zero ());
  1870.       emit_barrier ();
  1871.       emit_insn (gen_dummy (operands[0]));
  1872.       DONE;
  1873.     }
  1874.  
  1875.   if (TARGET_USE_DIV)
  1876.     {
  1877.       emit_move_insn (operands[0], gen_rtx (DIV, SImode, op1, op2));
  1878.       if (TARGET_CHECK_ZERO_DIV && GET_CODE (op2) != CONST_INT)
  1879.     {
  1880.       rtx label = gen_label_rtx ();
  1881.       emit_insn (gen_tcnd_divide_by_zero (op2, label));
  1882.       emit_label (label);
  1883.       emit_insn (gen_dummy (op2));
  1884.     }
  1885.       DONE;
  1886.     }
  1887.  
  1888.   join_label = gen_label_rtx ();
  1889.   if (GET_CODE (op1) == CONST_INT)
  1890.     {
  1891.       int neg = FALSE;
  1892.       rtx neg_op2 = gen_reg_rtx (SImode);
  1893.       rtx label1 = gen_label_rtx ();
  1894.  
  1895.       if (INTVAL (op1) < 0)
  1896.     {
  1897.       neg = TRUE;
  1898.       op1 = gen_rtx (CONST_INT, VOIDmode, -INTVAL (op1));
  1899.     }
  1900.       op1 = force_reg (SImode, op1);
  1901.  
  1902.       emit_insn (gen_negsi2 (neg_op2, op2));
  1903.       emit_insn (gen_cmpsi (op2, const0_rtx));
  1904.       emit_jump_insn (gen_bgt (label1));
  1905.                         /* constant / 0-or-negative */
  1906.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, op1, neg_op2));
  1907.       if (!neg)
  1908.     emit_insn (gen_negsi2 (operands[0], operands[0]));
  1909.  
  1910.       if (TARGET_CHECK_ZERO_DIV)
  1911.     emit_insn (gen_tcnd_divide_by_zero (op2, join_label));
  1912.       else
  1913.     {
  1914.       emit_jump_insn (gen_jump (join_label));
  1915.       emit_barrier ();
  1916.     }
  1917.  
  1918.       emit_label (label1);            /* constant / positive */
  1919.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, op1, op2));
  1920.       if (neg)
  1921.     emit_insn (gen_negsi2 (operands[0], operands[0]));
  1922.     }
  1923.  
  1924.   else if (GET_CODE (op2) == CONST_INT)
  1925.     {
  1926.       int neg = FALSE;
  1927.       rtx neg_op1 = gen_reg_rtx (SImode);
  1928.       rtx label1 = gen_label_rtx ();
  1929.  
  1930.       if (INTVAL (op2) < 0)
  1931.     {
  1932.       neg = TRUE;
  1933.       op2 = gen_rtx (CONST_INT, VOIDmode, -INTVAL (op2));
  1934.     }
  1935.       else if (! SMALL_INT (operands[2]))
  1936.     op2 = force_reg (SImode, op2);
  1937.  
  1938.       emit_insn (gen_negsi2 (neg_op1, op1));
  1939.       emit_insn (gen_cmpsi (op1, const0_rtx));
  1940.       emit_jump_insn (gen_bge (label1));
  1941.                         /* 0-or-negative / constant */
  1942.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, neg_op1, op2));
  1943.       if (!neg)
  1944.     emit_insn (gen_negsi2 (operands[0], operands[0]));
  1945.  
  1946.       emit_jump_insn (gen_jump (join_label));
  1947.       emit_barrier ();
  1948.  
  1949.       emit_label (label1);            /* positive / constant */
  1950.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, op1, op2));
  1951.       if (neg)
  1952.     emit_insn (gen_negsi2 (operands[0], operands[0]));
  1953.     }
  1954.  
  1955.   else
  1956.     {
  1957.       rtx neg_op1 = gen_reg_rtx (SImode);
  1958.       rtx neg_op2 = gen_reg_rtx (SImode);
  1959.       rtx label1 = gen_label_rtx ();
  1960.       rtx label2 = gen_label_rtx ();
  1961.       rtx label3 = gen_label_rtx ();
  1962.       rtx label4;
  1963.  
  1964.       emit_insn (gen_negsi2 (neg_op2, op2));
  1965.       emit_insn (gen_cmpsi (op2, const0_rtx));
  1966.       emit_jump_insn (gen_bgt (label1));
  1967.  
  1968.       emit_insn (gen_negsi2 (neg_op1, op1));
  1969.       emit_insn (gen_cmpsi (op1, const0_rtx));
  1970.       emit_jump_insn (gen_bge (label2));
  1971.                         /* negative / negative-or-0 */
  1972.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, neg_op1, neg_op2));
  1973.  
  1974.       if (TARGET_CHECK_ZERO_DIV)
  1975.     {
  1976.       label4 = gen_label_rtx ();
  1977.       emit_insn (gen_cmpsi (op2, const0_rtx));
  1978.       emit_jump_insn (gen_bne (join_label));
  1979.       emit_label (label4);
  1980.       emit_insn (gen_trap_divide_by_zero ());
  1981.       emit_barrier ();
  1982.     }
  1983.       else
  1984.     {
  1985.       emit_jump_insn (gen_jump (join_label));
  1986.       emit_barrier ();
  1987.     }
  1988.  
  1989.       emit_label (label2);            /* pos.-or-0 / neg.-or-0 */
  1990.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, op1, neg_op2));
  1991.  
  1992.       if (TARGET_CHECK_ZERO_DIV)
  1993.     {
  1994.       emit_insn (gen_cmpsi (op2, const0_rtx));
  1995.       emit_jump_insn (gen_beq (label4));
  1996.     }
  1997.  
  1998.       emit_insn (gen_negsi2 (operands[0], operands[0]));
  1999.       emit_jump_insn (gen_jump (join_label));
  2000.       emit_barrier ();
  2001.  
  2002.       emit_label (label1);
  2003.       emit_insn (gen_negsi2 (neg_op1, op1));
  2004.       emit_insn (gen_cmpsi (op1, const0_rtx));
  2005.       emit_jump_insn (gen_bge (label3));
  2006.                         /* negative / positive */
  2007.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, neg_op1, op2));
  2008.       emit_insn (gen_negsi2 (operands[0], operands[0]));
  2009.       emit_jump_insn (gen_jump (join_label));
  2010.       emit_barrier ();
  2011.  
  2012.       emit_label (label3);            /* positive-or-0 / positive */
  2013.       emit_move_insn (operands[0], gen_rtx (UDIV, SImode, op1, op2));
  2014.     }
  2015.  
  2016.   emit_label (join_label);
  2017.  
  2018.   emit_insn (gen_dummy (operands[0]));
  2019.   DONE;
  2020. }")
  2021.  
  2022. (define_insn ""
  2023.   [(set (match_operand:SI 0 "register_operand" "=r")
  2024.     (div:SI (match_operand:SI 1 "register_operand" "r")
  2025.         (match_operand:SI 2 "arith_operand" "rI")))]
  2026.   ""
  2027.   "div %0,%1,%2"
  2028.   [(set_attr "type" "idiv")])
  2029.  
  2030. (define_expand "udivsi3"
  2031.   [(set (match_operand:SI 0 "register_operand" "")
  2032.     (udiv:SI (match_operand:SI 1 "register_operand" "")
  2033.          (match_operand:SI 2 "arith32_operand" "")))]
  2034.   ""
  2035.   "
  2036. {
  2037.   rtx op2 = operands[2];
  2038.  
  2039.   if (op2 == const0_rtx)
  2040.     {
  2041.       emit_insn (gen_trap_divide_by_zero ());
  2042.       emit_barrier ();
  2043.       emit_insn (gen_dummy (operands[0]));
  2044.       DONE;
  2045.     }
  2046.   else if (GET_CODE (op2) != CONST_INT && TARGET_CHECK_ZERO_DIV)
  2047.     {
  2048.       rtx label = gen_label_rtx ();
  2049.       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
  2050.               gen_rtx (UDIV, SImode, operands[1], op2)));
  2051.       emit_insn (gen_tcnd_divide_by_zero (op2, label));
  2052.       emit_label (label);
  2053.       emit_insn (gen_dummy (operands[0]));
  2054.       DONE;
  2055.     }
  2056. }")
  2057.  
  2058. (define_insn ""
  2059.  [(set (match_operand:SI 0 "register_operand" "=r")
  2060.        (udiv:SI (match_operand:SI 1 "register_operand" "r")
  2061.         (match_operand:SI 2 "arith32_operand" "rI")))]
  2062.   "operands[2] != const0_rtx"
  2063.   "divu %0,%1,%2"
  2064.   [(set_attr "type" "idiv")])
  2065.  
  2066. (define_insn ""
  2067.  [(set (match_operand:SI 0 "register_operand" "=r")
  2068.        (udiv:SI (match_operand:SI 1 "register_operand" "r")
  2069.         (const_int 0)))]
  2070.   ""
  2071.   "tb0 0,%#r0,503"
  2072.   [(set_attr "type" "wierd")])
  2073.  
  2074. ;; patterns for mixed mode floating point.
  2075. ;; Do not define patterns that utilize mixed mode arithmetic that result
  2076. ;; in narrowing the precision, because it loses accuracy, since the standard
  2077. ;; requires double rounding, whereas the 88000 instruction only rounds once.
  2078.  
  2079. (define_expand "divdf3"
  2080.   [(set (match_operand:DF 0 "register_operand" "=r")
  2081.     (div:DF (match_operand:DF 1 "register_operand" "r")
  2082.         (match_operand:DF 2 "general_operand" "r")))]
  2083.   ""
  2084.   "
  2085. {
  2086.   if (real_power_of_2_operand (operands[2]))
  2087.     {
  2088.       union real_extract u;
  2089.       bcopy (&CONST_DOUBLE_LOW (operands[2]), &u, sizeof u);
  2090.       emit_insn (gen_muldf3 (operands[0], operands[1],
  2091.                  CONST_DOUBLE_FROM_REAL_VALUE (1.0/u.d, DFmode)));
  2092.       DONE;
  2093.     }
  2094.   else if (! register_operand (operands[2], DFmode))
  2095.     operands[2] = force_reg (DFmode, operands[2]);
  2096. }")
  2097.  
  2098. (define_insn ""
  2099.   [(set (match_operand:DF 0 "register_operand" "=r")
  2100.     (div:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  2101.         (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  2102.   ""
  2103.   "fdiv.dss %0,%1,%2"
  2104.   [(set_attr "type" "dpdiv")])
  2105.  
  2106. (define_insn ""
  2107.   [(set (match_operand:DF 0 "register_operand" "=r")
  2108.     (div:DF (match_operand:DF 1 "register_operand" "r")
  2109.         (float_extend:DF (match_operand:SF 2 "register_operand" "r"))))]
  2110.   ""
  2111.   "fdiv.dds %0,%1,%2"
  2112.   [(set_attr "type" "dpdiv")])
  2113.  
  2114. (define_insn ""
  2115.   [(set (match_operand:DF 0 "register_operand" "=r")
  2116.     (div:DF (float_extend:DF (match_operand:SF 1 "register_operand" "r"))
  2117.         (match_operand:DF 2 "register_operand" "r")))]
  2118.   ""
  2119.   "fdiv.dsd %0,%1,%2"
  2120.   [(set_attr "type" "dpdiv")])
  2121.  
  2122. (define_insn "divsf3"
  2123.   [(set (match_operand:SF 0 "register_operand" "=r")
  2124.     (div:SF (match_operand:SF 1 "register_operand" "r")
  2125.         (match_operand:SF 2 "register_operand" "r")))]
  2126.   ""
  2127.   "fdiv.sss %0,%1,%2"
  2128.   [(set_attr "type" "spdiv")])
  2129.  
  2130. (define_insn ""
  2131.   [(set (match_operand:DF 0 "register_operand" "=r")
  2132.     (div:DF (match_operand:DF 1 "register_operand" "r")
  2133.         (match_operand:DF 2 "register_operand" "r")))]
  2134.   ""
  2135.   "fdiv.ddd %0,%1,%2"
  2136.   [(set_attr "type" "dpdiv")])
  2137.  
  2138. ;; - remainder instructions, don't define, since the hardware doesn't have any
  2139. ;; direct support, and GNU can synthesis them out of div/mul just fine.
  2140.  
  2141. ;;- load effective address, must come after add, so that we favor using
  2142. ;;  addu reg,reg,reg  instead of:  lda reg,reg,reg (addu doesn't require
  2143. ;;  the data unit), and also future 88k chips might not support unscaled
  2144. ;;  lda instructions.
  2145.  
  2146. (define_insn ""
  2147.   [(set (match_operand:SI 0 "register_operand" "=r")
  2148.     (match_operand:HI 1 "address_operand" "p"))]
  2149.   ""
  2150.   "lda.h %0,%a1"
  2151.   [(set_attr "type" "loada")])
  2152.  
  2153. (define_insn ""
  2154.   [(set (match_operand:SI 0 "register_operand" "=r")
  2155.     (match_operand:SI 1 "address_operand" "p"))]
  2156.   ""
  2157.   "lda %0,%a1"
  2158.   [(set_attr "type" "loada")])
  2159.  
  2160. (define_insn ""
  2161.   [(set (match_operand:SI 0 "register_operand" "=r")
  2162.     (match_operand:DI 1 "address_operand" "p"))]
  2163.   ""
  2164.   "lda.d %0,%a1"
  2165.   [(set_attr "type" "loada")])
  2166.  
  2167. (define_insn ""
  2168.   [(set (match_operand:SI 0 "register_operand" "=r")
  2169.     (match_operand:SF 1 "address_operand" "p"))]
  2170.   ""
  2171.   "lda %0,%a1"
  2172.   [(set_attr "type" "loada")])
  2173.  
  2174. (define_insn ""
  2175.   [(set (match_operand:SI 0 "register_operand" "=r")
  2176.     (match_operand:DF 1 "address_operand" "p"))]
  2177.   ""
  2178.   "lda.d %0,%a1"
  2179.   [(set_attr "type" "loada")])
  2180.  
  2181. ;;- and instructions (with complement also)
  2182. (define_insn ""
  2183.   [(set (match_operand:SI 0 "register_operand" "=r")
  2184.     (and:SI (not:SI (match_operand:SI 1 "register_operand" "r"))
  2185.         (match_operand:SI 2 "register_operand" "r")))]
  2186.   ""
  2187.   "and.c %0,%2,%1")
  2188.  
  2189. ;; If the operation is being performed on a 32-bit constant such that
  2190. ;; it cannot be done in one insn, do it in two.  We may lose a bit on
  2191. ;; CSE in pathological cases, but it seems better doing it this way.
  2192.  
  2193. (define_expand "andsi3"
  2194.   [(set (match_operand:SI 0 "register_operand" "")
  2195.     (and:SI (match_operand:SI 1 "arith32_operand" "")
  2196.         (match_operand:SI 2 "arith32_operand" "")))]
  2197.   ""
  2198.   "
  2199. {
  2200.   if (GET_CODE (operands[2]) == CONST_INT)
  2201.     {
  2202.       int value = INTVAL (operands[2]);
  2203.  
  2204.       if (! (SMALL_INTVAL (value)
  2205.          || (value & 0xffff0000) == 0xffff0000
  2206.          || (value & 0xffff) == 0xffff
  2207.          || (value & 0xffff) == 0
  2208.          || integer_ok_for_set (~value)))
  2209.     {
  2210.       emit_insn (gen_andsi3 (operands[0], operands[1],
  2211.                  gen_rtx (CONST_INT, VOIDmode,
  2212.                       value | 0xffff)));
  2213.       operands[1] = operands[0];
  2214.       operands[2] = gen_rtx (CONST_INT, VOIDmode, value | 0xffff0000);
  2215.     }
  2216.     }
  2217. }")
  2218.  
  2219. (define_insn ""
  2220.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  2221.     (and:SI (match_operand:SI 1 "arith32_operand" "%r,r")
  2222.         (match_operand:SI 2 "arith32_operand" "rIJL,rn")))]
  2223.   ""
  2224.   "* return output_and (operands);"
  2225.   [(set_attr "type" "arith,marith")])
  2226.  
  2227. (define_insn ""
  2228.   [(set (match_operand:DI 0 "register_operand" "=r")
  2229.     (and:DI (not:DI (match_operand:DI 1 "register_operand" "r"))
  2230.         (match_operand:DI 2 "register_operand" "r")))]
  2231.   ""
  2232.   "and.c %d0,%d2,%d1\;and.c %0,%2,%1"
  2233.   [(set_attr "type" "marith")])
  2234.  
  2235. (define_insn "anddi3"
  2236.   [(set (match_operand:DI 0 "register_operand" "=r")
  2237.     (and:DI (match_operand:DI 1 "arith64_operand" "%r")
  2238.         (match_operand:DI 2 "arith64_operand" "rn")))]
  2239.   ""
  2240.   "*
  2241. {
  2242.   rtx xoperands[10];
  2243.  
  2244.   xoperands[0] = operand_subword (operands[0], 1, 0, DImode);
  2245.   xoperands[1] = operand_subword (operands[1], 1, 0, DImode);
  2246.   xoperands[2] = operand_subword (operands[2], 1, 0, DImode);
  2247.  
  2248.   output_asm_insn (output_and (xoperands), xoperands);
  2249.  
  2250.   operands[0] = operand_subword (operands[0], 0, 0, DImode);
  2251.   operands[1] = operand_subword (operands[1], 0, 0, DImode);
  2252.   operands[2] = operand_subword (operands[2], 0, 0, DImode);
  2253.  
  2254.   return output_and (operands);
  2255. }"
  2256.   [(set_attr "type" "marith")
  2257.    (set_attr "length" "4")]) ; length is 2, 3, or 4.
  2258.  
  2259. ;;- Bit set (inclusive or) instructions (with complement also)
  2260. (define_insn ""
  2261.   [(set (match_operand:SI 0 "register_operand" "=r")
  2262.     (ior:SI (not:SI (match_operand:SI 1 "register_operand" "r"))
  2263.         (match_operand:SI 2 "register_operand" "r")))]
  2264.   ""
  2265.   "or.c %0,%2,%1")
  2266.  
  2267. (define_expand "iorsi3"
  2268.   [(set (match_operand:SI 0 "register_operand" "")
  2269.     (ior:SI (match_operand:SI 1 "arith32_operand" "")
  2270.         (match_operand:SI 2 "arith32_operand" "")))]
  2271.   ""
  2272.   "
  2273. {
  2274.   if (GET_CODE (operands[2]) == CONST_INT)
  2275.     {
  2276.       int value = INTVAL (operands[2]);
  2277.  
  2278.       if (! (SMALL_INTVAL (value)
  2279.          || (value & 0xffff) == 0
  2280.          || integer_ok_for_set (value)))
  2281.     {
  2282.       emit_insn (gen_iorsi3 (operands[0], operands[1],
  2283.                  gen_rtx (CONST_INT, VOIDmode,
  2284.                       value & 0xffff0000)));
  2285.       operands[1] = operands[0];
  2286.       operands[2] = gen_rtx (CONST_INT, VOIDmode, value & 0xffff);
  2287.     }
  2288.     }
  2289. }")
  2290.  
  2291. (define_insn ""
  2292.   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
  2293.     (ior:SI (match_operand:SI 1 "arith32_operand" "%r,r,r,r")
  2294.         (match_operand:SI 2 "arith32_operand" "rI,L,M,n")))]
  2295.   ""
  2296.   "@
  2297.    or %0,%1,%2
  2298.    or.u %0,%1,%X2
  2299.    set %0,%1,%s2
  2300.    or.u %0,%1,%X2\;or %0,%0,%x2"
  2301.   [(set_attr "type" "arith,arith,arith,marith")])
  2302.  
  2303. (define_insn ""
  2304.   [(set (match_operand:DI 0 "register_operand" "=r")
  2305.     (ior:DI (not:DI (match_operand:DI 1 "register_operand" "r"))
  2306.         (match_operand:DI 2 "register_operand" "r")))]
  2307.   ""
  2308.   "or.c %d0,%d2,%d1\;or.c %0,%2,%1"
  2309.   [(set_attr "type" "marith")])
  2310.  
  2311. (define_insn "iordi3"
  2312.   [(set (match_operand:DI 0 "register_operand" "=r")
  2313.     (ior:DI (match_operand:DI 1 "arith64_operand" "%r")
  2314.         (match_operand:DI 2 "arith64_operand" "rn")))]
  2315.   ""
  2316.   "*
  2317. {
  2318.   rtx xoperands[10];
  2319.  
  2320.   xoperands[0] = operand_subword (operands[0], 1, 0, DImode);
  2321.   xoperands[1] = operand_subword (operands[1], 1, 0, DImode);
  2322.   xoperands[2] = operand_subword (operands[2], 1, 0, DImode);
  2323.  
  2324.   output_asm_insn (output_ior (xoperands), xoperands);
  2325.  
  2326.   operands[0] = operand_subword (operands[0], 0, 0, DImode);
  2327.   operands[1] = operand_subword (operands[1], 0, 0, DImode);
  2328.   operands[2] = operand_subword (operands[2], 0, 0, DImode);
  2329.  
  2330.   return output_ior (operands);
  2331. }"
  2332.   [(set_attr "type" "marith")
  2333.    (set_attr "length" "4")]) ; length is 2, 3, or 4.
  2334.  
  2335. ;;- xor instructions (with complement also)
  2336. (define_insn ""
  2337.   [(set (match_operand:SI 0 "register_operand" "=r")
  2338.     (not:SI (xor:SI (match_operand:SI 1 "register_operand" "%r")
  2339.             (match_operand:SI 2 "register_operand" "r"))))]
  2340.   ""
  2341.   "xor.c %0,%1,%2")
  2342.  
  2343. (define_expand "xorsi3"
  2344.   [(set (match_operand:SI 0 "register_operand" "")
  2345.     (xor:SI (match_operand:SI 1 "arith32_operand" "")
  2346.         (match_operand:SI 2 "arith32_operand" "")))]
  2347.   ""
  2348.   "
  2349. {
  2350.   if (GET_CODE (operands[2]) == CONST_INT)
  2351.     {
  2352.       int value = INTVAL (operands[2]);
  2353.  
  2354.       if (! (SMALL_INTVAL (value)
  2355.          || (value & 0xffff) == 0))
  2356.     {
  2357.       emit_insn (gen_xorsi3 (operands[0], operands[1],
  2358.                  gen_rtx (CONST_INT, VOIDmode,
  2359.                       value & 0xffff0000)));
  2360.       operands[1] = operands[0];
  2361.       operands[2] = gen_rtx (CONST_INT, VOIDmode, value & 0xffff);
  2362.     }
  2363.     }
  2364. }")
  2365.  
  2366. (define_insn ""
  2367.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  2368.     (xor:SI (match_operand:SI 1 "arith32_operand" "%r,r,r")
  2369.         (match_operand:SI 2 "arith32_operand" "rI,L,n")))]
  2370.   ""
  2371.   "@
  2372.    xor %0,%1,%2
  2373.    xor.u %0,%1,%X2
  2374.    xor.u %0,%1,%X2\;xor %0,%0,%x2"
  2375.   [(set_attr "type" "arith,arith,marith")])
  2376.  
  2377. (define_insn ""
  2378.   [(set (match_operand:DI 0 "register_operand" "=r")
  2379.     (not:DI (xor:DI (match_operand:DI 1 "register_operand" "r")
  2380.             (match_operand:DI 2 "register_operand" "r"))))]
  2381.   ""
  2382.   "xor.c %d0,%d1,%d2\;xor.c %0,%1,%2"
  2383.   [(set_attr "type" "marith")])
  2384.  
  2385. (define_insn "xordi3"
  2386.   [(set (match_operand:DI 0 "register_operand" "=r")
  2387.     (xor:DI (match_operand:DI 1 "arith64_operand" "%r")
  2388.         (match_operand:DI 2 "arith64_operand" "rn")))]
  2389.   ""
  2390.   "*
  2391. {
  2392.   rtx xoperands[10];
  2393.  
  2394.   xoperands[0] = operand_subword (operands[0], 1, 0, DImode);
  2395.   xoperands[1] = operand_subword (operands[1], 1, 0, DImode);
  2396.   xoperands[2] = operand_subword (operands[2], 1, 0, DImode);
  2397.  
  2398.   output_asm_insn (output_xor (xoperands), xoperands);
  2399.  
  2400.   operands[0] = operand_subword (operands[0], 0, 0, DImode);
  2401.   operands[1] = operand_subword (operands[1], 0, 0, DImode);
  2402.   operands[2] = operand_subword (operands[2], 0, 0, DImode);
  2403.  
  2404.   return output_xor (operands);
  2405. }"
  2406.   [(set_attr "type" "marith")
  2407.    (set_attr "length" "4")]) ; length is 2, 3, or 4.
  2408.  
  2409. ;;- ones complement instructions
  2410. (define_insn "one_cmplsi2"
  2411.   [(set (match_operand:SI 0 "register_operand" "=r")
  2412.     (not:SI (match_operand:SI 1 "register_operand" "r")))]
  2413.   ""
  2414.   "xor.c %0,%1,%#r0")
  2415.  
  2416. (define_insn "one_cmpldi2"
  2417.   [(set (match_operand:DI 0 "register_operand" "=r")
  2418.     (not:DI (match_operand:DI 1 "register_operand" "r")))]
  2419.   ""
  2420.   "xor.c %d0,%d1,%#r0\;xor.c %0,%1,%#r0"
  2421.   [(set_attr "type" "marith")])
  2422.  
  2423. ;; Optimized special cases of shifting.
  2424. ;; Must precede the general case.
  2425.  
  2426. ;; @@ What about HImode shifted by 8?
  2427.  
  2428. (define_insn ""
  2429.   [(set (match_operand:SI 0 "register_operand" "=r")
  2430.     (ashiftrt:SI (match_operand:SI 1 "memory_operand" "m")
  2431.              (const_int 24)))]
  2432.   "! SCALED_ADDRESS_P (XEXP (operands[1], 0))"
  2433.   "ld.b %0,%1"
  2434.   [(set_attr "type" "load")])
  2435.  
  2436. (define_insn ""
  2437.   [(set (match_operand:SI 0 "register_operand" "=r")
  2438.     (lshiftrt:SI (match_operand:SI 1 "memory_operand" "m")
  2439.              (const_int 24)))]
  2440.   "! SCALED_ADDRESS_P (XEXP (operands[1], 0))"
  2441.   "ld.bu %0,%1"
  2442.   [(set_attr "type" "load")])
  2443.  
  2444. (define_insn ""
  2445.   [(set (match_operand:SI 0 "register_operand" "=r")
  2446.     (ashiftrt:SI (match_operand:SI 1 "memory_operand" "m")
  2447.              (const_int 16)))]
  2448.   "! SCALED_ADDRESS_P (XEXP (operands[1], 0))"
  2449.   "ld.h %0,%1"
  2450.   [(set_attr "type" "load")])
  2451.  
  2452. (define_insn ""
  2453.   [(set (match_operand:SI 0 "register_operand" "=r")
  2454.     (lshiftrt:SI (match_operand:SI 1 "memory_operand" "m")
  2455.              (const_int 16)))]
  2456.   "! SCALED_ADDRESS_P (XEXP (operands[1], 0))"
  2457.   "ld.hu %0,%1"
  2458.   [(set_attr "type" "load")])
  2459.  
  2460. ;;- arithmetic shift instructions.
  2461.  
  2462. ;; @@ Do the optimized patterns with -1 get used?  Perhaps operand 1 should
  2463. ;; be arith32_operand?
  2464.  
  2465. ;; Use tbnd to support TARGET_TRAP_LARGE_SHIFT.
  2466. (define_insn "tbnd"
  2467.   [(set (pc)
  2468.     (if_then_else (gtu (match_operand:SI 0 "register_operand" "r")
  2469.                (match_operand:SI 0 "arith_operand" "rI"))
  2470.               (const_int 7)
  2471.               (pc)))]
  2472.   ""
  2473.   "tbnd %r0,%1"
  2474.   [(set_attr "type" "wierd")])
  2475.  
  2476. ;; Just in case the optimizer decides to fold away the test.
  2477. (define_insn ""
  2478.   [(set (pc) (const_int 7))]
  2479.   ""
  2480.   "tbnd %#r31,0"
  2481.   [(set_attr "type" "wierd")])
  2482.  
  2483. (define_expand "ashlsi3"
  2484.   [(set (match_operand:SI 0 "register_operand" "")
  2485.     (ashift:SI (match_operand:SI 1 "register_operand" "")
  2486.            (match_operand:SI 2 "arith32_operand" "")))]
  2487.   ""
  2488.   "
  2489. {
  2490.   if (GET_CODE (operands[2]) == CONST_INT)
  2491.     {
  2492.       if ((unsigned) INTVAL (operands[2]) > 31)
  2493.     {
  2494.       if (TARGET_TRAP_LARGE_SHIFT)
  2495.         emit_insn (gen_tbnd (force_reg (SImode, operands[2]),
  2496.                  gen_rtx (CONST_INT, VOIDmode, 31)));
  2497.       else
  2498.         emit_move_insn (operands[0], const0_rtx);
  2499.       DONE;
  2500.     }
  2501.     }
  2502.  
  2503.   else if (TARGET_TRAP_LARGE_SHIFT)
  2504.     emit_insn (gen_tbnd (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2505.  
  2506.   else if (TARGET_HANDLE_LARGE_SHIFT)
  2507.     {
  2508.       rtx reg = gen_reg_rtx (SImode);
  2509.       emit_insn (gen_cmpsi (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2510.       emit_insn (gen_extendsleu (reg));
  2511.       emit_insn (gen_andsi3 (reg, operands[1], reg));
  2512.       operands[1] = reg;
  2513.     }
  2514. }")
  2515.  
  2516. (define_insn ""
  2517.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  2518.     (ashift:SI (match_operand:SI 1 "register_operand" "r,r")
  2519.            (match_operand:SI 2 "arith5_operand" "r,n")))]
  2520.   ""
  2521.   "@
  2522.    mak %0,%1,%2
  2523.    mak %0,%1,0<%2>")
  2524.  
  2525. (define_expand "ashrsi3"
  2526.   [(set (match_operand:SI 0 "register_operand" "")
  2527.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "")
  2528.              (match_operand:SI 2 "arith32_operand" "")))]
  2529.   ""
  2530.   "
  2531. {
  2532.   if (GET_CODE (operands[2]) == CONST_INT)
  2533.     {
  2534.       if ((unsigned) INTVAL (operands[2]) > 31)
  2535.     {
  2536.       if (TARGET_TRAP_LARGE_SHIFT)
  2537.         {
  2538.           emit_insn (gen_tbnd (force_reg (SImode, operands[2]),
  2539.                    gen_rtx (CONST_INT, VOIDmode, 31)));
  2540.           DONE;
  2541.         }
  2542.       else
  2543.         operands[2] = gen_rtx (CONST_INT, VOIDmode, 31);
  2544.     }
  2545.     }
  2546.  
  2547.   else if (TARGET_TRAP_LARGE_SHIFT)
  2548.     emit_insn (gen_tbnd (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2549.  
  2550.   else if (TARGET_HANDLE_LARGE_SHIFT)
  2551.     {
  2552.       rtx reg = gen_reg_rtx (SImode);
  2553.       emit_insn (gen_cmpsi (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2554.       emit_insn (gen_extendsgtu (reg));
  2555.       emit_insn (gen_iorsi3 (reg, operands[2], reg));
  2556.       operands[2] = reg;
  2557.     }
  2558. }")
  2559.  
  2560. (define_insn ""
  2561.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  2562.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "r,r")
  2563.              (match_operand:SI 2 "arith5_operand" "r,n")))]
  2564.   ""
  2565.   "@
  2566.    ext %0,%1,%2
  2567.    ext %0,%1,0<%2>")
  2568.  
  2569. ;;- logical shift instructions.  Logical shift left becomes arithmetic
  2570. ;; shift left.  LSHIFT is not normally produced, but is supported.
  2571.  
  2572. (define_expand "lshlsi3"
  2573.   [(set (match_operand:SI 0 "register_operand" "")
  2574.     (lshift:SI (match_operand:SI 1 "register_operand" "")
  2575.            (match_operand:SI 2 "arith32_operand" "")))]
  2576.   ""
  2577.   "
  2578. {
  2579.   emit_insn (gen_ashlsi3 (operands[0], operands[1], operands[2]));
  2580.   DONE;
  2581. }")
  2582.  
  2583. (define_insn ""
  2584.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  2585.     (lshift:SI (match_operand:SI 1 "register_operand" "r,r")
  2586.            (match_operand:SI 2 "arith5_operand" "r,n")))]
  2587.   ""
  2588.   "@
  2589.    mak %0,%1,%2
  2590.    mak %0,%1,0<%2>")
  2591.  
  2592. (define_expand "lshrsi3"
  2593.   [(set (match_operand:SI 0 "register_operand" "")
  2594.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "")
  2595.              (match_operand:SI 2 "arith32_operand" "")))]
  2596.   ""
  2597.   "
  2598. {
  2599.   if (GET_CODE (operands[2]) == CONST_INT)
  2600.     {
  2601.       if ((unsigned) INTVAL (operands[2]) > 31)
  2602.     {
  2603.       if (TARGET_TRAP_LARGE_SHIFT)
  2604.         emit_insn (gen_tbnd (force_reg (SImode, operands[2]),
  2605.                  gen_rtx (CONST_INT, VOIDmode, 31)));
  2606.       else
  2607.         emit_move_insn (operands[0], const0_rtx);
  2608.       DONE;
  2609.     }
  2610.     }
  2611.  
  2612.   else if (TARGET_TRAP_LARGE_SHIFT)
  2613.     emit_insn (gen_tbnd (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2614.  
  2615.   else if (TARGET_HANDLE_LARGE_SHIFT)
  2616.     {
  2617.       rtx reg = gen_reg_rtx (SImode);
  2618.       emit_insn (gen_cmpsi (operands[2], gen_rtx (CONST_INT, VOIDmode, 31)));
  2619.       emit_insn (gen_extendsleu (reg));
  2620.       emit_insn (gen_andsi3 (reg, operands[1], reg));
  2621.       operands[1] = reg;
  2622.     }
  2623. }")
  2624.  
  2625. (define_insn ""
  2626.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  2627.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "r,r")
  2628.              (match_operand:SI 2 "arith5_operand" "r,n")))]
  2629.   ""
  2630.   "@
  2631.    extu %0,%1,%2
  2632.    extu %0,%1,0<%2>")
  2633.  
  2634. ;;- rotate instructions
  2635.  
  2636. (define_expand "rotlsi3"
  2637.   [(set (match_operand:SI 0 "register_operand" "")
  2638.     (rotatert:SI (match_operand:SI 1 "register_operand" "")
  2639.              (match_operand:SI 2 "arith32_operand" "")))]
  2640.   ""
  2641.   "
  2642. {
  2643.   if (GET_CODE (operands[2]) == CONST_INT
  2644.       && (unsigned) INTVAL (operands[2]) >= 32)
  2645.     operands[2] = gen_rtx (CONST_INT, VOIDmode,
  2646.                (32 - INTVAL (operands[2])) % 32);
  2647.   else
  2648.     {
  2649.       rtx op = gen_reg_rtx (SImode);
  2650.       emit_insn (gen_negsi2 (op, operands[2]));
  2651.       operands[2] = op;
  2652.     }
  2653. }")
  2654.  
  2655. (define_insn "rotrsi3"
  2656.   [(set (match_operand:SI 0 "register_operand" "=r")
  2657.     (rotatert:SI (match_operand:SI 1 "register_operand" "r")
  2658.              (match_operand:SI 2 "arith_operand" "rI")))]
  2659.   ""
  2660.   "rot %0,%1,%2")
  2661.  
  2662. ;; Bit field instructions.
  2663.  
  2664. (define_insn ""
  2665.   [(set (match_operand:SI 0 "register_operand" "=r")
  2666.     (sign_extract:SI (match_operand:SI 1 "register_operand" "r")
  2667.              (const_int 32)
  2668.              (const_int 0)))]
  2669.   ""
  2670.   "or %0,%#r0,%1")
  2671.  
  2672. (define_insn "extv"
  2673.   [(set (match_operand:SI 0 "register_operand" "=r")
  2674.     (sign_extract:SI (match_operand:SI 1 "register_operand" "r")
  2675.              (match_operand:SI 2 "int5_operand" "")
  2676.              (match_operand:SI 3 "int5_operand" "")))]
  2677.   ""
  2678.   "ext %0,%1,%2<(32-%2-%3)>")
  2679.  
  2680. (define_insn ""
  2681.   [(set (match_operand:SI 0 "register_operand" "=r")
  2682.     (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  2683.              (const_int 32)
  2684.              (const_int 0)))]
  2685.   ""
  2686.   "or %0,%#r0,%1")
  2687.  
  2688. (define_insn "extzv"
  2689.   [(set (match_operand:SI 0 "register_operand" "=r")
  2690.     (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  2691.              (match_operand:SI 2 "int5_operand" "")
  2692.              (match_operand:SI 3 "int5_operand" "")))]
  2693.   ""
  2694.   "extu %0,%1,%2<(32-%2-%3)>")
  2695.  
  2696. (define_insn ""
  2697.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
  2698.              (match_operand:SI 1 "int5_operand" "")
  2699.              (match_operand:SI 2 "int5_operand" ""))
  2700.     (const_int 0))]
  2701.   ""
  2702.   "clr %0,%0,%1<(32-%1-%2)>")
  2703.  
  2704. (define_insn ""
  2705.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
  2706.              (match_operand:SI 1 "int5_operand" "")
  2707.              (match_operand:SI 2 "int5_operand" ""))
  2708.     (const_int -1))]
  2709.   ""
  2710.   "set %0,%0,%1<(32-%1-%2)>")
  2711.  
  2712. (define_insn ""
  2713.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "=r")
  2714.              (match_operand:SI 1 "int5_operand" "")
  2715.              (match_operand:SI 2 "int5_operand" ""))
  2716.     (match_operand:SI 3 "int32_operand" "n"))]
  2717.   ""
  2718.   "*
  2719. {
  2720.   int value = INTVAL (operands[3]);
  2721.  
  2722.   if (INTVAL (operands[1]) < 32)
  2723.     value &= (1 << INTVAL (operands[1])) - 1;
  2724.  
  2725.   operands[2] = gen_rtx (CONST_INT, VOIDmode,
  2726.              32 - (INTVAL(operands[1]) + INTVAL(operands[2])));
  2727.  
  2728.   value <<= INTVAL (operands[2]);
  2729.   operands[3] = gen_rtx (CONST_INT, VOIDmode, value);
  2730.  
  2731.   if (SMALL_INTVAL (value))
  2732.     return \"clr %0,%0,%1<%2>\;or %0,%0,%3\";
  2733.   else if ((value & 0x0000ffff) == 0)
  2734.     return \"clr %0,%0,%1<%2>\;or.u %0,%0,%X3\";
  2735.   else
  2736.     return \"clr %0,%0,%1<%2>\;or.u %0,%0,%X3\;or %0,%0,%x3\";
  2737. }"
  2738.   [(set_attr "type" "marith")
  2739.    (set_attr "length" "3")]) ; may be 2 or 3.
  2740.  
  2741. ;; negate insns
  2742. (define_insn "negsi2"
  2743.   [(set (match_operand:SI 0 "register_operand" "=r")
  2744.     (neg:SI (match_operand:SI 1 "arith_operand" "rI")))]
  2745.   ""
  2746.   "subu %0,%#r0,%1")
  2747.  
  2748. (define_insn ""
  2749.   [(set (match_operand:SF 0 "register_operand" "=r")
  2750.     (float_truncate:SF (neg:DF (match_operand:DF 1 "register_operand" "r"))))]
  2751.   ""
  2752.   "fsub.ssd %0,%#r0,%1"
  2753.   [(set_attr "type" "dpadd")])
  2754.  
  2755. (define_insn ""
  2756.   [(set (match_operand:DF 0 "register_operand" "+r")
  2757.     (neg:DF (match_dup 0)))]
  2758.   ""
  2759.   "xor.u %0,%0,0x8000")
  2760.  
  2761. (define_insn "negdf2"
  2762.   [(set (match_operand:DF 0 "register_operand" "=&r")
  2763.     (neg:DF (match_operand:DF 1 "register_operand" "r")))]
  2764.   ""
  2765.   "xor.u %0,%1,0x8000\;or %d0,%#r0,%d1"
  2766.   [(set_attr "type" "marith")])
  2767.  
  2768. (define_insn "negsf2"
  2769.   [(set (match_operand:SF 0 "register_operand" "=r")
  2770.     (neg:SF (match_operand:SF 1 "register_operand" "r")))]
  2771.   ""
  2772.   "xor.u %0,%1,0x8000")
  2773.  
  2774. ;; absolute value insns
  2775.  
  2776. (define_expand "abssi2"
  2777.   [(set (match_operand:SI 0 "register_operand" "")
  2778.     (abs:SI (match_operand:SI 1 "register_operand" "")))]
  2779.   ""
  2780.   "
  2781. {
  2782.   rtx reg_mask = gen_reg_rtx (SImode);
  2783.   rtx op1 = force_reg (SImode, operands[1]);
  2784.  
  2785.   emit_insn (gen_ashrsi3 (reg_mask, op1,
  2786.               gen_rtx (CONST_INT, VOIDmode, 31)));
  2787.  
  2788.   emit_insn (gen_xorsi3 (operands[0], op1, reg_mask));
  2789.   emit_insn (gen_subsi3 (operands[0], operands[0], reg_mask));
  2790.   DONE;
  2791. }")
  2792.  
  2793. (define_insn ""
  2794.   [(set (match_operand:DF 0 "register_operand" "+r")
  2795.     (abs:DF (match_dup 0)))]
  2796.   ""
  2797.   "and.u %0,%0,0x7fff")
  2798.  
  2799. (define_insn "absdf2"
  2800.   [(set (match_operand:DF 0 "register_operand" "=&r")
  2801.     (abs:DF (match_operand:DF 1 "register_operand" "r")))]
  2802.   ""
  2803.   "and.u %0,%1,0x7fff\;or %d0,%#r0,%d1"
  2804.   [(set_attr "type" "marith")])
  2805.  
  2806. (define_insn "abssf2"
  2807.   [(set (match_operand:SF 0 "register_operand" "=r")
  2808.     (abs:SF (match_operand:SF 1 "register_operand" "r")))]
  2809.   ""
  2810.   "and.u %0,%1,0x7fff")
  2811.  
  2812. ;; Subroutines of "casesi".
  2813.  
  2814. ;; Operand 0 is index
  2815. ;; operand 1 is the minimum bound
  2816. ;; operand 2 is the maximum bound - minimum bound + 1
  2817. ;; operand 3 is CODE_LABEL for the table;
  2818. ;; operand 4 is the CODE_LABEL to go to if index out of range.
  2819.  
  2820. ;; (disabled on NeXT)
  2821. (define_expand "casesi"
  2822.   ;; We don't use these for generating the RTL, but we must describe
  2823.   ;; the operands here.
  2824.   [(match_operand:SI 0 "general_operand" "")
  2825.    (match_operand:SI 1 "immediate_operand" "")
  2826.    (match_operand:SI 2 "immediate_operand" "")
  2827.    (match_operand 3 "" "")
  2828.    (match_operand 4 "" "")]
  2829.   "0"
  2830.   "
  2831. {
  2832.   register rtx index_diff = gen_reg_rtx (SImode);
  2833.   register rtx low = gen_rtx (CONST_INT, VOIDmode, -INTVAL (operands[1]));
  2834.  
  2835.   /* Compute the index difference and handle the default case.  */
  2836.   emit_insn (gen_addsi3 (index_diff,
  2837.              force_reg (SImode, operands[0]),
  2838.              ADD_INT (low) ? low : force_reg (SImode, low)));
  2839.   emit_insn (gen_cmpsi (index_diff, operands[2]));
  2840.   emit_jump_insn (gen_bgtu (operands[4]));
  2841.  
  2842.   /* Call the jump that will branch to the appropriate case.  */
  2843.   emit_jump_insn (gen_casesi_enter (gen_rtx (LABEL_REF, VOIDmode, operands[3]),
  2844.                     index_diff,
  2845.                     operands[3]));
  2846.   emit_barrier ();
  2847.   DONE;
  2848. }")
  2849.  
  2850. ;; The bsr.n instruction is directed to the END of the table.  See
  2851. ;; ASM_OUTPUT_CASE_END.
  2852.  
  2853. (define_insn "casesi_enter"
  2854.   [(set (pc) (match_operand 0 "" ""))
  2855.    (use (match_operand:SI 1 "register_operand" "r"))
  2856.    ;; The USE here is so that at least one jump-insn will refer to the label,
  2857.    ;; to keep it alive in jump_optimize.
  2858.    (use (label_ref (match_operand 2 "" "")))
  2859.    (clobber (reg:SI 1))]
  2860.   ""
  2861.   "bsr.n %0e\;lda %#r1,%#r1[%1]"
  2862.   [(set_attr "type" "wierd")
  2863.    (set_attr "length" "3")]) ; Including the "jmp r1".
  2864.  
  2865. ;;- jump to subroutine
  2866. (define_expand "call"
  2867.   [(parallel [(call (match_operand:SI 0 "" "")
  2868.             (match_operand 1 "" ""))
  2869.           (use (reg:SI 1))])]
  2870.   ""
  2871.   "
  2872. {
  2873.   if (GET_CODE (operands[0]) == MEM
  2874.       && ! call_address_operand (XEXP (operands[0], 0), SImode))
  2875.     operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  2876.                force_reg (Pmode, XEXP (operands[0], 0)));
  2877. }")
  2878.  
  2879. (define_insn ""
  2880.   [(parallel [(call (mem:SI (match_operand:SI 0 "call_address_operand" "rQ"))
  2881.             (match_operand 1 "" ""))
  2882.           (use (reg:SI 1))])]
  2883.   ""
  2884.   "* return output_call (operands, operands[0]);"
  2885.   [(set_attr "type" "call")])
  2886.  
  2887. (define_expand "call_value"
  2888.   [(parallel [(set (match_operand 0 "register_operand" "")
  2889.            (call (match_operand:SI 1 "" "")
  2890.              (match_operand 2 "" "")))
  2891.           (use (reg:SI 1))])]
  2892.   ""
  2893.   "
  2894. {
  2895.   if (GET_CODE (operands[1]) == MEM
  2896.       && ! call_address_operand (XEXP (operands[1], 0), SImode))
  2897.     operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  2898.                force_reg (Pmode, XEXP (operands[1], 0)));
  2899. }")
  2900.  
  2901. (define_insn ""
  2902.   [(parallel [(set (match_operand 0 "register_operand" "=r")
  2903.            (call (mem:SI
  2904.               (match_operand:SI 1 "call_address_operand" "rQ"))
  2905.              (match_operand 2 "" "")))
  2906.           (use (reg:SI 1))])]
  2907.   ""
  2908.   "* return output_call (operands, operands[1]);"
  2909.   [(set_attr "type" "call")])
  2910.  
  2911. ;; Nop instruction and others
  2912.  
  2913. (define_insn "nop"
  2914.   [(const_int 0)]
  2915.   ""
  2916.   "ff0 %#r0,%#r0")
  2917.  
  2918. (define_insn "return"
  2919.   [(return)]
  2920.   "null_epilogue ()"
  2921.   "jmp%. %#r1"
  2922.   [(set_attr "type" "branch")])
  2923.  
  2924. ;; jump to variable address (for NeXT).
  2925. (define_insn "tablejump"
  2926.   [(set (pc) (match_operand:SI 0 "register_operand" "r"))
  2927.    (use (label_ref (match_operand 1 "" "")))]
  2928.   ""
  2929.   "jmp%. %0"
  2930.   [(set_attr "type" "branch")])
  2931.  
  2932. (define_insn "indirect_jump"
  2933.   [(set (pc) (match_operand:SI 0 "register_operand" "r"))]
  2934.   ""
  2935.   "jmp%. %0"
  2936.   [(set_attr "type" "branch")])
  2937.  
  2938. (define_insn "jump"
  2939.   [(set (pc)
  2940.     (label_ref (match_operand 0 "" "")))]
  2941.   ""
  2942.   "br%. %l0"
  2943.   [(set_attr "type" "jump")])
  2944.  
  2945. ;; Special insn to serve as the last insn of a define_expand.  This insn
  2946. ;; will generate no code.
  2947.  
  2948. (define_expand "dummy"
  2949.   [(set (match_operand 0 "" "") (match_dup 0))]
  2950.   ""
  2951.   "")
  2952.  
  2953. ;;- Local variables:
  2954. ;;- mode:emacs-lisp
  2955. ;;- comment-start: ";;- "
  2956. ;;- eval: (set-syntax-table (copy-sequence (syntax-table)))
  2957. ;;- eval: (modify-syntax-entry ?[ "(]")
  2958. ;;- eval: (modify-syntax-entry ?] ")[")
  2959. ;;- eval: (modify-syntax-entry ?{ "(}")
  2960. ;;- eval: (modify-syntax-entry ?} "){")
  2961. ;;- End:
  2962.