home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 6 / FreshFish_September1994.bin / bbs / gnu / gcc-2.6.0-src.lha / GNU / src / amiga / gcc-2.6.0 / config / rs6000 / rs6000.md < prev    next >
Encoding:
Text File  |  1994-07-13  |  202.4 KB  |  6,480 lines
  1. ;; Machine description for IBM RISC System 6000 (POWER) for GNU C compiler
  2. ;; Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
  3. ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
  4.  
  5. ;; This file is part of GNU CC.
  6.  
  7. ;; GNU CC is free software; you can redistribute it and/or modify
  8. ;; it under the terms of the GNU General Public License as published by
  9. ;; the Free Software Foundation; either version 2, or (at your option)
  10. ;; any later version.
  11.  
  12. ;; GNU CC is distributed in the hope that it will be useful,
  13. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ;; GNU General Public License for more details.
  16.  
  17. ;; You should have received a copy of the GNU General Public License
  18. ;; along with GNU CC; see the file COPYING.  If not, write to
  19. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  22.  
  23. ;; Define an insn type attribute.  This is used in function unit delay
  24. ;; computations.
  25. (define_attr "type" "integer,load,fpload,imul,idiv,branch,compare,delayed_compare,fpcompare,mtjmpr,fp,dmul,sdiv,ddiv,ssqrt,dsqrt,jmpreg"
  26.   (const_string "integer"))
  27.  
  28. ;; Length (in bytes).
  29. (define_attr "length" ""
  30.   (if_then_else (eq_attr "type" "branch")
  31.         (if_then_else (and (ge (minus (pc) (match_dup 0))
  32.                        (const_int -32768))
  33.                    (lt (minus (pc) (match_dup 0))
  34.                        (const_int 32767)))
  35.                   (const_int 8)
  36.                   (const_int 12))
  37.         (const_int 4)))
  38.  
  39. ;; Processor type -- this attribute must exactly match the processor_type
  40. ;; enumeration in rs6000.h.
  41.  
  42. (define_attr "cpu" "rios1,rios2,ppc601,ppc603,ppc604,ppc620"
  43.   (const (symbol_ref "rs6000_cpu_attr")))
  44.  
  45. ; (define_function_unit NAME MULTIPLICITY SIMULTANEITY
  46. ;            TEST READY-DELAY ISSUE-DELAY [CONFLICT-LIST])
  47.  
  48. ; Load/Store Unit -- POWER/2 and pure PowerPC only
  49. ; (POWER and 601 use Integer Unit)
  50. (define_function_unit "lsu" 1 0
  51.   (and (eq_attr "type" "load")
  52.        (eq_attr "cpu" "rios2,ppc603,ppc604,ppc620"))
  53.   2 0)
  54.  
  55. (define_function_unit "lsu" 1 0
  56.   (and (eq_attr "type" "fpload")
  57.        (eq_attr "cpu" "rios2,ppc603,ppc604,ppc620"))
  58.   2 0)
  59.  
  60. (define_function_unit "iu" 1 0
  61.   (and (eq_attr "type" "load")
  62.        (eq_attr "cpu" "rios1,ppc601"))
  63.   2 0)
  64.  
  65. (define_function_unit "iu" 1 0
  66.   (and (eq_attr "type" "fpload")
  67.        (eq_attr "cpu" "rios1,ppc601"))
  68.   3 0)
  69.  
  70. ; Integer Unit (RIOS1, PPC601, PPC603)
  71. ; Trivial operations take one cycle which need not be listed here.
  72. (define_function_unit "iu" 1 0
  73.   (and (eq_attr "type" "imul")
  74.        (eq_attr "cpu" "rios1"))
  75.   3 3)
  76.  
  77. (define_function_unit "iu" 1 0
  78.   (and (eq_attr "type" "imul")
  79.        (eq_attr "cpu" "ppc601,ppc603"))
  80.   5 5)
  81.  
  82. (define_function_unit "iu" 1 0
  83.   (and (eq_attr "type" "idiv")
  84.        (eq_attr "cpu" "rios1"))
  85.   19 19)
  86.  
  87. (define_function_unit "iu" 1 0
  88.   (and (eq_attr "type" "idiv")
  89.        (eq_attr "cpu" "ppc601"))
  90.   36 36)
  91.  
  92. (define_function_unit "iu" 1 0
  93.   (and (eq_attr "type" "idiv")
  94.        (eq_attr "cpu" "ppc603"))
  95.   37 36)
  96.  
  97. ; RIOS2 has two integer units: a primary one which can perform all
  98. ; operations and a secondary one which is fed in lock step with the first
  99. ; and can perform "simple" integer operations.
  100. (define_function_unit "iu2" 2 0
  101.   (and (eq_attr "type" "integer")
  102.        (eq_attr "cpu" "rios2"))
  103.   1 0
  104.   [(eq_attr "type" "imul,idiv")])
  105.  
  106. (define_function_unit "imuldiv" 1 0
  107.   (and (eq_attr "type" "imul")
  108.        (eq_attr "cpu" "rios2"))
  109.   2 2
  110.   [(eq_attr "type" "integer")])
  111.  
  112. (define_function_unit "imuldiv" 1 0
  113.   (and (eq_attr "type" "idiv")
  114.        (eq_attr "cpu" "rios2"))
  115.   13 13
  116.   [(eq_attr "type" "integer")])
  117.  
  118. ; PPC604 has three integer units: one primary and two secondary.
  119. (define_function_unit "iu3" 3 0
  120.   (and (eq_attr "type" "integer")
  121.        (eq_attr "cpu" "ppc604,ppc620"))
  122.   1 0
  123.   [(eq_attr "type" "imul,idiv")])
  124.  
  125. (define_function_unit "imuldiv" 1 0
  126.   (and (eq_attr "type" "imul")
  127.        (eq_attr "cpu" "ppc604,ppc620"))
  128.   4 2
  129.   [(eq_attr "type" "integer")])
  130.  
  131. (define_function_unit "imuldiv" 1 0
  132.   (and (eq_attr "type" "idiv")
  133.        (eq_attr "cpu" "ppc604,ppc620"))
  134.   20 19
  135.   [(eq_attr "type" "integer")])
  136.  
  137. ; Branch Processing Unit
  138. (define_function_unit "bpu" 1 0
  139.   (eq_attr "type" "compare")
  140.   4 0)
  141.  
  142. (define_function_unit "bpu" 1 0
  143.   (eq_attr "type" "delayed_compare")
  144.   5 0)
  145.  
  146. (define_function_unit "bpu" 1 0
  147.   (and (eq_attr "type" "fpcompare")
  148.        (eq_attr "cpu" "rios1,rios2"))
  149.   8 0)
  150.  
  151. (define_function_unit "bpu" 1 0
  152.   (and (eq_attr "type" "fpcompare")
  153.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  154.   4 0)
  155.  
  156. (define_function_unit "bpu" 1 0
  157.   (and (eq_attr "type" "mtjmpr")
  158.        (eq_attr "cpu" "rios1,rios2"))
  159.   5 0)
  160.  
  161. (define_function_unit "bpu" 1 0
  162.   (and (eq_attr "type" "mtjmpr")
  163.        (eq_attr "cpu" "ppc601,ppc603,ppc604,ppc620"))
  164.   4 0)
  165.  
  166. ; Floating Point Unit (RIOS1, PPC601, PPC603, PPC604).
  167. (define_function_unit "fpu" 1 0
  168.   (and (eq_attr "type" "fp,dmul")
  169.        (eq_attr "cpu" "rios1"))
  170.   2 0)
  171.  
  172. (define_function_unit "fpu" 1 0
  173.   (and (eq_attr "type" "fp")
  174.        (eq_attr "cpu" "ppc601"))
  175.   4 0)
  176.  
  177. (define_function_unit "fpu" 1 0
  178.   (and (eq_attr "type" "fp")
  179.        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
  180.   3 0)
  181.  
  182. (define_function_unit "fpu" 1 0
  183.   (and (eq_attr "type" "dmul")
  184.        (eq_attr "cpu" "ppc601"))
  185.   5 5)
  186.  
  187. (define_function_unit "fpu" 1 0
  188.   (and (eq_attr "type" "dmul")
  189.        (eq_attr "cpu" "ppc603"))
  190.   4 2)
  191.  
  192. (define_function_unit "fpu" 1 0
  193.   (and (eq_attr "type" "dmul")
  194.        (eq_attr "cpu" "ppc604,ppc620"))
  195.   3 0)
  196.  
  197. (define_function_unit "fpu" 1 0
  198.   (and (eq_attr "type" "sdiv,ddiv")
  199.        (eq_attr "cpu" "rios1"))
  200.   19 19)
  201.  
  202. (define_function_unit "fpu" 1 0
  203.   (and (eq_attr "type" "sdiv")
  204.        (eq_attr "cpu" "ppc601"))
  205.   17 17)
  206.  
  207. (define_function_unit "fpu" 1 0
  208.   (and (eq_attr "type" "sdiv")
  209.        (eq_attr "cpu" "ppc603,ppc604,ppc620"))
  210.   18 18)
  211.  
  212. (define_function_unit "fpu" 1 0
  213.   (and (eq_attr "type" "ddiv")
  214.        (eq_attr "cpu" "ppc601,ppc604,ppc620"))
  215.   31 31)
  216.  
  217. (define_function_unit "fpu" 1 0
  218.   (and (eq_attr "type" "ddiv")
  219.        (eq_attr "cpu" "ppc603"))
  220.   33 33)
  221.  
  222. (define_function_unit "fpu" 1 0
  223.   (and (eq_attr "type" "ssqrt")
  224.        (eq_attr "cpu" "ppc620"))
  225.   31 31)
  226.  
  227. (define_function_unit "fpu" 1 0
  228.   (and (eq_attr "type" "dsqrt")
  229.        (eq_attr "cpu" "ppc620"))
  230.   31 31)
  231.  
  232. ; RIOS2 has two symmetric FPUs.
  233. (define_function_unit "fpu2" 2 0
  234.   (and (eq_attr "type" "fp")
  235.        (eq_attr "cpu" "rios2"))
  236.   2 0)
  237.  
  238. (define_function_unit "fpu2" 2 0
  239.   (and (eq_attr "type" "dmul")
  240.        (eq_attr "cpu" "rios2"))
  241.   2 0)
  242.  
  243. (define_function_unit "fpu2" 2 0
  244.   (and (eq_attr "type" "sdiv,ddiv")
  245.        (eq_attr "cpu" "rios2"))
  246.   17 17)
  247.  
  248. (define_function_unit "fpu2" 2 0
  249.   (and (eq_attr "type" "ssqrt,dsqrt")
  250.        (eq_attr "cpu" "rios2"))
  251.   26 26)
  252.  
  253. ;; Start with fixed-point load and store insns.  Here we put only the more
  254. ;; complex forms.  Basic data transfer is done later.
  255.  
  256. (define_expand "zero_extendqidi2"
  257.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  258.     (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "")))]
  259.   "TARGET_POWERPC64"
  260.   "")
  261.  
  262. (define_insn ""
  263.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  264.     (zero_extend:DI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
  265.   "TARGET_POWERPC64"
  266.   "@
  267.    lbz%U1%X1 %0,%1
  268.    rldicl %0,%1,0,56"
  269.   [(set_attr "type" "load,*")])
  270.  
  271. (define_insn ""
  272.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  273.     (compare:CC (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
  274.             (const_int 0)))
  275.    (clobber (match_scratch:DI 2 "=r"))]
  276.   "TARGET_POWERPC64"
  277.   "rldicl. %2,%1,0,56"
  278.   [(set_attr "type" "compare")])
  279.  
  280. (define_insn ""
  281.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  282.     (compare:CC (zero_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
  283.             (const_int 0)))
  284.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  285.     (zero_extend:DI (match_dup 1)))]
  286.   "TARGET_POWERPC64"
  287.   "rldicl. %0,%1,0,56"
  288.   [(set_attr "type" "compare")])
  289.  
  290. (define_insn "extendqidi2"
  291.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  292.     (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r")))]
  293.   "TARGET_POWERPC64"
  294.   "extsb %0,%1")
  295.  
  296. (define_insn ""
  297.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  298.     (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
  299.             (const_int 0)))
  300.    (clobber (match_scratch:DI 2 "=r"))]
  301.   "TARGET_POWERPC64"
  302.   "extsb. %2,%1"
  303.   [(set_attr "type" "compare")])
  304.  
  305. (define_insn ""
  306.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  307.     (compare:CC (sign_extend:DI (match_operand:QI 1 "gpc_reg_operand" "r"))
  308.             (const_int 0)))
  309.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  310.     (sign_extend:DI (match_dup 1)))]
  311.   "TARGET_POWERPC64"
  312.   "extsb. %0,%1"
  313.   [(set_attr "type" "compare")])
  314.  
  315. (define_expand "zero_extendhidi2"
  316.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  317.     (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
  318.   "TARGET_POWERPC64"
  319.   "")
  320.  
  321. (define_insn ""
  322.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  323.     (zero_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  324.   "TARGET_POWERPC64"
  325.   "@
  326.    lhz%U1%X1 %0,%1
  327.    rldicl %0,%1,0,48"
  328.   [(set_attr "type" "load,*")])
  329.  
  330. (define_insn ""
  331.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  332.     (compare:CC (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
  333.             (const_int 0)))
  334.    (clobber (match_scratch:DI 2 "=r"))]
  335.   "TARGET_POWERPC64"
  336.   "rldicl. %2,%1,0,48"
  337.   [(set_attr "type" "compare")])
  338.  
  339. (define_insn ""
  340.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  341.     (compare:CC (zero_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
  342.             (const_int 0)))
  343.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  344.     (zero_extend:DI (match_dup 1)))]
  345.   "TARGET_POWERPC64"
  346.   "rldicl. %0,%1,0,48"
  347.   [(set_attr "type" "compare")])
  348.  
  349. (define_expand "extendhidi2"
  350.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  351.     (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "")))]
  352.   "TARGET_POWERPC64"
  353.   "")
  354.  
  355. (define_insn ""
  356.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  357.     (sign_extend:DI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  358.   "TARGET_POWERPC64"
  359.   "@
  360.    lha%U1%X1 %0,%1
  361.    extsh %0,%1"
  362.   [(set_attr "type" "load,*")])
  363.  
  364. (define_insn ""
  365.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  366.     (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
  367.             (const_int 0)))
  368.    (clobber (match_scratch:DI 2 "=r"))]
  369.   "TARGET_POWERPC64"
  370.   "extsh. %2,%1"
  371.   [(set_attr "type" "compare")])
  372.  
  373. (define_insn ""
  374.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  375.     (compare:CC (sign_extend:DI (match_operand:HI 1 "gpc_reg_operand" "r"))
  376.             (const_int 0)))
  377.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  378.     (sign_extend:DI (match_dup 1)))]
  379.   "TARGET_POWERPC64"
  380.   "extsh. %0,%1"
  381.   [(set_attr "type" "compare")])
  382.  
  383. (define_expand "zero_extendsidi2"
  384.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  385.     (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
  386.   "TARGET_POWERPC64"
  387.   "")
  388.  
  389. (define_insn ""
  390.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  391.     (zero_extend:DI (match_operand:SI 1 "reg_or_mem_operand" "m,r")))]
  392.   "TARGET_POWERPC64"
  393.   "@
  394.    lwz%U1%X1 %0,%1
  395.    rldicl %0,%1,0,32"
  396.   [(set_attr "type" "load,*")])
  397.  
  398. (define_insn ""
  399.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  400.     (compare:CC (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  401.             (const_int 0)))
  402.    (clobber (match_scratch:DI 2 "=r"))]
  403.   "TARGET_POWERPC64"
  404.   "rldicl. %2,%1,0,32"
  405.   [(set_attr "type" "compare")])
  406.  
  407. (define_insn ""
  408.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  409.     (compare:CC (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  410.             (const_int 0)))
  411.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  412.     (zero_extend:DI (match_dup 1)))]
  413.   "TARGET_POWERPC64"
  414.   "rldicl. %0,%1,0,32"
  415.   [(set_attr "type" "compare")])
  416.  
  417. (define_expand "extendsidi2"
  418.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  419.     (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "")))]
  420.   "TARGET_POWERPC64"
  421.   "")
  422.  
  423. (define_insn ""
  424.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  425.     (sign_extend:DI (match_operand:SI 1 "reg_or_mem_operand" "m,r")))]
  426.   "TARGET_POWERPC64"
  427.   "@
  428.    lwa%U1%X1 %0,%1
  429.    extsw %0,%1"
  430.   [(set_attr "type" "load,*")])
  431.  
  432. (define_insn ""
  433.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  434.     (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  435.             (const_int 0)))
  436.    (clobber (match_scratch:DI 2 "=r"))]
  437.   "TARGET_POWERPC64"
  438.   "extsw. %2,%1"
  439.   [(set_attr "type" "compare")])
  440.  
  441. (define_insn ""
  442.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  443.     (compare:CC (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  444.             (const_int 0)))
  445.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  446.     (sign_extend:DI (match_dup 1)))]
  447.   "TARGET_POWERPC64"
  448.   "extsw. %0,%1"
  449.   [(set_attr "type" "compare")])
  450.  
  451. (define_expand "zero_extendqisi2"
  452.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  453.     (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "")))]
  454.   ""
  455.   "")
  456.  
  457. (define_insn ""
  458.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  459.     (zero_extend:SI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
  460.   ""
  461.   "@
  462.    lbz%U1%X1 %0,%1
  463.    {rlinm|rlwinm} %0,%1,0,0xff"
  464.   [(set_attr "type" "load,*")])
  465.  
  466. (define_insn ""
  467.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  468.     (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  469.             (const_int 0)))
  470.    (clobber (match_scratch:SI 2 "=r"))]
  471.   ""
  472.   "{andil.|andi.} %2,%1,0xff"
  473.   [(set_attr "type" "compare")])
  474.  
  475. (define_insn ""
  476.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  477.     (compare:CC (zero_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  478.             (const_int 0)))
  479.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  480.     (zero_extend:SI (match_dup 1)))]
  481.   ""
  482.   "{andil.|andi.} %0,%1,0xff"
  483.   [(set_attr "type" "compare")])
  484.  
  485. (define_expand "extendqisi2"
  486.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  487.    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
  488.   ""
  489.   "
  490. {
  491.   if (TARGET_POWERPC)
  492.     emit_insn (gen_extendqisi2_ppc (operands[0], operands[1]));
  493.   else if (TARGET_POWER)
  494.     emit_insn (gen_extendqisi2_power (operands[0], operands[1]));
  495.   else
  496.     emit_insn (gen_extendqisi2_no_power (operands[0], operands[1]));
  497.   DONE;
  498. }")
  499.  
  500. (define_insn "extendqisi2_ppc"
  501.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  502.     (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r")))]
  503.   "TARGET_POWERPC"
  504.   "extsb %0,%1")
  505.  
  506. (define_insn ""
  507.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  508.     (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  509.             (const_int 0)))
  510.    (clobber (match_scratch:SI 2 "=r"))]
  511.   "TARGET_POWERPC"
  512.   "extsb. %2,%1"
  513.   [(set_attr "type" "compare")])
  514.  
  515. (define_insn ""
  516.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  517.     (compare:CC (sign_extend:SI (match_operand:QI 1 "gpc_reg_operand" "r"))
  518.             (const_int 0)))
  519.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  520.     (sign_extend:SI (match_dup 1)))]
  521.   "TARGET_POWERPC"
  522.   "extsb. %0,%1"
  523.   [(set_attr "type" "compare")])
  524.  
  525. (define_expand "extendqisi2_power"
  526.   [(parallel [(set (match_dup 2)
  527.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  528.                   (const_int 24)))
  529.           (clobber (scratch:SI))])
  530.    (parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
  531.            (ashiftrt:SI (match_dup 2)
  532.                 (const_int 24)))
  533.           (clobber (scratch:SI))])]
  534.   "TARGET_POWER"
  535.   "
  536. { operands[1] = gen_lowpart (SImode, operands[1]);
  537.   operands[2] = gen_reg_rtx (SImode); }")
  538.  
  539. (define_expand "extendqisi2_no_power"
  540.   [(set (match_dup 2)
  541.     (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  542.            (const_int 24)))
  543.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  544.     (ashiftrt:SI (match_dup 2)
  545.              (const_int 24)))]
  546.   "! TARGET_POWER && ! TARGET_POWERPC"
  547.   "
  548. { operands[1] = gen_lowpart (SImode, operands[1]);
  549.   operands[2] = gen_reg_rtx (SImode); }")
  550.  
  551. (define_expand "zero_extendqihi2"
  552.   [(set (match_operand:HI 0 "gpc_reg_operand" "")
  553.     (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "")))]
  554.   ""
  555.   "")
  556.  
  557. (define_insn ""
  558.   [(set (match_operand:HI 0 "gpc_reg_operand" "=r,r")
  559.     (zero_extend:HI (match_operand:QI 1 "reg_or_mem_operand" "m,r")))]
  560.   ""
  561.   "@
  562.    lbz%U1%X1 %0,%1
  563.    {rlinm|rlwinm} %0,%1,0,0xff"
  564.   [(set_attr "type" "load,*")])
  565.  
  566. (define_insn ""
  567.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  568.     (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
  569.             (const_int 0)))
  570.    (clobber (match_scratch:HI 2 "=r"))]
  571.   ""
  572.   "{andil.|andi.} %2,%1,0xff"
  573.   [(set_attr "type" "compare")])
  574.  
  575. (define_insn ""
  576.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  577.     (compare:CC (zero_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
  578.             (const_int 0)))
  579.    (set (match_operand:HI 0 "gpc_reg_operand" "=r")
  580.     (zero_extend:HI (match_dup 1)))]
  581.   ""
  582.   "{andil.|andi.} %0,%1,0xff"
  583.   [(set_attr "type" "compare")])
  584.  
  585. (define_expand "extendqihi2"
  586.   [(use (match_operand:HI 0 "gpc_reg_operand" ""))
  587.    (use (match_operand:QI 1 "gpc_reg_operand" ""))]
  588.   ""
  589.   "
  590. {
  591.   if (TARGET_POWERPC)
  592.     emit_insn (gen_extendqihi2_ppc (operands[0], operands[1]));
  593.   else if (TARGET_POWER)
  594.     emit_insn (gen_extendqihi2_power (operands[0], operands[1]));
  595.   else
  596.     emit_insn (gen_extendqihi2_no_power (operands[0], operands[1]));
  597.   DONE;
  598. }")
  599.  
  600. (define_insn "extendqihi2_ppc"
  601.   [(set (match_operand:HI 0 "gpc_reg_operand" "=r")
  602.     (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r")))]
  603.   "TARGET_POWERPC"
  604.   "extsb %0,%1")
  605.  
  606. (define_insn ""
  607.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  608.     (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
  609.             (const_int 0)))
  610.    (clobber (match_scratch:HI 2 "=r"))]
  611.   "TARGET_POWERPC"
  612.   "extsb. %2,%1"
  613.   [(set_attr "type" "compare")])
  614.  
  615. (define_insn ""
  616.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  617.     (compare:CC (sign_extend:HI (match_operand:QI 1 "gpc_reg_operand" "r"))
  618.             (const_int 0)))
  619.    (set (match_operand:HI 0 "gpc_reg_operand" "=r")
  620.     (sign_extend:HI (match_dup 1)))]
  621.   "TARGET_POWERPC"
  622.   "extsb. %0,%1"
  623.   [(set_attr "type" "compare")])
  624.  
  625. (define_expand "extendqihi2_power"
  626.   [(parallel [(set (match_dup 2)
  627.            (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  628.                   (const_int 24)))
  629.           (clobber (scratch:SI))])
  630.    (parallel [(set (match_operand:HI 0 "gpc_reg_operand" "")
  631.            (ashiftrt:SI (match_dup 2)
  632.                 (const_int 24)))
  633.           (clobber (scratch:SI))])]
  634.   "TARGET_POWER"
  635.   "
  636. { operands[0] = gen_lowpart (SImode, operands[0]);
  637.   operands[1] = gen_lowpart (SImode, operands[1]);
  638.   operands[2] = gen_reg_rtx (SImode); }")
  639.  
  640. (define_expand "extendqihi2_no_power"
  641.   [(set (match_dup 2)
  642.     (ashift:SI (match_operand:QI 1 "gpc_reg_operand" "")
  643.            (const_int 24)))
  644.    (set (match_operand:HI 0 "gpc_reg_operand" "")
  645.     (ashiftrt:SI (match_dup 2)
  646.              (const_int 24)))]
  647.   "! TARGET_POWER && ! TARGET_POWERPC"
  648.   "
  649. { operands[0] = gen_lowpart (SImode, operands[0]);
  650.   operands[1] = gen_lowpart (SImode, operands[1]);
  651.   operands[2] = gen_reg_rtx (SImode); }")
  652.  
  653. (define_expand "zero_extendhisi2"
  654.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  655.     (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
  656.   ""
  657.   "")
  658.  
  659. (define_insn ""
  660.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  661.     (zero_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  662.   ""
  663.   "@
  664.    lhz%U1%X1 %0,%1
  665.    {rlinm|rlwinm} %0,%1,0,0xffff"
  666.   [(set_attr "type" "load,*")])
  667.  
  668. (define_insn ""
  669.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  670.     (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  671.             (const_int 0)))
  672.    (clobber (match_scratch:SI 2 "=r"))]
  673.   ""
  674.   "{andil.|andi.} %2,%1,0xffff"
  675.   [(set_attr "type" "compare")])
  676.  
  677. (define_insn ""
  678.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  679.     (compare:CC (zero_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  680.             (const_int 0)))
  681.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  682.     (zero_extend:SI (match_dup 1)))]
  683.   ""
  684.   "{andil.|andi.} %0,%1,0xffff"
  685.   [(set_attr "type" "compare")])
  686.  
  687. (define_expand "extendhisi2"
  688.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  689.     (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "")))]
  690.   ""
  691.   "")
  692.  
  693. (define_insn ""
  694.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  695.     (sign_extend:SI (match_operand:HI 1 "reg_or_mem_operand" "m,r")))]
  696.   ""
  697.   "@
  698.    lha%U1%X1 %0,%1
  699.    {exts|extsh} %0,%1"
  700.   [(set_attr "type" "load,*")])
  701.  
  702. (define_insn ""
  703.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  704.     (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  705.             (const_int 0)))
  706.    (clobber (match_scratch:SI 2 "=r"))]
  707.   ""
  708.   "{exts.|extsh.} %2,%1"
  709.   [(set_attr "type" "compare")])
  710.  
  711. (define_insn ""
  712.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  713.     (compare:CC (sign_extend:SI (match_operand:HI 1 "gpc_reg_operand" "r"))
  714.             (const_int 0)))
  715.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  716.     (sign_extend:SI (match_dup 1)))]
  717.   ""
  718.   "{exts.|extsh.} %0,%1"
  719.   [(set_attr "type" "compare")])
  720.  
  721. ;; Fixed-point arithmetic insns.
  722.  
  723. ;; Discourage ai/addic because of carry but provide it in an alternative
  724. ;; allowing register zero as source.
  725. (define_insn "addsi3"
  726.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,?r,r")
  727.     (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,b,r,b")
  728.          (match_operand:SI 2 "add_operand" "r,I,I,J")))]
  729.   ""
  730.   "@
  731.    {cax|add} %0,%1,%2
  732.    {cal %0,%2(%1)|addi %0,%1,%2}
  733.    {ai|addic} %0,%1,%2
  734.    {cau|addis} %0,%1,%u2")
  735.  
  736. (define_insn ""
  737.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  738.     (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  739.                  (match_operand:SI 2 "reg_or_short_operand" "r,I"))
  740.             (const_int 0)))
  741.    (clobber (match_scratch:SI 3 "=r,r"))]
  742.   ""
  743.   "@
  744.    {cax.|add.} %3,%1,%2
  745.    {ai.|addic.} %3,%1,%2"
  746.   [(set_attr "type" "compare")])
  747.    
  748. (define_insn ""
  749.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  750.     (compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  751.                  (match_operand:SI 2 "reg_or_short_operand" "r,I"))
  752.             (const_int 0)))
  753.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  754.     (plus:SI (match_dup 1) (match_dup 2)))]
  755.   ""
  756.   "@
  757.    {cax.|add.} %0,%1,%2
  758.    {ai.|addic.} %0,%1,%2"
  759.   [(set_attr "type" "compare")])
  760.    
  761. ;; Split an add that we can't do in one insn into two insns, each of which
  762. ;; does one 16-bit part.  This is used by combine.  Note that the low-order
  763. ;; add should be last in case the result gets used in an address.
  764.  
  765. (define_split
  766.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  767.     (plus:SI (match_operand:SI 1 "gpc_reg_operand" "")
  768.          (match_operand:SI 2 "non_add_cint_operand" "")))]
  769.   ""
  770.   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
  771.    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
  772. "
  773. {
  774.   int low = INTVAL (operands[2]) & 0xffff;
  775.   int high = (unsigned) INTVAL (operands[2]) >> 16;
  776.  
  777.   if (low & 0x8000)
  778.     high++, low |= 0xffff0000;
  779.  
  780.   operands[3] = gen_rtx (CONST_INT, VOIDmode, high << 16);
  781.   operands[4] = gen_rtx (CONST_INT, VOIDmode, low);
  782. }")
  783.  
  784. (define_insn "one_cmplsi2"
  785.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  786.     (not:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  787.   ""
  788.   "nor %0,%1,%1")
  789.  
  790. (define_insn ""
  791.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  792.     (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  793.             (const_int 0)))
  794.    (clobber (match_scratch:SI 2 "=r"))]
  795.   ""
  796.   "nor. %2,%1,%1"
  797.   [(set_attr "type" "compare")])
  798.  
  799. (define_insn ""
  800.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  801.     (compare:CC (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  802.             (const_int 0)))
  803.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  804.     (not:SI (match_dup 1)))]
  805.   ""
  806.   "nor. %0,%2,%1"
  807.   [(set_attr "type" "compare")])
  808.  
  809. (define_insn ""
  810.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  811.     (minus:SI (match_operand:SI 1 "reg_or_short_operand" "rI")
  812.           (match_operand:SI 2 "gpc_reg_operand" "r")))]
  813.   "! TARGET_POWERPC"
  814.   "{sf%I1|subf%I1c} %0,%2,%1")
  815.  
  816. (define_insn ""
  817.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  818.     (minus:SI (match_operand:SI 1 "reg_or_short_operand" "r,I")
  819.           (match_operand:SI 2 "gpc_reg_operand" "r,r")))]
  820.   "TARGET_POWERPC"
  821.   "@
  822.    subf %0,%2,%1
  823.    subfic %0,%2,%1")
  824.  
  825. (define_insn ""
  826.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  827.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  828.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  829.             (const_int 0)))
  830.    (clobber (match_scratch:SI 3 "=r"))]
  831.   "! TARGET_POWERPC"
  832.   "{sf.|subfc.} %3,%2,%1"
  833.   [(set_attr "type" "compare")])
  834.  
  835. (define_insn ""
  836.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  837.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  838.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  839.             (const_int 0)))
  840.    (clobber (match_scratch:SI 3 "=r"))]
  841.   "TARGET_POWERPC"
  842.   "subf. %3,%2,%1"
  843.   [(set_attr "type" "compare")])
  844.  
  845. (define_insn ""
  846.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  847.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  848.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  849.             (const_int 0)))
  850.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  851.     (minus:SI (match_dup 1) (match_dup 2)))]
  852.   "! TARGET_POWERPC"
  853.   "{sf.|subfc.} %0,%2,%1"
  854.   [(set_attr "type" "compare")])
  855.  
  856. (define_insn ""
  857.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  858.     (compare:CC (minus:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  859.                   (match_operand:SI 2 "gpc_reg_operand" "r"))
  860.             (const_int 0)))
  861.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  862.     (minus:SI (match_dup 1) (match_dup 2)))]
  863.   "TARGET_POWERPC"
  864.   "subf. %0,%2,%1"
  865.   [(set_attr "type" "compare")])
  866.  
  867. (define_expand "subsi3"
  868.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  869.     (minus:SI (match_operand:SI 1 "reg_or_short_operand" "")
  870.           (match_operand:SI 2 "reg_or_cint_operand" "")))]
  871.   ""
  872.   "
  873. {
  874.   if (GET_CODE (operands[2]) == CONST_INT)
  875.     {
  876.       emit_insn (gen_addsi3 (operands[0], operands[1],
  877.                  negate_rtx (SImode, operands[2])));
  878.       DONE;
  879.     }
  880. }")
  881.  
  882. ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a doz[i]
  883. ;; instruction and some auxiliary computations.  Then we just have a single
  884. ;; DEFINE_INSN for doz[i] and the define_splits to make them if made by
  885. ;; combine.
  886.  
  887. (define_expand "sminsi3"
  888.   [(set (match_dup 3)
  889.     (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  890.                 (match_operand:SI 2 "reg_or_short_operand" ""))
  891.              (const_int 0)
  892.              (minus:SI (match_dup 2) (match_dup 1))))
  893.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  894.     (minus:SI (match_dup 2) (match_dup 3)))]
  895.   "TARGET_POWER"
  896.   "
  897. { operands[3] = gen_reg_rtx (SImode); }")
  898.  
  899. (define_split
  900.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  901.     (smin:SI (match_operand:SI 1 "gpc_reg_operand" "")
  902.          (match_operand:SI 2 "reg_or_short_operand" "")))
  903.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  904.   "TARGET_POWER"
  905.   [(set (match_dup 3)
  906.     (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
  907.              (const_int 0)
  908.              (minus:SI (match_dup 2) (match_dup 1))))
  909.    (set (match_dup 0) (minus:SI (match_dup 2) (match_dup 3)))]
  910.   "")
  911.  
  912. (define_expand "smaxsi3"
  913.   [(set (match_dup 3)
  914.     (if_then_else:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  915.                 (match_operand:SI 2 "reg_or_short_operand" ""))
  916.              (const_int 0)
  917.              (minus:SI (match_dup 2) (match_dup 1))))
  918.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  919.     (plus:SI (match_dup 3) (match_dup 1)))]
  920.   "TARGET_POWER"
  921.   "
  922. { operands[3] = gen_reg_rtx (SImode); }")
  923.  
  924. (define_split
  925.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  926.     (smax:SI (match_operand:SI 1 "gpc_reg_operand" "")
  927.          (match_operand:SI 2 "reg_or_short_operand" "")))
  928.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  929.   "TARGET_POWER"
  930.   [(set (match_dup 3)
  931.     (if_then_else:SI (gt:SI (match_dup 1) (match_dup 2))
  932.              (const_int 0)
  933.              (minus:SI (match_dup 2) (match_dup 1))))
  934.    (set (match_dup 0) (plus:SI (match_dup 3) (match_dup 1)))]
  935.   "")
  936.  
  937. (define_expand "uminsi3"
  938.   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  939.                   (const_int -2147483648)))
  940.    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
  941.                   (const_int -2147483648)))
  942.    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
  943.                        (const_int 0)
  944.                        (minus:SI (match_dup 4) (match_dup 3))))
  945.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  946.     (minus:SI (match_dup 2) (match_dup 3)))]
  947.   "TARGET_POWER"
  948.   "
  949. { operands[3] = gen_reg_rtx (SImode);  operands[4] = gen_reg_rtx (SImode); }")
  950.  
  951. (define_expand "umaxsi3"
  952.   [(set (match_dup 3) (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  953.                   (const_int -2147483648)))
  954.    (set (match_dup 4) (xor:SI (match_operand:SI 2 "gpc_reg_operand" "")
  955.                   (const_int -2147483648)))
  956.    (set (match_dup 3) (if_then_else:SI (gt (match_dup 3) (match_dup 4))
  957.                        (const_int 0)
  958.                        (minus:SI (match_dup 4) (match_dup 3))))
  959.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  960.     (plus:SI (match_dup 3) (match_dup 1)))]
  961.   "TARGET_POWER"
  962.   "
  963. { operands[3] = gen_reg_rtx (SImode);  operands[4] = gen_reg_rtx (SImode); }")
  964.  
  965. (define_insn ""
  966.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  967.     (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  968.                  (match_operand:SI 2 "reg_or_short_operand" "rI"))
  969.              (const_int 0)
  970.              (minus:SI (match_dup 2) (match_dup 1))))]
  971.   "TARGET_POWER"
  972.   "doz%I2 %0,%1,%2")
  973.  
  974. (define_insn ""
  975.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  976.     (compare:CC
  977.      (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  978.                   (match_operand:SI 2 "reg_or_short_operand" "rI"))
  979.               (const_int 0)
  980.               (minus:SI (match_dup 2) (match_dup 1)))
  981.      (const_int 0)))
  982.    (clobber (match_scratch:SI 3 "=r"))]
  983.   "TARGET_POWER"
  984.   "doz%I2. %3,%1,%2"
  985.   [(set_attr "type" "delayed_compare")])
  986.  
  987. (define_insn ""
  988.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  989.     (compare:CC
  990.      (if_then_else:SI (gt (match_operand:SI 1 "gpc_reg_operand" "r")
  991.                   (match_operand:SI 2 "reg_or_short_operand" "rI"))
  992.               (const_int 0)
  993.               (minus:SI (match_dup 2) (match_dup 1)))
  994.      (const_int 0)))
  995.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  996.     (if_then_else:SI (gt (match_dup 1) (match_dup 2))
  997.              (const_int 0)
  998.              (minus:SI (match_dup 2) (match_dup 1))))]
  999.   "TARGET_POWER"
  1000.   "doz%I2. %0,%1,%2"
  1001.   [(set_attr "type" "delayed_compare")])
  1002.  
  1003. ;; We don't need abs with condition code because such comparisons should
  1004. ;; never be done.
  1005. (define_insn "abssi2"
  1006.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1007.     (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  1008.   "TARGET_POWER"
  1009.   "abs %0,%1")
  1010.  
  1011. (define_insn ""
  1012.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1013.     (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r"))))]
  1014.   "TARGET_POWER"
  1015.   "nabs %0,%1")
  1016.  
  1017. (define_insn "negsi2"
  1018.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1019.     (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r")))]
  1020.   ""
  1021.   "neg %0,%1")
  1022.  
  1023. (define_insn ""
  1024.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1025.     (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1026.             (const_int 0)))
  1027.    (clobber (match_scratch:SI 2 "=r"))]
  1028.   ""
  1029.   "neg. %2,%1"
  1030.   [(set_attr "type" "compare")])
  1031.  
  1032. (define_insn ""
  1033.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  1034.     (compare:CC (neg:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1035.             (const_int 0)))
  1036.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1037.     (neg:SI (match_dup 1)))]
  1038.   ""
  1039.   "neg. %0,%1"
  1040.   [(set_attr "type" "compare")])
  1041.  
  1042. (define_insn "ffssi2"
  1043.   [(set (match_operand:SI 0 "register_operand" "=&r")
  1044.     (ffs:SI (match_operand:SI 1 "register_operand" "r")))]
  1045.   ""
  1046.   "neg %0,%1\;and %0,%0,%1\;{cntlz|cntlzw} %0,%0\;{sfi|subfic} %0,%0,32"
  1047.   [(set_attr "length" "16")])
  1048.  
  1049. (define_expand "mulsi3"
  1050.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  1051.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  1052.    (use (match_operand:SI 2 "reg_or_short_operand" ""))]
  1053.   ""
  1054.   "
  1055. {
  1056.   if (TARGET_POWER)
  1057.     emit_insn (gen_mulsi3_mq (operands[0], operands[1], operands[2]));
  1058.   else
  1059.     emit_insn (gen_mulsi3_no_mq (operands[0], operands[1], operands[2]));
  1060.   DONE;
  1061. }")
  1062.  
  1063. (define_insn "mulsi3_mq"
  1064.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1065.     (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  1066.          (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  1067.    (clobber (match_scratch:SI 3 "=q,q"))]
  1068.   "TARGET_POWER"
  1069.   "@
  1070.    {muls|mullw} %0,%1,%2
  1071.    {muli|mulli} %0,%1,%2"
  1072.    [(set_attr "type" "imul")])
  1073.  
  1074. (define_insn "mulsi3_no_mq"
  1075.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  1076.     (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r")
  1077.          (match_operand:SI 2 "reg_or_short_operand" "r,I")))]
  1078.   "! TARGET_POWER"
  1079.   "@
  1080.    mullw %0,%1,%2
  1081.    mulli %0,%1,%2"
  1082.    [(set_attr "type" "imul")])
  1083.  
  1084. (define_insn ""
  1085.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1086.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1087.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  1088.             (const_int 0)))
  1089.    (clobber (match_scratch:SI 3 "=r"))
  1090.    (clobber (match_scratch:SI 4 "=q"))]
  1091.   "TARGET_POWER"
  1092.   "{muls.|mullw.} %3,%1,%2"
  1093.   [(set_attr "type" "delayed_compare")])
  1094.  
  1095. (define_insn ""
  1096.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1097.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1098.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  1099.             (const_int 0)))
  1100.    (clobber (match_scratch:SI 3 "=r"))]
  1101.   "! TARGET_POWER"
  1102.   "mullw. %3,%1,%2"
  1103.   [(set_attr "type" "delayed_compare")])
  1104.  
  1105. (define_insn ""
  1106.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1107.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1108.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  1109.             (const_int 0)))
  1110.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1111.     (mult:SI (match_dup 1) (match_dup 2)))
  1112.    (clobber (match_scratch:SI 4 "=q"))]
  1113.   "TARGET_POWER"
  1114.   "{muls.|mullw.} %0,%1,%2"
  1115.   [(set_attr "type" "delayed_compare")])
  1116.  
  1117. (define_insn ""
  1118.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1119.     (compare:CC (mult:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1120.                  (match_operand:SI 2 "gpc_reg_operand" "r"))
  1121.             (const_int 0)))
  1122.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1123.     (mult:SI (match_dup 1) (match_dup 2)))]
  1124.   "! TARGET_POWER"
  1125.   "mullw. %0,%1,%2"
  1126.   [(set_attr "type" "delayed_compare")])
  1127.  
  1128. ;; Operand 1 is divided by operand 2; quotient goes to operand
  1129. ;; 0 and remainder to operand 3.
  1130. ;; ??? At some point, see what, if anything, we can do about if (x % y == 0).
  1131.  
  1132. (define_expand "divmodsi4"
  1133.   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1134.            (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1135.                (match_operand:SI 2 "gpc_reg_operand" "")))
  1136.           (set (match_operand:SI 3 "gpc_reg_operand" "")
  1137.            (mod:SI (match_dup 1) (match_dup 2)))])]
  1138.   "TARGET_POWER || (! TARGET_POWER && ! TARGET_POWERPC)"
  1139.   "
  1140. {
  1141.   if (! TARGET_POWER && ! TARGET_POWERPC)
  1142.     {
  1143.       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  1144.       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  1145.       emit_insn (gen_divss_call ());
  1146.       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
  1147.       emit_move_insn (operands[3], gen_rtx (REG, SImode, 4));
  1148.       DONE;
  1149.     }
  1150. }")
  1151.  
  1152. (define_insn ""
  1153.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1154.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1155.         (match_operand:SI 2 "gpc_reg_operand" "r")))
  1156.    (set (match_operand:SI 3 "gpc_reg_operand" "=q")
  1157.     (mod:SI (match_dup 1) (match_dup 2)))]
  1158.   "TARGET_POWER"
  1159.   "divs %0,%1,%2"
  1160.   [(set_attr "type" "idiv")])
  1161.  
  1162. (define_insn ""
  1163.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1164.         (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1165.                 (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1166.   "TARGET_POWERPC"
  1167.   "divw %0,%1,%2"
  1168.   [(set_attr "type" "idiv")])
  1169.  
  1170. (define_expand "udivsi3"
  1171.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1172.         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1173.                  (match_operand:SI 2 "gpc_reg_operand" "")))]
  1174.   "TARGET_POWERPC || (! TARGET_POWER && ! TARGET_POWERPC)"
  1175.   "
  1176. {
  1177.   if (! TARGET_POWER && ! TARGET_POWERPC)
  1178.     {
  1179.       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  1180.       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  1181.       emit_insn (gen_quous_call ());
  1182.       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
  1183.       DONE;
  1184.     }
  1185. }")
  1186.  
  1187. (define_insn ""
  1188.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1189.         (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1190.                  (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1191.   "TARGET_POWERPC"
  1192.   "divwu %0,%1,%2"
  1193.   [(set_attr "type" "idiv")])
  1194.  
  1195. ;; For powers of two we can do srai/aze for divide and then adjust for
  1196. ;; modulus.  If it isn't a power of two, FAIL on POWER so divmodsi4 will be
  1197. ;; used; for PowerPC, force operands into register and do a normal divide;
  1198. ;; for AIX common-mode, use quoss call on register operands.
  1199. (define_expand "divsi3"
  1200.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1201.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1202.         (match_operand:SI 2 "reg_or_cint_operand" "")))]
  1203.   ""
  1204.   "
  1205. {
  1206.   if (GET_CODE (operands[2]) == CONST_INT
  1207.       && exact_log2 (INTVAL (operands[2])) >= 0)
  1208.     ;
  1209.   else if (TARGET_POWER && ! TARGET_POWERPC)
  1210.     FAIL;
  1211.   else
  1212.     operands[2] = force_reg (SImode, operands[2]);
  1213.  
  1214.   if (! TARGET_POWER && ! TARGET_POWERPC)
  1215.     {
  1216.       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  1217.       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  1218.       emit_insn (gen_quoss_call ());
  1219.       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
  1220.       DONE;
  1221.     }
  1222. }")
  1223.  
  1224. (define_expand "modsi3"
  1225.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  1226.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  1227.    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
  1228.   ""
  1229.   "
  1230. {
  1231.   int i = exact_log2 (INTVAL (operands[2]));
  1232.   rtx temp1;
  1233.   rtx temp2;
  1234.  
  1235.   if (GET_CODE (operands[2]) != CONST_INT || i < 0)
  1236.     FAIL;
  1237.  
  1238.   temp1 = gen_reg_rtx (SImode);
  1239.   temp2 = gen_reg_rtx (SImode);
  1240.  
  1241.   emit_insn (gen_divsi3 (temp1, operands[1], operands[2]));
  1242.   emit_insn (gen_ashlsi3 (temp2, temp1, GEN_INT (i)));
  1243.   emit_insn (gen_subsi3 (operands[0], operands[1], temp2));
  1244.   DONE;
  1245. }")
  1246.  
  1247. (define_insn ""
  1248.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1249.     (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1250.         (match_operand:SI 2 "const_int_operand" "N")))]
  1251.   "exact_log2 (INTVAL (operands[2])) >= 0"
  1252.   "{srai|srawi} %0,%1,%p2\;{aze|addze} %0,%0"
  1253.   [(set_attr "length" "8")])
  1254.  
  1255. (define_insn ""
  1256.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1257.     (compare:CC (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1258.                 (match_operand:SI 2 "const_int_operand" "N"))
  1259.             (const_int 0)))
  1260.    (clobber (match_scratch:SI 3 "=r"))]
  1261.   "exact_log2 (INTVAL (operands[2])) >= 0"
  1262.   "{srai|srawi} %3,%1,%p2\;{aze.|addze.} %3,%3"
  1263.   [(set_attr "type" "compare")
  1264.    (set_attr "length" "8")])
  1265.  
  1266. (define_insn ""
  1267.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1268.     (compare:CC (div:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1269.                 (match_operand:SI 2 "const_int_operand" "N"))
  1270.             (const_int 0)))
  1271.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1272.     (div:SI (match_dup 1) (match_dup 2)))]
  1273.   "exact_log2 (INTVAL (operands[2])) >= 0"
  1274.   "{srai|srawi} %0,%1,%p2\;{aze.|addze.} %0,%0"
  1275.   [(set_attr "type" "compare")
  1276.    (set_attr "length" "8")])
  1277.  
  1278. (define_insn ""
  1279.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1280.     (udiv:SI
  1281.      (plus:DI (ashift:DI
  1282.            (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1283.            (const_int 32))
  1284.           (zero_extend:DI (match_operand:SI 4 "register_operand" "2")))
  1285.      (match_operand:SI 3 "gpc_reg_operand" "r")))
  1286.    (set (match_operand:SI 2 "register_operand" "=*q")
  1287.     (umod:SI
  1288.      (plus:DI (ashift:DI
  1289.            (zero_extend:DI (match_dup 1)) (const_int 32))
  1290.           (zero_extend:DI (match_dup 4)))
  1291.      (match_dup 3)))]
  1292.   
  1293.   "TARGET_POWER"
  1294.   "div %0,%1,%3"
  1295.   [(set_attr "type" "idiv")])
  1296.  
  1297. ;; To do unsigned divide we handle the cases of the divisor looking like a
  1298. ;; negative number.  If it is a constant that is less than 2**31, we don't
  1299. ;; have to worry about the branches.  So make a few subroutines here.
  1300. ;;
  1301. ;; First comes the normal case.
  1302. (define_expand "udivmodsi4_normal"
  1303.   [(set (match_dup 4) (const_int 0))
  1304.    (parallel [(set (match_operand:SI 0 "" "")
  1305.            (udiv:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
  1306.                         (const_int 32))
  1307.                      (zero_extend:DI (match_operand:SI 1 "" "")))
  1308.                 (match_operand:SI 2 "" "")))
  1309.           (set (match_operand:SI 3 "" "")
  1310.            (umod:SI (plus:DI (ashift:DI (zero_extend:DI (match_dup 4))
  1311.                         (const_int 32))
  1312.                      (zero_extend:DI (match_dup 1)))
  1313.                 (match_dup 2)))])]
  1314.   "TARGET_POWER"
  1315.   "
  1316. { operands[4] = gen_reg_rtx (SImode); }")
  1317.  
  1318. ;; This handles the branches.
  1319. (define_expand "udivmodsi4_tests"
  1320.   [(set (match_operand:SI 0 "" "") (const_int 0))
  1321.    (set (match_operand:SI 3 "" "") (match_operand:SI 1 "" ""))
  1322.    (set (match_dup 5) (compare:CCUNS (match_dup 1) (match_operand:SI 2 "" "")))
  1323.    (set (pc) (if_then_else (ltu (match_dup 5) (const_int 0))
  1324.                (label_ref (match_operand:SI 4 "" "")) (pc)))
  1325.    (set (match_dup 0) (const_int 1))
  1326.    (set (match_dup 3) (minus:SI (match_dup 1) (match_dup 2)))
  1327.    (set (match_dup 6) (compare:CC (match_dup 2) (const_int 0)))
  1328.    (set (pc) (if_then_else (lt (match_dup 6) (const_int 0))
  1329.                (label_ref (match_dup 4)) (pc)))]
  1330.   "TARGET_POWER"
  1331.   "
  1332. { operands[5] = gen_reg_rtx (CCUNSmode);
  1333.   operands[6] = gen_reg_rtx (CCmode);
  1334. }")
  1335.  
  1336. (define_expand "udivmodsi4"
  1337.   [(parallel [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1338.            (udiv:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1339.                 (match_operand:SI 2 "reg_or_cint_operand" "")))
  1340.           (set (match_operand:SI 3 "gpc_reg_operand" "")
  1341.            (umod:SI (match_dup 1) (match_dup 2)))])]
  1342.   ""
  1343.   "
  1344. {
  1345.   rtx label = 0;
  1346.  
  1347.   if (! TARGET_POWER)
  1348.     if (! TARGET_POWERPC)
  1349.       {
  1350.     emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  1351.     emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  1352.     emit_insn (gen_divus_call ());
  1353.     emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
  1354.     emit_move_insn (operands[3], gen_rtx (REG, SImode, 4));
  1355.     DONE;
  1356.       }
  1357.     else
  1358.       FAIL;
  1359.  
  1360.   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 0)
  1361.     {
  1362.       operands[2] = force_reg (SImode, operands[2]);
  1363.       label = gen_label_rtx ();
  1364.       emit (gen_udivmodsi4_tests (operands[0], operands[1], operands[2],
  1365.                   operands[3], label));
  1366.     }
  1367.   else
  1368.     operands[2] = force_reg (SImode, operands[2]);
  1369.  
  1370.   emit (gen_udivmodsi4_normal (operands[0], operands[1], operands[2],
  1371.                    operands[3]));
  1372.   if (label)
  1373.     emit_label (label);
  1374.  
  1375.   DONE;
  1376. }")
  1377.  
  1378. ;; AIX architecture-independent common-mode multiply (DImode),
  1379. ;; divide/modulus, and quotient subroutine calls.  Input operands in R3 and
  1380. ;; R4; results in R3 and somtimes R4; link register always clobbered by bla
  1381. ;; instruction; R0 sometimes clobbered; also, MQ sometimes clobbered but
  1382. ;; assumed unused if generating common-mode, so ignore.
  1383. (define_insn "mulh_call"
  1384.   [(set (reg:SI 3)
  1385.     (truncate:SI
  1386.      (lshiftrt:DI (mult:DI (sign_extend:DI (reg:SI 3))
  1387.                    (sign_extend:DI (reg:SI 4)))
  1388.               (const_int 32))))
  1389.    (clobber (match_scratch:SI 0 "=l"))]
  1390.   "! TARGET_POWER && ! TARGET_POWERPC"
  1391.   "bla __mulh")
  1392.  
  1393. (define_insn "mull_call"
  1394.   [(set (reg:DI 3)
  1395.     (mult:DI (sign_extend:DI (reg:SI 3))
  1396.          (sign_extend:DI (reg:SI 4))))
  1397.    (clobber (match_scratch:SI 0 "=l"))
  1398.    (clobber (reg:SI 0))]
  1399.   "! TARGET_POWER && ! TARGET_POWERPC"
  1400.   "bla __mull")
  1401.  
  1402. (define_insn "divss_call"
  1403.   [(set (reg:SI 3)
  1404.     (div:SI (reg:SI 3) (reg:SI 4)))
  1405.    (set (reg:SI 4)
  1406.     (mod:SI (reg:SI 3) (reg:SI 4)))
  1407.    (clobber (match_scratch:SI 0 "=l"))
  1408.    (clobber (reg:SI 0))]
  1409.   "! TARGET_POWER && ! TARGET_POWERPC"
  1410.   "bla __divss")
  1411.  
  1412. (define_insn "divus_call"
  1413.   [(set (reg:SI 3)
  1414.     (udiv:SI (reg:SI 3) (reg:SI 4)))
  1415.    (set (reg:SI 4)
  1416.     (umod:SI (reg:SI 3) (reg:SI 4)))
  1417.    (clobber (match_scratch:SI 0 "=l"))
  1418.    (clobber (reg:SI 0))]
  1419.   "! TARGET_POWER && ! TARGET_POWERPC"
  1420.   "bla __divus")
  1421.  
  1422. (define_insn "quoss_call"
  1423.   [(set (reg:SI 3)
  1424.     (div:SI (reg:SI 3) (reg:SI 4)))
  1425.    (clobber (match_scratch:SI 0 "=l"))]
  1426.   "! TARGET_POWER && ! TARGET_POWERPC"
  1427.   "bla __quoss")
  1428.  
  1429. (define_insn "quous_call"
  1430.   [(set (reg:SI 3)
  1431.     (udiv:SI (reg:SI 3) (reg:SI 4)))
  1432.    (clobber (match_scratch:SI 0 "=l"))
  1433.    (clobber (reg:SI 0))]
  1434.   "! TARGET_POWER && ! TARGET_POWERPC"
  1435.   "bla __quous")
  1436.  
  1437. (define_insn "andsi3"
  1438.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  1439.     (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  1440.         (match_operand:SI 2 "and_operand" "?r,L,K,J")))
  1441.    (clobber (match_scratch:CC 3 "=X,X,x,x"))]
  1442.   ""
  1443.   "@
  1444.    and %0,%1,%2
  1445.    {rlinm|rlwinm} %0,%1,0,%m2,%M2
  1446.    {andil.|andi.} %0,%1,%b2
  1447.    {andiu.|andis.} %0,%1,%u2")
  1448.  
  1449. (define_insn ""
  1450.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x")
  1451.     (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  1452.                 (match_operand:SI 2 "and_operand" "r,K,J,L"))
  1453.             (const_int 0)))
  1454.    (clobber (match_scratch:SI 3 "=r,r,r,r"))]
  1455.   ""
  1456.   "@
  1457.    and. %3,%1,%2
  1458.    {andil.|andi.} %3,%1,%b2
  1459.    {andiu.|andis.} %3,%1,%u2
  1460.    {rlinm.|rlwinm.} %3,%1,0,%m2,%M2"
  1461.   [(set_attr "type" "compare,compare,compare,delayed_compare")])
  1462.  
  1463. (define_insn ""
  1464.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x,x,x")
  1465.     (compare:CC (and:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
  1466.                 (match_operand:SI 2 "and_operand" "r,K,J,L"))
  1467.             (const_int 0)))
  1468.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  1469.     (and:SI (match_dup 1) (match_dup 2)))]
  1470.   ""
  1471.   "@
  1472.    and. %0,%1,%2
  1473.    {andil.|andi.} %0,%1,%b2
  1474.    {andiu.|andis.} %0,%1,%u2
  1475.    {rlinm.|rlwinm.} %0,%1,0,%m2,%M2"
  1476.   [(set_attr "type" "compare,compare,compare,delayed_compare")])
  1477.  
  1478. ;; Take a AND with a constant that cannot be done in a single insn and try to
  1479. ;; split it into two insns.  This does not verify that the insns are valid
  1480. ;; since this need not be done as combine will do it.
  1481.  
  1482. (define_split
  1483.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1484.     (and:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1485.         (match_operand:SI 2 "non_and_cint_operand" "")))]
  1486.   ""
  1487.   [(set (match_dup 0) (and:SI (match_dup 1) (match_dup 3)))
  1488.    (set (match_dup 0) (and:SI (match_dup 0) (match_dup 4)))]
  1489.   "
  1490. {
  1491.   int maskval = INTVAL (operands[2]);
  1492.   int i, transitions, last_bit_value;
  1493.   int orig = maskval, first_c = maskval, second_c;
  1494.  
  1495.   /* We know that MASKVAL must have more than 2 bit-transitions.  Start at
  1496.      the low-order bit and count for the third transition.  When we get there,
  1497.      make a first mask that has everything to the left of that position
  1498.      a one.  Then make the second mask to turn off whatever else is needed.  */
  1499.  
  1500.   for (i = 1, transitions = 0, last_bit_value = maskval & 1; i < 32; i++)
  1501.     {
  1502.       if (((maskval >>= 1) & 1) != last_bit_value)
  1503.     last_bit_value ^= 1, transitions++;
  1504.  
  1505.       if (transitions > 2)
  1506.     {
  1507.       first_c |= (~0) << i;
  1508.       break;
  1509.     }
  1510.     }
  1511.  
  1512.   second_c = orig | ~ first_c;
  1513.  
  1514.   operands[3] = gen_rtx (CONST_INT, VOIDmode, first_c);
  1515.   operands[4] = gen_rtx (CONST_INT, VOIDmode, second_c);
  1516. }")
  1517.  
  1518. (define_insn "iorsi3"
  1519.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  1520.     (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
  1521.         (match_operand:SI 2 "logical_operand" "r,K,J")))]
  1522.   ""
  1523.   "@
  1524.    or %0,%1,%2
  1525.    {oril|ori} %0,%1,%b2
  1526.    {oriu|oris} %0,%1,%u2")
  1527.  
  1528. (define_insn ""
  1529.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1530.     (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1531.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1532.             (const_int 0)))
  1533.    (clobber (match_scratch:SI 3 "=r"))]
  1534.   ""
  1535.   "or. %3,%1,%2"
  1536.   [(set_attr "type" "compare")])
  1537.  
  1538. (define_insn ""
  1539.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1540.     (compare:CC (ior:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1541.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1542.             (const_int 0)))
  1543.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1544.     (ior:SI (match_dup 1) (match_dup 2)))]
  1545.   ""
  1546.   "or. %0,%1,%2"
  1547.   [(set_attr "type" "compare")])
  1548.  
  1549. ;; Split an IOR that we can't do in one insn into two insns, each of which
  1550. ;; does one 16-bit part.  This is used by combine.
  1551.  
  1552. (define_split
  1553.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1554.     (ior:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1555.         (match_operand:SI 2 "non_logical_cint_operand" "")))]
  1556.   ""
  1557.   [(set (match_dup 0) (ior:SI (match_dup 1) (match_dup 3)))
  1558.    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 4)))]
  1559. "
  1560. {
  1561.   operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1562.              INTVAL (operands[2]) & 0xffff0000);
  1563.   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
  1564. }")
  1565.  
  1566. (define_insn "xorsi3"
  1567.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  1568.     (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r")
  1569.         (match_operand:SI 2 "logical_operand" "r,K,J")))]
  1570.   ""
  1571.   "@
  1572.    xor %0,%1,%2
  1573.    {xoril|xori} %0,%1,%b2
  1574.    {xoriu|xoris} %0,%1,%u2")
  1575.  
  1576. (define_insn ""
  1577.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1578.     (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1579.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1580.             (const_int 0)))
  1581.    (clobber (match_scratch:SI 3 "=r"))]
  1582.   ""
  1583.   "xor. %3,%1,%2"
  1584.   [(set_attr "type" "compare")])
  1585.  
  1586. (define_insn ""
  1587.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1588.     (compare:CC (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1589.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1590.             (const_int 0)))
  1591.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1592.     (xor:SI (match_dup 1) (match_dup 2)))]
  1593.   ""
  1594.   "xor. %0,%1,%2"
  1595.   [(set_attr "type" "compare")])
  1596.  
  1597. ;; Split an XOR that we can't do in one insn into two insns, each of which
  1598. ;; does one 16-bit part.  This is used by combine.
  1599.  
  1600. (define_split
  1601.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  1602.     (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  1603.         (match_operand:SI 2 "non_logical_cint_operand" "")))]
  1604.   ""
  1605.   [(set (match_dup 0) (xor:SI (match_dup 1) (match_dup 3)))
  1606.    (set (match_dup 0) (xor:SI (match_dup 0) (match_dup 4)))]
  1607. "
  1608. {
  1609.   operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1610.              INTVAL (operands[2]) & 0xffff0000);
  1611.   operands[4] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[2]) & 0xffff);
  1612. }")
  1613.  
  1614. (define_insn ""
  1615.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1616.     (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1617.             (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1618.    ""
  1619.    "eqv %0,%1,%2")
  1620.  
  1621. (define_insn ""
  1622.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1623.     (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1624.                     (match_operand:SI 2 "gpc_reg_operand" "r")))
  1625.             (const_int 0)))
  1626.    (clobber (match_scratch:SI 3 "=r"))]
  1627.    ""
  1628.    "eqv. %3,%1,%2"
  1629.    [(set_attr "type" "compare")])
  1630.  
  1631. (define_insn ""
  1632.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1633.     (compare:CC (not:SI (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  1634.                     (match_operand:SI 2 "gpc_reg_operand" "r")))
  1635.             (const_int 0)))
  1636.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1637.     (not:SI (xor:SI (match_dup 1) (match_dup 2))))]
  1638.    ""
  1639.    "eqv. %0,%1,%2"
  1640.    [(set_attr "type" "compare")])
  1641.  
  1642. (define_insn ""
  1643.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1644.     (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1645.         (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1646.   ""
  1647.   "andc %0,%2,%1")
  1648.  
  1649. (define_insn ""
  1650.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1651.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1652.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1653.             (const_int 0)))
  1654.    (clobber (match_scratch:SI 3 "=r"))]
  1655.   ""
  1656.   "andc. %3,%2,%1"
  1657.   [(set_attr "type" "compare")])
  1658.  
  1659. (define_insn ""
  1660.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1661.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1662.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1663.             (const_int 0)))
  1664.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1665.     (and:SI (not:SI (match_dup 1)) (match_dup 2)))]
  1666.   ""
  1667.   "andc. %0,%2,%1"
  1668.   [(set_attr "type" "compare")])
  1669.  
  1670. (define_insn ""
  1671.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1672.     (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1673.         (match_operand:SI 2 "gpc_reg_operand" "r")))]
  1674.   ""
  1675.   "orc %0,%2,%1")
  1676.  
  1677. (define_insn ""
  1678.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1679.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1680.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1681.             (const_int 0)))
  1682.    (clobber (match_scratch:SI 3 "=r"))]
  1683.   ""
  1684.   "orc. %3,%2,%1"
  1685.   [(set_attr "type" "compare")])
  1686.  
  1687. (define_insn ""
  1688.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1689.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  1690.                 (match_operand:SI 2 "gpc_reg_operand" "r"))
  1691.             (const_int 0)))
  1692.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1693.     (ior:SI (not:SI (match_dup 1)) (match_dup 2)))]
  1694.   ""
  1695.   "orc. %0,%2,%1"
  1696.   [(set_attr "type" "compare")])
  1697.  
  1698. (define_insn ""
  1699.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1700.     (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1701.         (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1702.   ""
  1703.   "nand %0,%1,%2")
  1704.  
  1705. (define_insn ""
  1706.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1707.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1708.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1709.             (const_int 0)))
  1710.    (clobber (match_scratch:SI 3 "=r"))]
  1711.   ""
  1712.   "nand. %3,%1,%2"
  1713.   [(set_attr "type" "compare")])
  1714.  
  1715. (define_insn ""
  1716.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1717.     (compare:CC (ior:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1718.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1719.             (const_int 0)))
  1720.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1721.     (ior:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
  1722.   ""
  1723.   "nand. %0,%1,%2"
  1724.   [(set_attr "type" "compare")])
  1725.  
  1726. (define_insn ""
  1727.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1728.     (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1729.         (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  1730.   ""
  1731.   "nor %0,%1,%2")
  1732.  
  1733. (define_insn ""
  1734.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1735.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1736.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1737.             (const_int 0)))
  1738.    (clobber (match_scratch:SI 3 "=r"))]
  1739.   ""
  1740.   "nor. %3,%1,%2"
  1741.   [(set_attr "type" "compare")])
  1742.  
  1743. (define_insn ""
  1744.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1745.     (compare:CC (and:SI (not:SI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  1746.                 (not:SI (match_operand:SI 2 "gpc_reg_operand" "r")))
  1747.             (const_int 0)))
  1748.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1749.     (and:SI (not:SI (match_dup 1)) (not:SI (match_dup 2))))]
  1750.   ""
  1751.   "nor. %0,%1,%2"
  1752.   [(set_attr "type" "compare")])
  1753.  
  1754. ;; maskir insn.  We need four forms because things might be in arbitrary
  1755. ;; orders.  Don't define forms that only set CR fields because these
  1756. ;; would modify an input register.
  1757.  
  1758. (define_insn ""
  1759.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1760.     (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1761.             (match_operand:SI 1 "gpc_reg_operand" "0"))
  1762.         (and:SI (match_dup 2)
  1763.             (match_operand:SI 3 "gpc_reg_operand" "r"))))]
  1764.   "TARGET_POWER"
  1765.   "maskir %0,%3,%2")
  1766.  
  1767. (define_insn ""
  1768.   [(set (match_operand:SI 0 "register_operand" "=r")
  1769.     (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1770.             (match_operand:SI 1 "gpc_reg_operand" "0"))
  1771.         (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1772.             (match_dup 2))))]
  1773.   "TARGET_POWER"
  1774.   "maskir %0,%3,%2")
  1775.  
  1776. (define_insn ""
  1777.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1778.     (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1779.             (match_operand:SI 3 "gpc_reg_operand" "r"))
  1780.         (and:SI (not:SI (match_dup 2))
  1781.             (match_operand:SI 1 "gpc_reg_operand" "0"))))]
  1782.   "TARGET_POWER"
  1783.   "maskir %0,%3,%2")
  1784.  
  1785. (define_insn ""
  1786.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1787.     (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1788.             (match_operand:SI 2 "gpc_reg_operand" "r"))
  1789.         (and:SI (not:SI (match_dup 2))
  1790.             (match_operand:SI 1 "gpc_reg_operand" "0"))))]
  1791.   "TARGET_POWER"
  1792.   "maskir %0,%3,%2")
  1793.  
  1794. (define_insn ""
  1795.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1796.     (compare:CC
  1797.      (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1798.              (match_operand:SI 1 "gpc_reg_operand" "0"))
  1799.          (and:SI (match_dup 2)
  1800.              (match_operand:SI 3 "gpc_reg_operand" "r")))
  1801.      (const_int 0)))
  1802.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1803.     (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
  1804.         (and:SI (match_dup 2) (match_dup 3))))]
  1805.   "TARGET_POWER"
  1806.   "maskir. %0,%3,%2"
  1807.   [(set_attr "type" "compare")])
  1808.  
  1809. (define_insn ""
  1810.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1811.     (compare:CC
  1812.      (ior:SI (and:SI (not:SI (match_operand:SI 2 "gpc_reg_operand" "r"))
  1813.              (match_operand:SI 1 "gpc_reg_operand" "0"))
  1814.          (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1815.              (match_dup 2)))
  1816.      (const_int 0)))
  1817.    (set (match_operand:SI 0 "register_operand" "=r")
  1818.     (ior:SI (and:SI (not:SI (match_dup 2)) (match_dup 1))
  1819.         (and:SI (match_dup 3) (match_dup 2))))]
  1820.   "TARGET_POWER"
  1821.   "maskir. %0,%3,%2"
  1822.   [(set_attr "type" "compare")])
  1823.  
  1824. (define_insn ""
  1825.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1826.     (compare:CC
  1827.      (ior:SI (and:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  1828.              (match_operand:SI 3 "gpc_reg_operand" "r"))
  1829.          (and:SI (not:SI (match_dup 2))
  1830.              (match_operand:SI 1 "gpc_reg_operand" "0")))
  1831.      (const_int 0)))
  1832.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1833.     (ior:SI (and:SI (match_dup 2) (match_dup 3))
  1834.         (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
  1835.   "TARGET_POWER"
  1836.   "maskir. %0,%3,%2"
  1837.   [(set_attr "type" "compare")])
  1838.  
  1839. (define_insn ""
  1840.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1841.     (compare:CC
  1842.      (ior:SI (and:SI (match_operand:SI 3 "gpc_reg_operand" "r")
  1843.              (match_operand:SI 2 "gpc_reg_operand" "r"))
  1844.          (and:SI (not:SI (match_dup 2))
  1845.              (match_operand:SI 1 "gpc_reg_operand" "0")))
  1846.      (const_int 0)))
  1847.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1848.     (ior:SI (and:SI (match_dup 3) (match_dup 2))
  1849.         (and:SI (not:SI (match_dup 2)) (match_dup 1))))]
  1850.   "TARGET_POWER"
  1851.   "maskir. %0,%3,%2"
  1852.   [(set_attr "type" "compare")])
  1853.  
  1854. ;; Rotate and shift insns, in all their variants.  These support shifts,
  1855. ;; field inserts and extracts, and various combinations thereof.
  1856. (define_insn "insv"
  1857.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  1858.              (match_operand:SI 1 "const_int_operand" "i")
  1859.              (match_operand:SI 2 "const_int_operand" "i"))
  1860.     (match_operand:SI 3 "gpc_reg_operand" "r"))]
  1861.   ""
  1862.   "*
  1863. {
  1864.   int start = INTVAL (operands[2]) & 31;
  1865.   int size = INTVAL (operands[1]) & 31;
  1866.  
  1867.   operands[4] = gen_rtx (CONST_INT, VOIDmode, 32 - start - size);
  1868.   operands[1] = gen_rtx (CONST_INT, VOIDmode, start + size - 1);
  1869.   return \"{rlimi|rlwimi} %0,%3,%4,%h2,%h1\";
  1870. }")
  1871.  
  1872. (define_insn "extzv"
  1873.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1874.     (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1875.              (match_operand:SI 2 "const_int_operand" "i")
  1876.              (match_operand:SI 3 "const_int_operand" "i")))]
  1877.   ""
  1878.   "*
  1879. {
  1880.   int start = INTVAL (operands[3]) & 31;
  1881.   int size = INTVAL (operands[2]) & 31;
  1882.  
  1883.   if (start + size >= 32)
  1884.     operands[3] = const0_rtx;
  1885.   else
  1886.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1887.   return \"{rlinm|rlwinm} %0,%1,%3,%s2,31\";
  1888. }")
  1889.  
  1890. (define_insn ""
  1891.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1892.     (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1893.              (match_operand:SI 2 "const_int_operand" "i")
  1894.              (match_operand:SI 3 "const_int_operand" "i"))
  1895.             (const_int 0)))
  1896.    (clobber (match_scratch:SI 4 "=r"))]
  1897.   ""
  1898.   "*
  1899. {
  1900.   int start = INTVAL (operands[3]) & 31;
  1901.   int size = INTVAL (operands[2]) & 31;
  1902.  
  1903.   /* If the bitfield being tested fits in the upper or lower half of a
  1904.      word, it is possible to use andiu. or andil. to test it.  This is
  1905.      useful because the condition register set-use delay is smaller for
  1906.      andi[ul]. than for rlinm.  This doesn't work when the starting bit
  1907.      position is 0 because the LT and GT bits may be set wrong.  */
  1908.  
  1909.   if ((start > 0 && start + size <= 16) || start >= 16)
  1910.     {
  1911.       operands[3] = gen_rtx (CONST_INT, VOIDmode,
  1912.                  ((1 << (16 - (start & 15)))
  1913.                   - (1 << (16 - (start & 15) - size))));
  1914.       if (start < 16)
  1915.     return \"{andiu.|andis.} %4,%1,%3\";
  1916.       else
  1917.     return \"{andil.|andi.} %4,%1,%3\";
  1918.     }
  1919.   
  1920.   if (start + size >= 32)
  1921.     operands[3] = const0_rtx;
  1922.   else
  1923.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1924.   return \"{rlinm.|rlwinm.} %4,%1,%3,%s2,31\";
  1925. }"
  1926.   [(set_attr "type" "compare")])
  1927.  
  1928. (define_insn ""
  1929.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  1930.     (compare:CC (zero_extract:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1931.              (match_operand:SI 2 "const_int_operand" "i")
  1932.              (match_operand:SI 3 "const_int_operand" "i"))
  1933.             (const_int 0)))
  1934.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1935.     (zero_extract:SI (match_dup 1) (match_dup 2) (match_dup 3)))]
  1936.   ""
  1937.   "*
  1938. {
  1939.   int start = INTVAL (operands[3]) & 31;
  1940.   int size = INTVAL (operands[2]) & 31;
  1941.  
  1942.   if (start >= 16 && start + size == 32)
  1943.     {
  1944.       operands[3] = gen_rtx (CONST_INT, VOIDmode, (1 << (32 - start)) - 1);
  1945.       return \"{andil.|andi.} %0,%1,%3\";
  1946.     }
  1947.   
  1948.   if (start + size >= 32)
  1949.     operands[3] = const0_rtx;
  1950.   else
  1951.     operands[3] = gen_rtx (CONST_INT, VOIDmode, start + size);
  1952.   return \"{rlinm.|rlwinm.} %0,%1,%3,%s2,31\";
  1953. }"
  1954.   [(set_attr "type" "delayed_compare")])
  1955.  
  1956. (define_insn "rotlsi3"
  1957.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1958.     (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1959.            (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  1960.   ""
  1961.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffffffff")
  1962.  
  1963. (define_insn ""
  1964.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1965.     (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1966.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1967.             (const_int 0)))
  1968.    (clobber (match_scratch:SI 3 "=r"))]
  1969.   ""
  1970.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffffffff"
  1971.   [(set_attr "type" "delayed_compare")])
  1972.  
  1973. (define_insn ""
  1974.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  1975.     (compare:CC (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1976.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1977.             (const_int 0)))
  1978.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1979.     (rotate:SI (match_dup 1) (match_dup 2)))]
  1980.   ""
  1981.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffffffff"
  1982.   [(set_attr "type" "delayed_compare")])
  1983.  
  1984. (define_insn ""
  1985.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  1986.     (and:SI (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1987.                (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1988.         (match_operand:SI 3 "mask_operand" "L")))]
  1989.   ""
  1990.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,%m3,%M3")
  1991.  
  1992. (define_insn ""
  1993.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  1994.     (compare:CC (and:SI
  1995.              (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  1996.                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  1997.              (match_operand:SI 3 "mask_operand" "L"))
  1998.             (const_int 0)))
  1999.    (clobber (match_scratch:SI 4 "=r"))]
  2000.   ""
  2001.   "{rl%I2nm.|rlw%I2nm.} %4,%1,%h2,%m3,%M3"
  2002.   [(set_attr "type" "delayed_compare")])
  2003.  
  2004. (define_insn ""
  2005.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  2006.     (compare:CC (and:SI
  2007.              (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2008.                 (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2009.              (match_operand:SI 3 "mask_operand" "L"))
  2010.             (const_int 0)))
  2011.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2012.     (and:SI (rotate:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  2013.   ""
  2014.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,%m3,%M3"
  2015.   [(set_attr "type" "delayed_compare")])
  2016.  
  2017. (define_insn ""
  2018.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2019.     (zero_extend:SI
  2020.      (subreg:QI
  2021.       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2022.              (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
  2023.   ""
  2024.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xff")
  2025.  
  2026. (define_insn ""
  2027.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2028.     (compare:CC (zero_extend:SI
  2029.              (subreg:QI
  2030.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2031.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  2032.             (const_int 0)))
  2033.    (clobber (match_scratch:SI 3 "=r"))]
  2034.   ""
  2035.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xff"
  2036.   [(set_attr "type" "delayed_compare")])
  2037.  
  2038. (define_insn ""
  2039.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2040.     (compare:CC (zero_extend:SI
  2041.              (subreg:QI
  2042.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2043.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  2044.             (const_int 0)))
  2045.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2046.     (zero_extend:SI (subreg:QI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
  2047.   ""
  2048.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xff"
  2049.   [(set_attr "type" "delayed_compare")])
  2050.  
  2051. (define_insn ""
  2052.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2053.     (zero_extend:SI
  2054.      (subreg:HI
  2055.       (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2056.              (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0)))]
  2057.   ""
  2058.   "{rl%I2nm|rlw%I2nm} %0,%1,%h2,0xffff")
  2059.  
  2060. (define_insn ""
  2061.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2062.     (compare:CC (zero_extend:SI
  2063.              (subreg:HI
  2064.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2065.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  2066.             (const_int 0)))
  2067.    (clobber (match_scratch:SI 3 "=r"))]
  2068.   ""
  2069.   "{rl%I2nm.|rlw%I2nm.} %3,%1,%h2,0xffff"
  2070.   [(set_attr "type" "delayed_compare")])
  2071.  
  2072. (define_insn ""
  2073.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2074.     (compare:CC (zero_extend:SI
  2075.              (subreg:HI
  2076.               (rotate:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2077.                  (match_operand:SI 2 "reg_or_cint_operand" "ri")) 0))
  2078.             (const_int 0)))
  2079.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2080.     (zero_extend:SI (subreg:HI (rotate:SI (match_dup 1) (match_dup 2)) 0)))]
  2081.   ""
  2082.   "{rl%I2nm.|rlw%I2nm.} %0,%1,%h2,0xffff"
  2083.   [(set_attr "type" "delayed_compare")])
  2084.  
  2085. ;; Note that we use "sle." instead of "sl." so that we can set
  2086. ;; SHIFT_COUNT_TRUNCATED.
  2087.  
  2088. (define_expand "ashlsi3"
  2089.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  2090.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  2091.    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
  2092.   ""
  2093.   "
  2094. {
  2095.   if (TARGET_POWER)
  2096.     emit_insn (gen_ashlsi3_power (operands[0], operands[1], operands[2]));
  2097.   else
  2098.     emit_insn (gen_ashlsi3_no_power (operands[0], operands[1], operands[2]));
  2099.   DONE;
  2100. }")
  2101.  
  2102. (define_insn "ashlsi3_power"
  2103.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2104.     (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2105.            (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  2106.    (clobber (match_scratch:SI 3 "=q,X"))]
  2107.   "TARGET_POWER"
  2108.   "@
  2109.    sle %0,%1,%2
  2110.    {sli|slwi} %0,%1,%h2"
  2111.   [(set_attr "length" "8")])
  2112.  
  2113. (define_insn "ashlsi3_no_power"
  2114.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2115.     (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2116.            (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  2117.   "! TARGET_POWER"
  2118.   "slw%I2 %0,%1,%h2"
  2119.   [(set_attr "length" "8")])
  2120.  
  2121. (define_insn ""
  2122.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  2123.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2124.                    (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2125.             (const_int 0)))
  2126.    (clobber (match_scratch:SI 3 "=r,r"))
  2127.    (clobber (match_scratch:SI 4 "=q,X"))]
  2128.   "TARGET_POWER"
  2129.   "@
  2130.    sle. %3,%1,%2
  2131.    {sli.|slwi.} %3,%1,%h2"
  2132.   [(set_attr "type" "delayed_compare")])
  2133.  
  2134. (define_insn ""
  2135.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2136.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2137.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2138.             (const_int 0)))
  2139.    (clobber (match_scratch:SI 3 "=r"))]
  2140.   "! TARGET_POWER"
  2141.   "slw%I2. %3,%1,%h2"
  2142.   [(set_attr "type" "delayed_compare")])
  2143.  
  2144. (define_insn ""
  2145.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  2146.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2147.                    (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2148.             (const_int 0)))
  2149.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2150.     (ashift:SI (match_dup 1) (match_dup 2)))
  2151.    (clobber (match_scratch:SI 4 "=q,X"))]
  2152.   "TARGET_POWER"
  2153.   "@
  2154.    sle. %0,%1,%2
  2155.    {sli.|slwi.} %0,%1,%h2"
  2156.   [(set_attr "type" "delayed_compare")])
  2157.  
  2158. (define_insn ""
  2159.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2160.     (compare:CC (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2161.                    (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2162.             (const_int 0)))
  2163.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2164.     (ashift:SI (match_dup 1) (match_dup 2)))]
  2165.   "! TARGET_POWER"
  2166.   "slw%I2. %0,%1,%h2"
  2167.   [(set_attr "type" "delayed_compare")])
  2168.  
  2169. (define_insn ""
  2170.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2171.     (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2172.                (match_operand:SI 2 "const_int_operand" "i"))
  2173.         (match_operand:SI 3 "mask_operand" "L")))]
  2174.   "includes_lshift_p (operands[2], operands[3])"
  2175.   "{rlinm|rlwinm} %0,%h1,%h2,%m3,%M3")
  2176.  
  2177. (define_insn ""
  2178.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2179.     (compare:CC
  2180.      (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2181.                 (match_operand:SI 2 "const_int_operand" "i"))
  2182.          (match_operand:SI 3 "mask_operand" "L"))
  2183.      (const_int 0)))
  2184.    (clobber (match_scratch:SI 4 "=r"))]
  2185.   "includes_lshift_p (operands[2], operands[3])"
  2186.   "{rlinm.|rlwinm.} %4,%h1,%h2,%m3,%M3"
  2187.   [(set_attr "type" "delayed_compare")])
  2188.  
  2189. (define_insn ""
  2190.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  2191.     (compare:CC
  2192.      (and:SI (ashift:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2193.                 (match_operand:SI 2 "const_int_operand" "i"))
  2194.          (match_operand:SI 3 "mask_operand" "L"))
  2195.      (const_int 0)))
  2196.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2197.     (and:SI (ashift:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  2198.   "includes_lshift_p (operands[2], operands[3])"
  2199.   "{rlinm.|rlwinm.} %0,%h1,%h2,%m3,%M3"
  2200.   [(set_attr "type" "delayed_compare")])
  2201.  
  2202. ;; The AIX assembler mis-handles "sri x,x,0", so write that case as
  2203. ;; "sli x,x,0".
  2204. (define_expand "lshrsi3"
  2205.   [(use (match_operand:SI 0 "gpc_reg_operand" ""))
  2206.    (use (match_operand:SI 1 "gpc_reg_operand" ""))
  2207.    (use (match_operand:SI 2 "reg_or_cint_operand" ""))]
  2208.   ""
  2209.   "
  2210. {
  2211.   if (TARGET_POWER)
  2212.     emit_insn (gen_lshrsi3_power (operands[0], operands[1], operands[2]));
  2213.   else
  2214.     emit_insn (gen_lshrsi3_no_power (operands[0], operands[1], operands[2]));
  2215.   DONE;
  2216. }")
  2217.  
  2218. (define_insn "lshrsi3_power"
  2219.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2220.     (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2221.              (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  2222.    (clobber (match_scratch:SI 3 "=q,X"))]
  2223.   "TARGET_POWER"
  2224.   "@
  2225.   sre %0,%1,%2
  2226.   {s%A2i|s%A2wi} %0,%1,%h2")
  2227.  
  2228. (define_insn "lshrsi3_no_power"
  2229.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2230.     (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2231.              (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  2232.   "! TARGET_POWER"
  2233.   "srw%I2 %0,%1,%h2")
  2234.  
  2235. (define_insn ""
  2236.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  2237.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2238.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2239.             (const_int 0)))
  2240.    (clobber (match_scratch:SI 3 "=r,r"))
  2241.    (clobber (match_scratch:SI 4 "=q,X"))]
  2242.   "TARGET_POWER"
  2243.   "@
  2244.   sre. %3,%1,%2
  2245.   {s%A2i.|s%A2wi.} %3,%1,%h2"
  2246.   [(set_attr "type" "delayed_compare")])
  2247.  
  2248. (define_insn ""
  2249.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2250.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2251.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2252.             (const_int 0)))
  2253.    (clobber (match_scratch:SI 3 "=r"))]
  2254.   "! TARGET_POWER"
  2255.   "srw%I2. %3,%1,%h2"
  2256.   [(set_attr "type" "delayed_compare")])
  2257.  
  2258. (define_insn ""
  2259.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  2260.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2261.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2262.             (const_int 0)))
  2263.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2264.     (lshiftrt:SI (match_dup 1) (match_dup 2)))
  2265.    (clobber (match_scratch:SI 4 "=q,X"))]
  2266.   "TARGET_POWER"
  2267.   "@
  2268.   sre. %0,%1,%2
  2269.   {s%A2i.|s%A2wi.} %0,%1,%h2"
  2270.   [(set_attr "type" "delayed_compare")])
  2271.  
  2272. (define_insn ""
  2273.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2274.     (compare:CC (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2275.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2276.             (const_int 0)))
  2277.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2278.     (lshiftrt:SI (match_dup 1) (match_dup 2)))]
  2279.   "! TARGET_POWER"
  2280.   "srw%I2. %0,%1,%h2"
  2281.   [(set_attr "type" "delayed_compare")])
  2282.  
  2283. (define_insn ""
  2284.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2285.     (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2286.                  (match_operand:SI 2 "const_int_operand" "i"))
  2287.         (match_operand:SI 3 "mask_operand" "L")))]
  2288.   "includes_rshift_p (operands[2], operands[3])"
  2289.   "{rlinm|rlwinm} %0,%1,%s2,%m3,%M3")
  2290.  
  2291. (define_insn ""
  2292.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2293.     (compare:CC
  2294.      (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2295.                   (match_operand:SI 2 "const_int_operand" "i"))
  2296.          (match_operand:SI 3 "mask_operand" "L"))
  2297.      (const_int 0)))
  2298.    (clobber (match_scratch:SI 4 "=r"))]
  2299.   "includes_rshift_p (operands[2], operands[3])"
  2300.   "{rlinm.|rlwinm.} %4,%1,%s2,%m3,%M3"
  2301.   [(set_attr "type" "delayed_compare")])
  2302.  
  2303. (define_insn ""
  2304.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  2305.     (compare:CC
  2306.      (and:SI (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2307.                   (match_operand:SI 2 "const_int_operand" "i"))
  2308.          (match_operand:SI 3 "mask_operand" "L"))
  2309.      (const_int 0)))
  2310.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2311.     (and:SI (lshiftrt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))]
  2312.   "includes_rshift_p (operands[2], operands[3])"
  2313.   "{rlinm.|rlwinm.} %0,%1,%s2,%m3,%M3"
  2314.   [(set_attr "type" "delayed_compare")])
  2315.  
  2316. (define_insn ""
  2317.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2318.     (zero_extend:SI
  2319.      (subreg:QI
  2320.       (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2321.                (match_operand:SI 2 "const_int_operand" "i")) 0)))]
  2322.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  2323.   "{rlinm|rlwinm} %0,%1,%s2,0xff")
  2324.  
  2325. (define_insn ""
  2326.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2327.     (compare:CC
  2328.      (zero_extend:SI
  2329.       (subreg:QI
  2330.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2331.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  2332.      (const_int 0)))
  2333.    (clobber (match_scratch:SI 3 "=r"))]
  2334.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  2335.   "{rlinm.|rlwinm.} %3,%1,%s2,0xff"
  2336.   [(set_attr "type" "delayed_compare")])
  2337.  
  2338. (define_insn ""
  2339.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2340.     (compare:CC
  2341.      (zero_extend:SI
  2342.       (subreg:QI
  2343.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2344.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  2345.      (const_int 0)))
  2346.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2347.     (zero_extend:SI (subreg:QI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
  2348.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 255))"
  2349.   "{rlinm.|rlwinm.} %0,%1,%s2,0xff"
  2350.   [(set_attr "type" "delayed_compare")])
  2351.  
  2352. (define_insn ""
  2353.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2354.     (zero_extend:SI
  2355.      (subreg:HI
  2356.       (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2357.                (match_operand:SI 2 "const_int_operand" "i")) 0)))]
  2358.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  2359.   "{rlinm|rlwinm} %0,%1,%s2,0xffff")
  2360.  
  2361. (define_insn ""
  2362.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2363.     (compare:CC
  2364.      (zero_extend:SI
  2365.       (subreg:HI
  2366.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2367.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  2368.      (const_int 0)))
  2369.    (clobber (match_scratch:SI 3 "=r"))]
  2370.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  2371.   "{rlinm.|rlwinm.} %3,%1,%s2,0xffff"
  2372.   [(set_attr "type" "delayed_compare")])
  2373.  
  2374. (define_insn ""
  2375.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2376.     (compare:CC
  2377.      (zero_extend:SI
  2378.       (subreg:HI
  2379.        (lshiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2380.             (match_operand:SI 2 "const_int_operand" "i")) 0))
  2381.      (const_int 0)))
  2382.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2383.     (zero_extend:SI (subreg:HI (lshiftrt:SI (match_dup 1) (match_dup 2)) 0)))]
  2384.   "includes_rshift_p (operands[2], gen_rtx (CONST_INT, VOIDmode, 65535))"
  2385.   "{rlinm.|rlwinm.} %0,%1,%s2,0xffff"
  2386.   [(set_attr "type" "delayed_compare")])
  2387.  
  2388. (define_insn ""
  2389.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  2390.              (const_int 1)
  2391.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  2392.     (ashiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  2393.              (const_int 31)))]
  2394.   "TARGET_POWER"
  2395.   "rrib %0,%1,%2")
  2396.  
  2397. (define_insn ""
  2398.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  2399.              (const_int 1)
  2400.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  2401.     (lshiftrt:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  2402.              (const_int 31)))]
  2403.   "TARGET_POWER"
  2404.   "rrib %0,%1,%2")
  2405.  
  2406. (define_insn ""
  2407.   [(set (zero_extract:SI (match_operand:SI 0 "gpc_reg_operand" "+r")
  2408.              (const_int 1)
  2409.              (match_operand:SI 1 "gpc_reg_operand" "r"))
  2410.     (zero_extract:SI (match_operand:SI 2 "gpc_reg_operand" "r")
  2411.              (const_int 1)
  2412.              (const_int 0)))]
  2413.   "TARGET_POWER"
  2414.   "rrib %0,%1,%2")
  2415.  
  2416. (define_expand "ashrsi3"
  2417.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  2418.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "")
  2419.              (match_operand:SI 2 "reg_or_cint_operand" "")))]
  2420.   ""
  2421.   "
  2422. {
  2423.   if (TARGET_POWER)
  2424.     emit_insn (gen_ashrsi3_power (operands[0], operands[1], operands[2]));
  2425.   else
  2426.     emit_insn (gen_ashrsi3_no_power (operands[0], operands[1], operands[2]));
  2427.   DONE;
  2428. }")
  2429.  
  2430. (define_insn "ashrsi3_power"
  2431.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2432.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2433.              (match_operand:SI 2 "reg_or_cint_operand" "r,i")))
  2434.    (clobber (match_scratch:SI 3 "=q,X"))]
  2435.   "TARGET_POWER"
  2436.   "@
  2437.    srea %0,%1,%2
  2438.    {srai|srawi} %0,%1,%h2")
  2439.  
  2440. (define_insn "ashrsi3_no_power"
  2441.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2442.     (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2443.              (match_operand:SI 2 "reg_or_cint_operand" "ri")))]
  2444.   "! TARGET_POWER"
  2445.   "sraw%I2 %0,%1,%h2")
  2446.  
  2447. (define_insn ""
  2448.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  2449.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2450.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2451.             (const_int 0)))
  2452.    (clobber (match_scratch:SI 3 "=r,r"))
  2453.    (clobber (match_scratch:SI 4 "=q,X"))]
  2454.   "TARGET_POWER"
  2455.   "@
  2456.    srea. %3,%1,%2
  2457.    {srai.|srawi.} %3,%1,%h2"
  2458.   [(set_attr "type" "delayed_compare")])
  2459.  
  2460. (define_insn ""
  2461.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  2462.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2463.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2464.             (const_int 0)))
  2465.    (clobber (match_scratch:SI 3 "=r"))]
  2466.   "! TARGET_POWER"
  2467.   "sraw%I2. %3,%1,%h2"
  2468.   [(set_attr "type" "delayed_compare")])
  2469.  
  2470. (define_insn ""
  2471.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  2472.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  2473.                  (match_operand:SI 2 "reg_or_cint_operand" "r,i"))
  2474.             (const_int 0)))
  2475.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  2476.     (ashiftrt:SI (match_dup 1) (match_dup 2)))
  2477.    (clobber (match_scratch:SI 4 "=q,X"))]
  2478.   "TARGET_POWER"
  2479.   "@
  2480.    srea. %0,%1,%2
  2481.    {srai.|srawi.} %0,%1,%h2"
  2482.   [(set_attr "type" "delayed_compare")])
  2483.  
  2484. (define_insn ""
  2485.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  2486.     (compare:CC (ashiftrt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  2487.                  (match_operand:SI 2 "reg_or_cint_operand" "ri"))
  2488.             (const_int 0)))
  2489.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  2490.     (ashiftrt:SI (match_dup 1) (match_dup 2)))]
  2491.   "! TARGET_POWER"
  2492.   "sraw%I2. %0,%1,%h2"
  2493.   [(set_attr "type" "delayed_compare")])
  2494.  
  2495. ;; Floating-point insns, excluding normal data motion.
  2496. ;;
  2497. ;; PowerPC has a full set of single-precision floating point instructions.
  2498. ;;
  2499. ;; For the POWER architecture, we pretend that we have both SFmode and
  2500. ;; DFmode insns, while, in fact, all fp insns are actually done in double.
  2501. ;; The only conversions we will do will be when storing to memory.  In that
  2502. ;; case, we will use the "frsp" instruction before storing.
  2503. ;;
  2504. ;; Note that when we store into a single-precision memory location, we need to
  2505. ;; use the frsp insn first.  If the register being stored isn't dead, we
  2506. ;; need a scratch register for the frsp.  But this is difficult when the store
  2507. ;; is done by reload.  It is not incorrect to do the frsp on the register in
  2508. ;; this case, we just lose precision that we would have otherwise gotten but
  2509. ;; is not guaranteed.  Perhaps this should be tightened up at some point.
  2510.  
  2511. (define_insn "extendsfdf2"
  2512.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2513.     (float_extend:DF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2514.   ""
  2515.   "*
  2516. {
  2517.   if (REGNO (operands[0]) == REGNO (operands[1]))
  2518.     return \"\";
  2519.   else
  2520.     return \"fmr %0,%1\";
  2521. }"
  2522.   [(set_attr "type" "fp")])
  2523.  
  2524. (define_insn "truncdfsf2"
  2525.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2526.     (float_truncate:SF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2527.   ""
  2528.   "frsp %0,%1"
  2529.   [(set_attr "type" "fp")])
  2530.  
  2531. (define_insn "negsf2"
  2532.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2533.     (neg:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2534.   ""
  2535.   "fneg %0,%1"
  2536.   [(set_attr "type" "fp")])
  2537.  
  2538. (define_insn "abssf2"
  2539.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2540.     (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2541.   ""
  2542.   "fabs %0,%1"
  2543.   [(set_attr "type" "fp")])
  2544.  
  2545. (define_insn ""
  2546.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2547.     (neg:SF (abs:SF (match_operand:SF 1 "gpc_reg_operand" "f"))))]
  2548.   ""
  2549.   "fnabs %0,%1"
  2550.   [(set_attr "type" "fp")])
  2551.  
  2552. (define_expand "addsf3"
  2553.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2554.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2555.          (match_operand:SF 2 "gpc_reg_operand" "")))]
  2556.   ""
  2557.   "")
  2558.  
  2559. (define_insn ""
  2560.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2561.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2562.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2563.   "TARGET_POWERPC"
  2564.   "fadds %0,%1,%2"
  2565.   [(set_attr "type" "fp")])
  2566.  
  2567. (define_insn ""
  2568.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2569.     (plus:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2570.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2571.   "! TARGET_POWERPC"
  2572.   "{fa|fadd} %0,%1,%2"
  2573.   [(set_attr "type" "fp")])
  2574.  
  2575. (define_expand "subsf3"
  2576.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2577.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2578.           (match_operand:SF 2 "gpc_reg_operand" "")))]
  2579.   ""
  2580.   "")
  2581.  
  2582. (define_insn ""
  2583.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2584.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2585.           (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2586.   "TARGET_POWERPC"
  2587.   "fsubs %0,%1,%2"
  2588.   [(set_attr "type" "fp")])
  2589.  
  2590. (define_insn ""
  2591.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2592.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2593.           (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2594.   "! TARGET_POWERPC"
  2595.   "{fs|fsub} %0,%1,%2"
  2596.   [(set_attr "type" "fp")])
  2597.  
  2598. (define_expand "mulsf3"
  2599.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2600.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2601.          (match_operand:SF 2 "gpc_reg_operand" "")))]
  2602.   ""
  2603.   "")
  2604.  
  2605. (define_insn ""
  2606.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2607.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2608.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2609.   "TARGET_POWERPC"
  2610.   "fmuls %0,%1,%2"
  2611.   [(set_attr "type" "fp")])
  2612.  
  2613. (define_insn ""
  2614.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2615.     (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2616.          (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2617.   "! TARGET_POWERPC"
  2618.   "{fm|fmul} %0,%1,%2"
  2619.   [(set_attr "type" "fp")])
  2620.  
  2621. (define_expand "divsf3"
  2622.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2623.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2624.         (match_operand:SF 2 "gpc_reg_operand" "")))]
  2625.   ""
  2626.   "")
  2627.  
  2628. (define_insn ""
  2629.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2630.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2631.         (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2632.   "TARGET_POWERPC"
  2633.   "fdivs %0,%1,%2"
  2634.   [(set_attr "type" "sdiv")])
  2635.  
  2636. (define_insn ""
  2637.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2638.     (div:SF (match_operand:SF 1 "gpc_reg_operand" "f")
  2639.         (match_operand:SF 2 "gpc_reg_operand" "f")))]
  2640.   "! TARGET_POWERPC"
  2641.   "{fd|fdiv} %0,%1,%2"
  2642.   [(set_attr "type" "sdiv")])
  2643.  
  2644. (define_insn ""
  2645.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2646.     (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2647.               (match_operand:SF 2 "gpc_reg_operand" "f"))
  2648.          (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2649.   "TARGET_POWERPC"
  2650.   "fmadds %0,%1,%2,%3"
  2651.   [(set_attr "type" "fp")])
  2652.  
  2653. (define_insn ""
  2654.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2655.     (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2656.               (match_operand:SF 2 "gpc_reg_operand" "f"))
  2657.          (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2658.   "! TARGET_POWERPC"
  2659.   "{fma|fmadd} %0,%1,%2,%3"
  2660.   [(set_attr "type" "fp")])
  2661.  
  2662. (define_insn ""
  2663.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2664.     (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2665.                (match_operand:SF 2 "gpc_reg_operand" "f"))
  2666.           (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2667.   "TARGET_POWERPC"
  2668.   "fmsubs %0,%1,%2,%3"
  2669.   [(set_attr "type" "fp")])
  2670.  
  2671. (define_insn ""
  2672.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2673.     (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2674.                (match_operand:SF 2 "gpc_reg_operand" "f"))
  2675.           (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2676.   "! TARGET_POWERPC"
  2677.   "{fms|fmsub} %0,%1,%2,%3"
  2678.   [(set_attr "type" "fp")])
  2679.  
  2680. (define_insn ""
  2681.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2682.     (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2683.                   (match_operand:SF 2 "gpc_reg_operand" "f"))
  2684.              (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2685.   "TARGET_POWERPC"
  2686.   "fnmadds %0,%1,%2,%3"
  2687.   [(set_attr "type" "fp")])
  2688.  
  2689. (define_insn ""
  2690.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2691.     (neg:SF (plus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2692.                   (match_operand:SF 2 "gpc_reg_operand" "f"))
  2693.              (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2694.   "! TARGET_POWERPC"
  2695.   "{fnma|fnmadd} %0,%1,%2,%3"
  2696.   [(set_attr "type" "fp")])
  2697.  
  2698. (define_insn ""
  2699.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2700.     (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2701.                    (match_operand:SF 2 "gpc_reg_operand" "f"))
  2702.               (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2703.   "TARGET_POWERPC"
  2704.   "fnmsubs %0,%1,%2,%3"
  2705.   [(set_attr "type" "fp")])
  2706.  
  2707. (define_insn ""
  2708.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2709.     (neg:SF (minus:SF (mult:SF (match_operand:SF 1 "gpc_reg_operand" "%f")
  2710.                    (match_operand:SF 2 "gpc_reg_operand" "f"))
  2711.               (match_operand:SF 3 "gpc_reg_operand" "f"))))]
  2712.   "! TARGET_POWERPC"
  2713.   "{fnms|fnmsub} %0,%1,%2,%3"
  2714.   [(set_attr "type" "fp")])
  2715.  
  2716. (define_expand "sqrtsf2"
  2717.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2718.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "")))]
  2719.   "TARGET_PPC_GPOPT || TARGET_POWER2"
  2720.   "")
  2721.  
  2722. (define_insn ""
  2723.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2724.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2725.   "TARGET_PPC_GPOPT"
  2726.   "fsqrts %0,%1"
  2727.   [(set_attr "type" "ssqrt")])
  2728.  
  2729. (define_insn ""
  2730.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2731.     (sqrt:SF (match_operand:SF 1 "gpc_reg_operand" "f")))]
  2732.   "TARGET_POWER2"
  2733.   "fsqrt %0,%1"
  2734.   [(set_attr "type" "dsqrt")])
  2735.  
  2736. ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a fsel
  2737. ;; instruction and some auxiliary computations.  Then we just have a single
  2738. ;; DEFINE_INSN for fsel and the define_splits to make them if made by
  2739. ;; combine.
  2740. (define_expand "maxsf3"
  2741.   [(set (match_dup 3)
  2742.     (minus:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2743.           (match_operand:SF 2 "gpc_reg_operand" "")))
  2744.    (set (match_operand:SF 0 "gpc_reg_operand" "")
  2745.     (if_then_else:SF (ge (match_dup 3)
  2746.                  (const_int 0))
  2747.              (match_dup 1)
  2748.              (match_dup 2)))]
  2749.   "TARGET_PPC_GFXOPT"
  2750.   "
  2751. { operands[3] = gen_reg_rtx (SFmode); }")
  2752.  
  2753. (define_split
  2754.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2755.     (smax:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2756.          (match_operand:SF 2 "gpc_reg_operand" "")))
  2757.    (clobber (match_operand:SF 3 "gpc_reg_operand" ""))]
  2758.   "TARGET_PPC_GFXOPT"
  2759.   [(set (match_dup 3)
  2760.     (minus:SF (match_dup 1) (match_dup 2)))
  2761.    (set (match_operand:SF 0 "gpc_reg_operand" "")
  2762.     (if_then_else:SF (ge (match_dup 3)
  2763.                  (const_int 0))
  2764.              (match_dup 1)
  2765.              (match_dup 2)))]
  2766.   "")
  2767.  
  2768. (define_expand "minsf3"
  2769.   [(set (match_dup 3)
  2770.     (minus:SF (match_operand:SF 2 "gpc_reg_operand" "")
  2771.           (match_operand:SF 1 "gpc_reg_operand" "")))
  2772.    (set (match_operand:SF 0 "gpc_reg_operand" "")
  2773.     (if_then_else:SF (ge (match_dup 3)
  2774.                  (const_int 0))
  2775.              (match_dup 1)
  2776.              (match_dup 2)))]
  2777.   "TARGET_PPC_GFXOPT"
  2778.   "
  2779. { operands[3] = gen_reg_rtx (SFmode); }")
  2780.  
  2781. (define_split
  2782.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  2783.     (smin:SF (match_operand:SF 1 "gpc_reg_operand" "")
  2784.          (match_operand:SF 2 "gpc_reg_operand" "")))
  2785.    (clobber (match_operand:SF 3 "gpc_reg_operand" ""))]
  2786.   "TARGET_PPC_GFXOPT"
  2787.   [(set (match_dup 3)
  2788.     (minus:SF (match_dup 2) (match_dup 1)))
  2789.    (set (match_operand:SF 0 "gpc_reg_operand" "")
  2790.     (if_then_else:SF (ge (match_dup 3)
  2791.                  (const_int 0))
  2792.              (match_dup 1)
  2793.              (match_dup 2)))]
  2794.   "")
  2795.  
  2796. (define_insn ""
  2797.   [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
  2798.     (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
  2799.                  (const_int 0))
  2800.              (match_operand:SF 2 "gpc_reg_operand" "f")
  2801.              (match_operand:SF 3 "gpc_reg_operand" "f")))]
  2802.   "TARGET_PPC_GFXOPT"
  2803.   "fsel %0,%1,%2,%3"
  2804.   [(set_attr "type" "fp")])
  2805.  
  2806. (define_insn "negdf2"
  2807.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2808.     (neg:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2809.   ""
  2810.   "fneg %0,%1"
  2811.   [(set_attr "type" "fp")])
  2812.  
  2813. (define_insn "absdf2"
  2814.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2815.     (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2816.   ""
  2817.   "fabs %0,%1"
  2818.   [(set_attr "type" "fp")])
  2819.  
  2820. (define_insn ""
  2821.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2822.     (neg:DF (abs:DF (match_operand:DF 1 "gpc_reg_operand" "f"))))]
  2823.   ""
  2824.   "fnabs %0,%1"
  2825.   [(set_attr "type" "fp")])
  2826.  
  2827. (define_insn "adddf3"
  2828.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2829.     (plus:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2830.          (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2831.   ""
  2832.   "{fa|fadd} %0,%1,%2"
  2833.   [(set_attr "type" "fp")])
  2834.  
  2835. (define_insn "subdf3"
  2836.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2837.     (minus:DF (match_operand:DF 1 "gpc_reg_operand" "f")
  2838.           (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2839.   ""
  2840.   "{fs|fsub} %0,%1,%2"
  2841.   [(set_attr "type" "fp")])
  2842.  
  2843. (define_insn "muldf3"
  2844.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2845.     (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2846.          (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2847.   ""
  2848.   "{fm|fmul} %0,%1,%2"
  2849.   [(set_attr "type" "dmul")])
  2850.  
  2851. (define_insn "divdf3"
  2852.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2853.     (div:DF (match_operand:DF 1 "gpc_reg_operand" "f")
  2854.         (match_operand:DF 2 "gpc_reg_operand" "f")))]
  2855.   ""
  2856.   "{fd|fdiv} %0,%1,%2"
  2857.   [(set_attr "type" "ddiv")])
  2858.  
  2859. (define_insn ""
  2860.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2861.     (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2862.               (match_operand:DF 2 "gpc_reg_operand" "f"))
  2863.          (match_operand:DF 3 "gpc_reg_operand" "f")))]
  2864.   ""
  2865.   "{fma|fmadd} %0,%1,%2,%3"
  2866.   [(set_attr "type" "dmul")])
  2867.  
  2868. (define_insn ""
  2869.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2870.     (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2871.                (match_operand:DF 2 "gpc_reg_operand" "f"))
  2872.           (match_operand:DF 3 "gpc_reg_operand" "f")))]
  2873.   ""
  2874.   "{fms|fmsub} %0,%1,%2,%3"
  2875.   [(set_attr "type" "dmul")])
  2876.  
  2877. (define_insn ""
  2878.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2879.     (neg:DF (plus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2880.                   (match_operand:DF 2 "gpc_reg_operand" "f"))
  2881.              (match_operand:DF 3 "gpc_reg_operand" "f"))))]
  2882.   ""
  2883.   "{fnma|fnmadd} %0,%1,%2,%3"
  2884.   [(set_attr "type" "dmul")])
  2885.  
  2886. (define_insn ""
  2887.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2888.     (neg:DF (minus:DF (mult:DF (match_operand:DF 1 "gpc_reg_operand" "%f")
  2889.                    (match_operand:DF 2 "gpc_reg_operand" "f"))
  2890.               (match_operand:DF 3 "gpc_reg_operand" "f"))))]
  2891.   ""
  2892.   "{fnms|fnmsub} %0,%1,%2,%3"
  2893.   [(set_attr "type" "dmul")])
  2894.  
  2895. (define_insn "sqrtdf2"
  2896.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2897.     (sqrt:DF (match_operand:DF 1 "gpc_reg_operand" "f")))]
  2898.   "TARGET_PPC_GPOPT || TARGET_POWER2"
  2899.   "fsqrt %0,%1"
  2900.   [(set_attr "type" "dsqrt")])
  2901.  
  2902. ;; For SMIN, SMAX, UMIN, and UMAX, we use DEFINE_EXPAND's that involve a fsel
  2903. ;; instruction and some auxiliary computations.  Then we just have a single
  2904. ;; DEFINE_INSN for fsel and the define_splits to make them if made by
  2905. ;; combine.
  2906.  
  2907. (define_expand "maxdf3"
  2908.   [(set (match_dup 3)
  2909.     (minus:DF (match_operand:DF 1 "gpc_reg_operand" "")
  2910.           (match_operand:DF 2 "gpc_reg_operand" "")))
  2911.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2912.     (if_then_else:DF (ge (match_dup 3)
  2913.                  (const_int 0))
  2914.              (match_dup 1)
  2915.              (match_dup 2)))]
  2916.   "TARGET_PPC_GFXOPT"
  2917.   "
  2918. { operands[3] = gen_reg_rtx (DFmode); }")
  2919.  
  2920. (define_split
  2921.   [(set (match_operand:DF 0 "gpc_reg_operand" "")
  2922.     (smax:DF (match_operand:DF 1 "gpc_reg_operand" "")
  2923.          (match_operand:DF 2 "gpc_reg_operand" "")))
  2924.    (clobber (match_operand:DF 3 "gpc_reg_operand" ""))]
  2925.   "TARGET_PPC_GFXOPT"
  2926.   [(set (match_dup 3)
  2927.     (minus:DF (match_dup 1) (match_dup 2)))
  2928.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2929.     (if_then_else:DF (ge (match_dup 3)
  2930.                  (const_int 0))
  2931.              (match_dup 1)
  2932.              (match_dup 2)))]
  2933.   "")
  2934.  
  2935. (define_expand "mindf3"
  2936.   [(set (match_dup 3)
  2937.     (minus:DF (match_operand:DF 2 "gpc_reg_operand" "")
  2938.           (match_operand:DF 1 "gpc_reg_operand" "")))
  2939.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2940.     (if_then_else:DF (ge (match_dup 3)
  2941.                  (const_int 0))
  2942.              (match_dup 1)
  2943.              (match_dup 2)))]
  2944.   "TARGET_PPC_GFXOPT"
  2945.   "
  2946. { operands[3] = gen_reg_rtx (DFmode); }")
  2947.  
  2948. (define_split
  2949.   [(set (match_operand:DF 0 "gpc_reg_operand" "")
  2950.     (smin:DF (match_operand:DF 1 "gpc_reg_operand" "")
  2951.          (match_operand:DF 2 "gpc_reg_operand" "")))
  2952.    (clobber (match_operand:DF 3 "gpc_reg_operand" ""))]
  2953.   "TARGET_PPC_GFXOPT"
  2954.   [(set (match_dup 3)
  2955.     (minus:DF (match_dup 2) (match_dup 1)))
  2956.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2957.     (if_then_else:DF (ge (match_dup 3)
  2958.                  (const_int 0))
  2959.              (match_dup 1)
  2960.              (match_dup 2)))]
  2961.   "")
  2962.  
  2963. (define_insn ""
  2964.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  2965.     (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "f")
  2966.                  (const_int 0))
  2967.              (match_operand:DF 2 "gpc_reg_operand" "f")
  2968.              (match_operand:DF 3 "gpc_reg_operand" "f")))]
  2969.   "TARGET_PPC_GFXOPT"
  2970.   "fsel %0,%1,%2,%3"
  2971.   [(set_attr "type" "fp")])
  2972.  
  2973. ;; Conversions to and from floating-point.
  2974. (define_expand "floatsidf2"
  2975.   [(set (match_dup 2)
  2976.     (plus:DI (zero_extend:DI
  2977.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  2978.               (match_dup 3)))
  2979.          (match_dup 4)))
  2980.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  2981.     (minus:DF (subreg:DF (match_dup 2) 0)
  2982.           (match_dup 5)))]
  2983.   ""
  2984.   "
  2985. {
  2986. #if HOST_BITS_PER_INT != BITS_PER_WORD
  2987.   /* Maybe someone can figure out how to do this in that case.  I don't
  2988.      want to right now.  */
  2989.   abort ();
  2990. #endif
  2991.  
  2992.   operands[2] = gen_reg_rtx (DImode);
  2993.   operands[3] = gen_rtx (CONST_INT, VOIDmode, 0x80000000);
  2994.   operands[4] = immed_double_const (0, 0x43300000, DImode);
  2995.   operands[5] = force_reg (DFmode, immed_double_const (0x43300000,
  2996.                                0x80000000, DFmode));
  2997. }")
  2998.  
  2999. (define_expand "floatunssidf2"
  3000.   [(set (match_dup 2)
  3001.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
  3002.          (match_dup 3)))
  3003.    (set (match_operand:DF 0 "gpc_reg_operand" "")
  3004.     (minus:DF (subreg:DF (match_dup 2) 0)
  3005.           (match_dup 4)))]
  3006.   ""
  3007.   "
  3008. {
  3009. #if HOST_BITS_PER_INT != BITS_PER_WORD
  3010.   /* Maybe someone can figure out how to do this in that case.  I don't
  3011.      want to right now.  */
  3012.   abort ();
  3013. #endif
  3014.  
  3015.   operands[2] = gen_reg_rtx (DImode);
  3016.   operands[3] = immed_double_const (0, 0x43300000, DImode);
  3017.   operands[4] = force_reg (DFmode, immed_double_const (0x43300000, 0, DFmode));
  3018. }")
  3019.  
  3020. ;; For the above two cases, we always split.
  3021. (define_split
  3022.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  3023.     (plus:DI (zero_extend:DI
  3024.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "")
  3025.               (match_operand:SI 2 "logical_operand" "")))
  3026.          (match_operand:DI 3 "immediate_operand" "")))]
  3027.   "reload_completed && HOST_BITS_PER_INT == BITS_PER_WORD
  3028.    && GET_CODE (operands[3]) == CONST_DOUBLE
  3029.    && CONST_DOUBLE_LOW (operands[3]) == 0"
  3030.   [(set (match_dup 6) (xor:SI (match_dup 1) (match_dup 2)))
  3031.    (set (match_dup 4) (match_dup 5))]
  3032.   "
  3033. { operands[4] = operand_subword (operands[0], 0, 0, DImode);
  3034.   operands[5] = operand_subword (operands[3], 0, 0, DImode);
  3035.   operands[6] = operand_subword (operands[0], 1, 0, DImode);
  3036. }")
  3037.  
  3038. (define_insn ""
  3039.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3040.     (plus:DI (zero_extend:DI
  3041.           (xor:SI (match_operand:SI 1 "gpc_reg_operand" "%r")
  3042.               (match_operand:SI 2 "logical_operand" "rKJ")))
  3043.          (match_operand:DI 3 "immediate_operand" "n")))]
  3044.   "HOST_BITS_PER_INT == BITS_PER_WORD
  3045.    && GET_CODE (operands[3]) == CONST_DOUBLE
  3046.    && CONST_DOUBLE_LOW (operands[3]) == 0"
  3047.   "#"
  3048.   [(set_attr "length" "8")])
  3049.   
  3050. (define_split
  3051.   [(set (match_operand:DI 0 "gpc_reg_operand" "=")
  3052.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
  3053.          (match_operand:DI 2 "immediate_operand" "")))]
  3054.   "reload_completed && HOST_BITS_PER_INT == BITS_PER_WORD
  3055.    && GET_CODE (operands[2]) == CONST_DOUBLE
  3056.    && CONST_DOUBLE_LOW (operands[2]) == 0"
  3057.   [(set (match_dup 3) (match_dup 4))
  3058.    (set (match_dup 5) (match_dup 1))]
  3059.   "
  3060. { operands[3] = operand_subword (operands[0], 0, 0, DImode);
  3061.   operands[4] = operand_subword (operands[2], 0, 0, DImode);
  3062.   operands[5] = operand_subword (operands[0], 1, 0, DImode);
  3063.  
  3064.   if (rtx_equal_p (operands[1], operands[5]))
  3065.     {
  3066.       emit_move_insn (operands[3], operands[4]);
  3067.       DONE;
  3068.     }
  3069.  
  3070.   if (rtx_equal_p (operands[1], operands[3]))
  3071.     {
  3072.       rtx temp;
  3073.  
  3074.       temp = operands[3]; operands[3] = operands[5]; operands[5] = temp;
  3075.       temp = operands[4]; operands[4] = operands[1]; operands[1] = temp;
  3076.     }
  3077. }")
  3078.  
  3079. (define_insn ""
  3080.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3081.     (plus:DI (zero_extend:DI (match_operand:SI 1 "gpc_reg_operand" "r"))
  3082.          (match_operand:DI 2 "immediate_operand" "n")))]
  3083.   "HOST_BITS_PER_INT == BITS_PER_WORD
  3084.    && GET_CODE (operands[2]) == CONST_DOUBLE
  3085.    && CONST_DOUBLE_LOW (operands[2]) == 0"
  3086.   "#"
  3087.   [(set_attr "length" "8")])
  3088.  
  3089. (define_expand "fix_truncdfsi2"
  3090.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  3091.     (fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
  3092.   ""
  3093.   "
  3094. {
  3095.   if (TARGET_POWER2 || TARGET_POWERPC)
  3096.     {
  3097.       rtx stack_slot = assign_stack_temp (DImode, 8, 0),
  3098.     temp = gen_reg_rtx (DImode);
  3099.  
  3100.       emit_insn (gen_fpcvtsi (temp, operands[1]));
  3101.       emit_move_insn (stack_slot, temp);
  3102.       emit_move_insn (operands[0],
  3103.               operand_subword (stack_slot, 1, 0, DImode));
  3104.       DONE;
  3105.     }
  3106.   else
  3107.     {
  3108.       emit_insn (gen_trunc_call (operands[0], operands[1],
  3109.                  gen_rtx (SYMBOL_REF, Pmode, RS6000_ITRUNC)));
  3110.       DONE;
  3111.     }
  3112. }")
  3113.  
  3114. (define_insn "fpcvtsi"
  3115.   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
  3116.     (sign_extend:DI
  3117.      (fix:SI (match_operand:DF 1 "gpc_reg_operand" "f"))))]
  3118.   "TARGET_POWER2 || TARGET_POWERPC"
  3119.   "{fcirz|fctiwz} %0,%1"
  3120.   [(set_attr "type" "fp")])
  3121.  
  3122. (define_expand "fixuns_truncdfsi2"
  3123.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  3124.     (unsigned_fix:SI (match_operand:DF 1 "gpc_reg_operand" "")))]
  3125.   "! TARGET_POWER2 && ! TARGET_POWERPC"
  3126.   "
  3127. {
  3128.   emit_insn (gen_trunc_call (operands[0], operands[1],
  3129.                  gen_rtx (SYMBOL_REF, Pmode, RS6000_UITRUNC)));
  3130.   DONE;
  3131. }")
  3132.  
  3133. (define_expand "trunc_call"
  3134.   [(parallel [(set (match_operand:SI 0 "" "")
  3135.            (fix:SI (match_operand:DF 1 "" "")))
  3136.           (use (match_operand:SI 2 "" ""))])]
  3137.   ""
  3138.   "
  3139. {
  3140.   rtx insns = gen_trunc_call_rtl (operands[0], operands[1], operands[2]);
  3141.   rtx first = XVECEXP (insns, 0, 0);
  3142.   rtx last = XVECEXP (insns, 0, XVECLEN (insns, 0) - 1);
  3143.  
  3144.   REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
  3145.                    REG_NOTES (first));
  3146.   REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
  3147.  
  3148.   emit_insn (insns);
  3149.   DONE;
  3150. }")
  3151.  
  3152. (define_expand "trunc_call_rtl"
  3153.   [(set (reg:DF 33) (match_operand:DF 1 "gpc_reg_operand" ""))
  3154.    (use (reg:DF 33))
  3155.    (parallel [(set (reg:SI 3)
  3156.            (call (mem:SI (match_operand 2 "" "")) (const_int 0)))
  3157.           (clobber (scratch:SI))])
  3158.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  3159.     (reg:SI 3))]
  3160.   ""
  3161.   "
  3162. { 
  3163.   rs6000_trunc_used = 1;
  3164. }")
  3165.  
  3166. (define_insn "floatdidf2"
  3167.   [(set (match_operand:DF 0 "gpc_reg_operand" "=f")
  3168.     (float:DF (match_operand:DI 1 "gpc_reg_operand" "f")))]
  3169.   "TARGET_POWERPC64"
  3170.   "fcfid %0,%1"
  3171.   [(set_attr "type" "fp")])
  3172.  
  3173. (define_insn "fix_truncdfdi2"
  3174.   [(set (match_operand:DI 0 "gpc_reg_operand" "=f")
  3175.     (fix:DI (match_operand:DF 1 "gpc_reg_operand" "f")))]
  3176.   "TARGET_POWERPC64"
  3177.   "fctidz %0,%1"
  3178.   [(set_attr "type" "fp")])
  3179.  
  3180. ;; Define the DImode operations that can be done in a small number
  3181. ;; of instructions.
  3182. (define_expand "adddi3"
  3183.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  3184.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "")
  3185.          (match_operand:DI 2 "reg_or_short_operand" "")))]
  3186.   ""
  3187.   "
  3188. {
  3189.   if (! TARGET_POWER && ! TARGET_POWERPC64
  3190.       && short_cint_operand (operands[2], DImode))
  3191.     FAIL;
  3192. }")
  3193.  
  3194. (define_insn ""
  3195.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  3196.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r,r")
  3197.          (match_operand:DI 2 "reg_or_short_operand" "r,I")))]
  3198.   "TARGET_POWER && ! TARGET_POWERPC64"
  3199.   "@
  3200.    {a|addc} %L0,%L1,%L2\;{ae|adde} %0,%1,%2
  3201.    {ai|addic} %L0,%L1,%2\;{a%G2e|add%G2e} %0,%1"
  3202.   [(set_attr "length" "8")])
  3203.  
  3204. (define_insn ""
  3205.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3206.     (plus:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
  3207.          (match_operand:DI 2 "gpc_reg_operand" "r")))]
  3208.   "! TARGET_POWER && ! TARGET_POWERPC64"
  3209.   "addc %L0,%L1,%L2\;adde %0,%1,%2"
  3210.   [(set_attr "length" "8")])
  3211.  
  3212. (define_expand "subdi3"
  3213.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  3214.     (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
  3215.           (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
  3216.   ""
  3217.   "
  3218. {
  3219.   if (! TARGET_POWER && ! TARGET_POWERPC64
  3220.       && short_cint_operand (operands[1], DImode))
  3221.     FAIL;
  3222. }")
  3223.  
  3224. (define_insn ""
  3225.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  3226.     (minus:DI (match_operand:DI 1 "reg_or_short_operand" "r,I")
  3227.           (match_operand:DI 2 "gpc_reg_operand" "r,r")))]
  3228.   "TARGET_POWER && ! TARGET_POWERPC64"
  3229.   "@
  3230.    {sf|subfc} %L0,%L2,%L1\;{sfe|subfe} %0,%2,%1
  3231.    {sfi|subfic} %L0,%L2,%1\;{sf%G1e|subf%G1e} %0,%2"
  3232.   [(set_attr "length" "8")])
  3233.  
  3234. (define_insn ""
  3235.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3236.     (minus:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3237.           (match_operand:DI 2 "gpc_reg_operand" "r")))]
  3238.   "! TARGET_POWER && ! TARGET_POWERPC64"
  3239.   "subfc %L0,%L2,%L1\;subfe %0,%2,%1"
  3240.   [(set_attr "length" "8")])
  3241.  
  3242. (define_expand "negdi2"
  3243.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3244.     (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
  3245.   ""
  3246.   "")
  3247.  
  3248. (define_insn ""
  3249.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3250.     (neg:DI (match_operand:DI 1 "gpc_reg_operand" "r")))]
  3251.   "! TARGET_POWERPC64"
  3252.   "{sfi|subfic} %L0,%L1,0\;{sfze|subfze} %0,%1"
  3253.   [(set_attr "length" "8")])
  3254.  
  3255. (define_expand "mulsidi3"
  3256.   [(set (match_operand:DI 0 "gpc_reg_operand" "")
  3257.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" ""))
  3258.          (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" ""))))]
  3259.   ""
  3260.   "
  3261. {
  3262.   if (! TARGET_POWER && ! TARGET_POWERPC)
  3263.     {
  3264.       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  3265.       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  3266.       emit_insn (gen_mull_call ());
  3267.       emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
  3268.               gen_rtx (REG, SImode, 3));
  3269.       emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
  3270.               gen_rtx (REG, SImode, 4));
  3271.       DONE;
  3272.     }
  3273.   else if (TARGET_POWER)
  3274.     {
  3275.       emit_insn (gen_mulsidi3_mq (operands[0], operands[1], operands[2]));
  3276.       DONE;
  3277.     }
  3278. }")
  3279.  
  3280. (define_insn "mulsidi3_mq"
  3281.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3282.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3283.          (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))
  3284.    (clobber (match_scratch:SI 3 "=q"))]
  3285.   "TARGET_POWER"
  3286.   "mul %0,%1,%2\;mfmq %L0"
  3287.   [(set_attr "type" "imul")
  3288.    (set_attr "length" "8")])
  3289.  
  3290. (define_insn ""
  3291.   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r")
  3292.     (mult:DI (sign_extend:DI (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3293.          (sign_extend:DI (match_operand:SI 2 "gpc_reg_operand" "r"))))]
  3294.   "TARGET_POWERPC && ! TARGET_POWERPC64"
  3295.   "mulhw %0,%1,%2\;mullw %L0,%1,%2"
  3296.   [(set_attr "type" "imul")
  3297.    (set_attr "length" "8")])
  3298.  
  3299. (define_expand "smulsi3_highpart"
  3300.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  3301.     (truncate:SI
  3302.      (lshiftrt:DI (mult:DI (sign_extend:DI
  3303.                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3304.                    (sign_extend:DI
  3305.                 (match_operand:SI 2 "gpc_reg_operand" "r")))
  3306.               (const_int 32))))]
  3307.   ""
  3308.   "
  3309. {
  3310.   if (! TARGET_POWER && ! TARGET_POWERPC)
  3311.     {
  3312.       emit_move_insn (gen_rtx (REG, SImode, 3), operands[1]);
  3313.       emit_move_insn (gen_rtx (REG, SImode, 4), operands[2]);
  3314.       emit_insn (gen_mulh_call ());
  3315.       emit_move_insn (operands[0], gen_rtx (REG, SImode, 3));
  3316.       DONE;
  3317.     }
  3318.   else if (TARGET_POWER)
  3319.     {
  3320.       emit_insn (gen_smulsi3_highpart_mq (operands[0], operands[1], operands[2]));
  3321.       DONE;
  3322.     }
  3323. }")
  3324.  
  3325. (define_insn "smulsi3_highpart_mq"
  3326.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  3327.     (truncate:SI
  3328.      (lshiftrt:DI (mult:DI (sign_extend:DI
  3329.                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3330.                    (sign_extend:DI
  3331.                 (match_operand:SI 2 "gpc_reg_operand" "r")))
  3332.               (const_int 32))))
  3333.    (clobber (match_scratch:SI 3 "=q"))]
  3334.   "TARGET_POWER"
  3335.   "mul %0,%1,%2"
  3336.   [(set_attr "type" "imul")])
  3337.  
  3338. (define_insn ""
  3339.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  3340.     (truncate:SI
  3341.      (lshiftrt:DI (mult:DI (sign_extend:DI
  3342.                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3343.                    (sign_extend:DI
  3344.                 (match_operand:SI 2 "gpc_reg_operand" "r")))
  3345.               (const_int 32))))]
  3346.   "TARGET_POWERPC"
  3347.   "mulhw %0,%1,%2"
  3348.   [(set_attr "type" "imul")])
  3349.  
  3350. (define_insn "umulsi3_highpart"
  3351.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  3352.     (truncate:SI
  3353.      (lshiftrt:DI (mult:DI (zero_extend:DI
  3354.                 (match_operand:SI 1 "gpc_reg_operand" "%r"))
  3355.                    (zero_extend:DI
  3356.                 (match_operand:SI 2 "gpc_reg_operand" "r")))
  3357.               (const_int 32))))]
  3358.   "TARGET_POWERPC"
  3359.   "mulhwu %0,%1,%2"
  3360.   [(set_attr "type" "imul")])
  3361.  
  3362. ;; If operands 0 and 2 are in the same register, we have a problem.  But
  3363. ;; operands 0 and 1 (the usual case) can be in the same register.  That's
  3364. ;; why we have the strange constraints below.
  3365. (define_insn "ashldi3"
  3366.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r,r,&r")
  3367.     (ashift:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
  3368.            (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
  3369.    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
  3370.   "TARGET_POWER"
  3371.   "@
  3372.    {sli|slwi} %0,%L1,%h2\;{cal %L0,0(0)|li %L0,0}
  3373.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
  3374.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2
  3375.    sl%I2q %L0,%L1,%h2\;sll%I2q %0,%1,%h2"
  3376.   [(set_attr "length" "8")])
  3377.  
  3378. (define_insn "lshrdi3"
  3379.   [(set (match_operand:DI 0 "gpc_reg_operand" "=&r,r,r,&r")
  3380.     (lshiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r,0,r")
  3381.              (match_operand:SI 2 "reg_or_cint_operand" "M,i,r,r")))
  3382.    (clobber (match_scratch:SI 3 "=X,q,q,q"))]
  3383.   "TARGET_POWER"
  3384.   "@
  3385.    {cal %0,0(0)|li %0,0}\;{s%A2i|s%A2wi} %L0,%1,%h2
  3386.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
  3387.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2
  3388.    sr%I2q %0,%1,%h2\;srl%I2q %L0,%L1,%h2"
  3389.   [(set_attr "length" "8")])
  3390.  
  3391. ;; Shift by a variable amount is too complex to be worth open-coding.  We
  3392. ;; just handle shifts by constants.
  3393.  
  3394. (define_expand "ashrdi3"
  3395.   [(parallel [(set (match_operand:DI 0 "gpc_reg_operand" "")
  3396.            (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "")
  3397.                 (match_operand:SI 2 "general_operand" "")))
  3398.           (clobber (match_scratch:SI 3 ""))])]
  3399.   "TARGET_POWER"
  3400.   "
  3401. { if (GET_CODE (operands[2]) != CONST_INT)
  3402.     FAIL;
  3403. }")
  3404.  
  3405. (define_insn ""
  3406.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r,r")
  3407.     (ashiftrt:DI (match_operand:DI 1 "gpc_reg_operand" "r,r")
  3408.              (match_operand:SI 2 "const_int_operand" "M,i")))
  3409.    (clobber (match_scratch:SI 3 "=X,q"))]
  3410.   "TARGET_POWER"
  3411.   "@
  3412.    {srai|srawi} %0,%1,31\;{srai|srawi} %L0,%1,%h2
  3413.    sraiq %0,%1,%h2\;srliq %L0,%L1,%h2"
  3414.   [(set_attr "length" "8")])
  3415.  
  3416. ;; PowerPC64 DImode operations.
  3417.  
  3418. (define_insn "ffsdi2"
  3419.   [(set (match_operand:DI 0 "register_operand" "=&r")
  3420.     (ffs:DI (match_operand:DI 1 "register_operand" "r")))]
  3421.   "TARGET_POWERPC64"
  3422.   "neg %0,%1\;and %0,%0,%1\;cntlzd %0,%0\;subfic %0,%0,64"
  3423.   [(set_attr "length" "16")])
  3424.  
  3425. (define_insn "muldi3"
  3426.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3427.     (mult:DI (match_operand:DI 1 "gpc_reg_operand" "%r")
  3428.          (match_operand:DI 2 "gpc_reg_operand" "r")))]
  3429.   "TARGET_POWERPC64"
  3430.   "mulld %0,%1,%2"
  3431.    [(set_attr "type" "imul")])
  3432.  
  3433. (define_insn "smuldi3_highpart"
  3434.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3435.     (truncate:DI
  3436.      (lshiftrt:TI (mult:TI (sign_extend:TI
  3437.                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
  3438.                    (sign_extend:TI
  3439.                 (match_operand:DI 2 "gpc_reg_operand" "r")))
  3440.               (const_int 64))))]
  3441.   "TARGET_POWERPC64"
  3442.   "mulhd %0,%1,%2"
  3443.   [(set_attr "type" "imul")])
  3444.  
  3445. (define_insn "umuldi3_highpart"
  3446.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3447.     (truncate:DI
  3448.      (lshiftrt:TI (mult:TI (zero_extend:TI
  3449.                 (match_operand:DI 1 "gpc_reg_operand" "%r"))
  3450.                    (zero_extend:TI
  3451.                 (match_operand:DI 2 "gpc_reg_operand" "r")))
  3452.               (const_int 64))))]
  3453.   "TARGET_POWERPC64"
  3454.   "mulhdu %0,%1,%2"
  3455.   [(set_attr "type" "imul")])
  3456.  
  3457. (define_insn "divdi3"
  3458.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3459.         (div:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3460.                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
  3461.   "TARGET_POWERPC64"
  3462.   "divd %0,%1,%2"
  3463.   [(set_attr "type" "idiv")])
  3464.  
  3465. (define_insn "udivdi3"
  3466.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3467.         (udiv:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3468.                  (match_operand:DI 2 "gpc_reg_operand" "r")))]
  3469.   "TARGET_POWERPC64"
  3470.   "divdu %0,%1,%2"
  3471.   [(set_attr "type" "idiv")])
  3472.  
  3473. (define_insn "rotldi3"
  3474.   [(set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3475.     (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3476.            (match_operand:DI 2 "reg_or_cint_operand" "ri")))]
  3477.   "TARGET_POWERPC64"
  3478.   "rld%I2cl %0,%1,%h2,0")
  3479.  
  3480. (define_insn ""
  3481.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  3482.     (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3483.                    (match_operand:DI 2 "reg_or_cint_operand" "ri"))
  3484.             (const_int 0)))
  3485.    (clobber (match_scratch:DI 3 "=r"))]
  3486.   "TARGET_POWERPC64"
  3487.   "rld%I2cl. %3,%1,%h2,0"
  3488.   [(set_attr "type" "delayed_compare")])
  3489.  
  3490. (define_insn ""
  3491.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  3492.     (compare:CC (rotate:DI (match_operand:DI 1 "gpc_reg_operand" "r")
  3493.                    (match_operand:DI 2 "reg_or_cint_operand" "ri"))
  3494.             (const_int 0)))
  3495.    (set (match_operand:DI 0 "gpc_reg_operand" "=r")
  3496.     (rotate:DI (match_dup 1) (match_dup 2)))]
  3497.   "TARGET_POWERPC64"
  3498.   "rld%I2cl. %0,%1,%h2,0"
  3499.   [(set_attr "type" "delayed_compare")])
  3500.  
  3501. ;; Now define ways of moving data around.
  3502. ;;
  3503. ;; For SI, we special-case integers that can't be loaded in one insn.  We
  3504. ;; do the load 16-bits at a time.  We could do this by loading from memory,
  3505. ;; and this is even supposed to be faster, but it is simpler not to get
  3506. ;; integers in the TOC.
  3507. (define_expand "movsi"
  3508.   [(set (match_operand:SI 0 "general_operand" "")
  3509.     (match_operand:SI 1 "any_operand" ""))]
  3510.   ""
  3511.   "
  3512. {
  3513.   if (GET_CODE (operands[0]) != REG)
  3514.     operands[1] = force_reg (SImode, operands[1]);
  3515.  
  3516.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT
  3517.       && ! LEGITIMATE_CONSTANT_POOL_ADDRESS_P (operands[1]))
  3518.     {
  3519.       /* If we are to limit the number of things we put in the TOC and
  3520.      this is a symbol plus a constant we can add in one insn,
  3521.      just put the sumbol in the TOC and add the constant.  Don't do
  3522.      this if reload is in progress.  */
  3523.       if (GET_CODE (operands[1]) == CONST
  3524.       && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
  3525.       && GET_CODE (XEXP (operands[1], 0)) == PLUS
  3526.       && add_operand (XEXP (XEXP (operands[1], 0), 1), SImode)
  3527.       && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
  3528.           || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
  3529.       && ! side_effects_p (operands[0]))
  3530.     {
  3531.       rtx sym = force_const_mem (SImode, XEXP (XEXP (operands[1], 0), 0));
  3532.       rtx other = XEXP (XEXP (operands[1], 0), 1);
  3533.  
  3534.       emit_insn (gen_addsi3 (operands[0], force_reg (SImode, sym), other));
  3535.       DONE;
  3536.     }
  3537.  
  3538.       operands[1] = force_const_mem (SImode, operands[1]);
  3539.       if (! memory_address_p (SImode, XEXP (operands[1], 0))
  3540.       && ! reload_in_progress)
  3541.     operands[1] = change_address (operands[1], SImode,
  3542.                       XEXP (operands[1], 0));
  3543.     }
  3544.  
  3545.   if (GET_CODE (operands[1]) == CONST_INT
  3546.       && (unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
  3547.       && (INTVAL (operands[1]) & 0xffff) != 0)
  3548.     {
  3549.       emit_move_insn (operands[0],
  3550.               gen_rtx (CONST_INT, VOIDmode,
  3551.                    INTVAL (operands[1]) & 0xffff0000));
  3552.       emit_insn (gen_iorsi3 (operands[0], operands[0],
  3553.                  gen_rtx (CONST_INT, VOIDmode,
  3554.                       INTVAL (operands[1]) & 0xffff)));
  3555.       DONE;
  3556.     }
  3557. }")
  3558.  
  3559. (define_insn ""
  3560.   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*q,*c*l,*h")
  3561.     (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,r,0"))]
  3562.   "TARGET_POWER && (gpc_reg_operand (operands[0], SImode)
  3563.    || gpc_reg_operand (operands[1], SImode))"
  3564.   "@
  3565.    mr %0,%1
  3566.    {l%U1%X1|lwz%U1%X1} %0,%1
  3567.    {st%U0%X0|stw%U0%X0} %1,%0
  3568.    {cal %0,%1(0)|li %0,%1}
  3569.    {cau %0,0,%u1|lis %0,%u1}
  3570.    mf%1 %0
  3571.    mt%0 %1
  3572.    mt%0 %1
  3573.    cror 0,0,0"
  3574.   [(set_attr "type" "*,load,*,*,*,*,*,mtjmpr,*")])
  3575.  
  3576. (define_insn ""
  3577.   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*h,*h")
  3578.     (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,0"))]
  3579.   "! TARGET_POWER && (gpc_reg_operand (operands[0], SImode)
  3580.    || gpc_reg_operand (operands[1], SImode))"
  3581.   "@
  3582.    mr %0,%1
  3583.    lwz%U1%X1 %0,%1
  3584.    stw%U0%X0 %1,%0
  3585.    li %0,%1
  3586.    lis %0,%u1
  3587.    mf%1 %0
  3588.    mt%0 %1
  3589.    cror 0,0,0"
  3590.   [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")])
  3591.  
  3592. ;; Split a load of a large constant into the appropriate two-insn
  3593. ;; sequence.
  3594.  
  3595. (define_split
  3596.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  3597.     (match_operand:SI 1 "const_int_operand" ""))]
  3598.   "(unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000
  3599.    && (INTVAL (operands[1]) & 0xffff) != 0"
  3600.   [(set (match_dup 0)
  3601.     (match_dup 2))
  3602.    (set (match_dup 0)
  3603.     (ior:SI (match_dup 0)
  3604.         (match_dup 3)))]
  3605.   "
  3606. {
  3607.   operands[2] = gen_rtx (CONST_INT, VOIDmode,
  3608.              INTVAL (operands[1]) & 0xffff0000);
  3609.   operands[3] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[1]) & 0xffff);
  3610. }")
  3611.  
  3612. (define_insn ""
  3613.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  3614.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  3615.             (const_int 0)))
  3616.    (set (match_operand:SI 0 "gpc_reg_operand" "=r") (match_dup 1))]
  3617.   ""
  3618.   "mr. %0,%1"
  3619.   [(set_attr "type" "compare")])
  3620.  
  3621. (define_expand "movhi"
  3622.   [(set (match_operand:HI 0 "general_operand" "")
  3623.     (match_operand:HI 1 "any_operand" ""))]
  3624.   ""
  3625.   "
  3626. {
  3627.   if (GET_CODE (operands[0]) != REG)
  3628.     operands[1] = force_reg (HImode, operands[1]);
  3629.  
  3630.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
  3631.     {
  3632.       operands[1] = force_const_mem (HImode, operands[1]);
  3633.       if (! memory_address_p (HImode, XEXP (operands[1], 0))
  3634.       && ! reload_in_progress)
  3635.     operands[1] = change_address (operands[1], HImode,
  3636.                       XEXP (operands[1], 0));
  3637.     }
  3638. }")
  3639.  
  3640. (define_insn ""
  3641.   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
  3642.     (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
  3643.   "TARGET_POWER && (gpc_reg_operand (operands[0], HImode)
  3644.    || gpc_reg_operand (operands[1], HImode))"
  3645.   "@
  3646.    mr %0,%1
  3647.    lhz%U1%X1 %0,%1
  3648.    sth%U0%X0 %1,%0
  3649.    {cal %0,%w1(0)|li %0,%w1}
  3650.    mf%1 %0
  3651.    mt%0 %1
  3652.    mt%0 %1
  3653.    cror 0,0,0"
  3654.   [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")])
  3655.  
  3656. (define_insn ""
  3657.   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h")
  3658.     (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,0"))]
  3659.   "! TARGET_POWER && (gpc_reg_operand (operands[0], HImode)
  3660.    || gpc_reg_operand (operands[1], HImode))"
  3661.   "@
  3662.    mr %0,%1
  3663.    lhz%U1%X1 %0,%1
  3664.    sth%U0%X0 %1,%0
  3665.    li %0,%w1
  3666.    mf%1 %0
  3667.    mt%0 %1
  3668.    cror 0,0,0"
  3669.   [(set_attr "type" "*,load,*,*,*,mtjmpr,*")])
  3670.  
  3671. (define_expand "movqi"
  3672.   [(set (match_operand:QI 0 "general_operand" "")
  3673.     (match_operand:QI 1 "any_operand" ""))]
  3674.   ""
  3675.   "
  3676. {
  3677.   if (GET_CODE (operands[0]) != REG)
  3678.     operands[1] = force_reg (QImode, operands[1]);
  3679.  
  3680.   if (CONSTANT_P (operands[1]) && GET_CODE (operands[1]) != CONST_INT)
  3681.     {
  3682.       operands[1] = force_const_mem (QImode, operands[1]);
  3683.       if (! memory_address_p (QImode, XEXP (operands[1], 0))
  3684.       && ! reload_in_progress)
  3685.     operands[1] = change_address (operands[1], QImode,
  3686.                       XEXP (operands[1], 0));
  3687.     }
  3688. }")
  3689.  
  3690. (define_insn ""
  3691.   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h")
  3692.     (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))]
  3693.   "TARGET_POWER && (gpc_reg_operand (operands[0], QImode)
  3694.    || gpc_reg_operand (operands[1], QImode))"
  3695.   "@
  3696.    mr %0,%1
  3697.    lbz%U1%X1 %0,%1
  3698.    stb%U0%X0 %1,%0
  3699.    {cal %0,%1(0)|li %0,%1}
  3700.    mf%1 %0
  3701.    mt%0 %1
  3702.    mt%0 %1
  3703.    cror 0,0,0"
  3704.   [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")])
  3705.  
  3706. (define_insn ""
  3707.   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h")
  3708.     (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,0"))]
  3709.   "! TARGET_POWER && (gpc_reg_operand (operands[0], QImode)
  3710.    || gpc_reg_operand (operands[1], QImode))"
  3711.   "@
  3712.    mr %0,%1
  3713.    lbz%U1%X1 %0,%1
  3714.    stb%U0%X0 %1,%0
  3715.    li %0,%1
  3716.    mf%1 %0
  3717.    mt%0 %1
  3718.    cror 0,0,0"
  3719.   [(set_attr "type" "*,load,*,*,*,mtjmpr,*")])
  3720.  
  3721. ;; Here is how to move condition codes around.  When we store CC data in
  3722. ;; an integer register or memory, we store just the high-order 4 bits.
  3723. ;; This lets us not shift in the most common case of CR0.
  3724. (define_expand "movcc"
  3725.   [(set (match_operand:CC 0 "nonimmediate_operand" "")
  3726.     (match_operand:CC 1 "nonimmediate_operand" ""))]
  3727.   ""
  3728.   "")
  3729.  
  3730. (define_insn ""
  3731.   [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,y,r,r,r,r,m")
  3732.     (match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,m,r"))]
  3733.   "register_operand (operands[0], CCmode)
  3734.    || register_operand (operands[1], CCmode)"
  3735.   "@
  3736.    mcrf %0,%1
  3737.    mtcrf 128,%1
  3738.    {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
  3739.    mfcr %0
  3740.    mfcr %0\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
  3741.    mr %0,%1
  3742.    {l%U1%X1|lwz%U1%X1} %0,%1
  3743.    {st%U0%U1|stw%U0%U1} %1,%0"
  3744.   [(set_attr "type" "*,*,*,compare,*,*,load,*")
  3745.    (set_attr "length" "*,*,12,*,8,*,*,*")])
  3746.  
  3747. ;; For floating-point, we normally deal with the floating-point registers.
  3748. ;; The sole exception is that parameter passing can produce floating-point
  3749. ;; values in fixed-point registers.  Unless the value is a simple constant
  3750. ;; or already in memory, we deal with this by allocating memory and copying
  3751. ;; the value explicitly via that memory location.
  3752. (define_expand "movsf"
  3753.   [(set (match_operand:SF 0 "nonimmediate_operand" "")
  3754.     (match_operand:SF 1 "any_operand" ""))]
  3755.   ""
  3756.   "
  3757. {
  3758.   /* If we are called from reload, we might be getting a SUBREG of a hard
  3759.      reg.  So expand it.  */
  3760.   if (GET_CODE (operands[0]) == SUBREG
  3761.       && GET_CODE (SUBREG_REG (operands[0])) == REG
  3762.       && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER)
  3763.     operands[0] = alter_subreg (operands[0]);
  3764.   if (GET_CODE (operands[1]) == SUBREG
  3765.       && GET_CODE (SUBREG_REG (operands[1])) == REG
  3766.       && REGNO (SUBREG_REG (operands[1])) < FIRST_PSEUDO_REGISTER)
  3767.     operands[1] = alter_subreg (operands[1]);
  3768.  
  3769.   if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 32)
  3770.     {
  3771.       /* If this is a store to memory or another integer register do the
  3772.      move directly.  Otherwise store to a temporary stack slot and
  3773.      load from there into a floating point register.  */
  3774.  
  3775.       if (GET_CODE (operands[0]) == MEM
  3776.       || (GET_CODE (operands[0]) == REG
  3777.           && (REGNO (operands[0]) < 32
  3778.           || (reload_in_progress
  3779.               && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))))
  3780.     {
  3781.       emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
  3782.               operand_subword (operands[1], 0, 0, SFmode));
  3783.       DONE;
  3784.     }
  3785.       else
  3786.     {
  3787.       rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
  3788.  
  3789.       emit_move_insn (stack_slot, operands[1]);
  3790.       emit_move_insn (operands[0], stack_slot);
  3791.       DONE;
  3792.     }
  3793.     }
  3794.  
  3795.   if (GET_CODE (operands[0]) == MEM)
  3796.     {
  3797.       operands[1] = force_reg (SFmode, operands[1]);
  3798.       if (! TARGET_POWERPC)
  3799.     if (reload_in_progress || reload_completed)
  3800.       emit_insn (gen_truncdfsf2 (operands[1],
  3801.                      gen_rtx (SUBREG, DFmode, operands[1], 0)));
  3802.     else
  3803.       {
  3804.         rtx newreg = gen_reg_rtx (SFmode);
  3805.         emit_insn (gen_truncdfsf2 (newreg,
  3806.                                        gen_rtx (SUBREG, DFmode, operands[1], 0)));
  3807.         operands[1] = newreg;
  3808.           }
  3809.     }
  3810.  
  3811.   if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) < 32)
  3812.     {
  3813.       if (GET_CODE (operands[1]) == MEM
  3814. #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && ! defined(REAL_IS_NOT_DOUBLE)
  3815.       || GET_CODE (operands[1]) == CONST_DOUBLE
  3816. #endif
  3817.       || (GET_CODE (operands[1]) == REG
  3818.           && (REGNO (operands[1]) < 32
  3819.           || (reload_in_progress
  3820.               && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER))))
  3821.     {
  3822.       emit_move_insn (operand_subword (operands[0], 0, 0, SFmode),
  3823.               operand_subword (operands[1], 0, 0, SFmode));
  3824.       DONE;
  3825.     }
  3826.       else
  3827.     {
  3828.       rtx stack_slot = assign_stack_temp (SFmode, 4, 0);
  3829.  
  3830.       emit_move_insn (stack_slot, operands[1]);
  3831.       emit_move_insn (operands[0], stack_slot);
  3832.       DONE;
  3833.     }
  3834.     }
  3835.  
  3836.   if (CONSTANT_P (operands[1]))
  3837.     {
  3838.       operands[1] = force_const_mem (SFmode, operands[1]);
  3839.       if (! memory_address_p (SFmode, XEXP (operands[1], 0))
  3840.       && ! reload_in_progress)
  3841.     operands[1] = change_address (operands[1], SFmode,
  3842.                       XEXP (operands[1], 0));
  3843.     }
  3844. }")
  3845.  
  3846. (define_split
  3847.   [(set (match_operand:SF 0 "gpc_reg_operand" "")
  3848.     (match_operand:SF 1 "easy_fp_constant" ""))]
  3849.   "reload_completed && REGNO (operands[0]) <= 31"
  3850.   [(set (match_dup 2) (match_dup 3))]
  3851.   "
  3852. { operands[2] = operand_subword (operands[0], 0, 0, SFmode);
  3853.   operands[3] = operand_subword (operands[1], 0, 0, SFmode); }")
  3854.   
  3855. (define_insn ""
  3856.   [(set (match_operand:SF 0 "fp_reg_or_mem_operand" "=f,f,m")
  3857.     (match_operand:SF 1 "input_operand" "f,m,f"))]
  3858.   "gpc_reg_operand (operands[0], SFmode)
  3859.    || gpc_reg_operand (operands[1], SFmode)"
  3860.   "@
  3861.    fmr %0,%1
  3862.    lfs%U1%X1 %0,%1
  3863.    stfs%U0%X0 %1,%0"
  3864.   [(set_attr "type" "fp,fpload,*")
  3865.    (set_attr "length" "*,*,8")])
  3866.  
  3867. (define_expand "movdf"
  3868.   [(set (match_operand:DF 0 "nonimmediate_operand" "")
  3869.     (match_operand:DF 1 "any_operand" ""))]
  3870.   ""
  3871.   "
  3872. {
  3873.   if (GET_CODE (operands[0]) == MEM && GET_CODE (operands[1]) == MEM)
  3874.     {
  3875.       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
  3876.               operand_subword_force (operands[1], 1, DFmode));
  3877.       emit_move_insn (operand_subword (operands[0], 0, 1, DFmode),
  3878.               operand_subword_force (operands[1], 0, DFmode));
  3879.       DONE;
  3880.     }
  3881.  
  3882.   if (GET_CODE (operands[0]) != REG)
  3883.     operands[1] = force_reg (DFmode, operands[1]);
  3884.  
  3885.   if (CONSTANT_P (operands[1]) && ! easy_fp_constant (operands[1], DFmode))
  3886.     {
  3887.       operands[1] = force_const_mem (DFmode, operands[1]);
  3888.       if (! memory_address_p (DFmode, XEXP (operands[1], 0))
  3889.       && ! reload_in_progress)
  3890.     operands[1] = change_address (operands[1], DFmode,
  3891.                       XEXP (operands[1], 0));
  3892.     }
  3893. }")
  3894.  
  3895. (define_split
  3896.   [(set (match_operand:DF 0 "gpc_reg_operand" "")
  3897.     (match_operand:DF 1 "easy_fp_constant" ""))]
  3898.   "reload_completed && REGNO (operands[0]) <= 31"
  3899.   [(set (match_dup 2) (match_dup 3))
  3900.    (set (match_dup 4) (match_dup 5))]
  3901.   "
  3902. { operands[2] = operand_subword (operands[0], 0, 0, DFmode);
  3903.   operands[3] = operand_subword (operands[1], 0, 0, DFmode);
  3904.   operands[4] = operand_subword (operands[0], 1, 0, DFmode);
  3905.   operands[5] = operand_subword (operands[1], 1, 0, DFmode); }")
  3906.  
  3907. ;; Don't have reload use general registers to load a constant.  First,
  3908. ;; it might not work if the output operand has is the equivalent of
  3909. ;; a non-offsettable memref, but also it is less efficient than loading
  3910. ;; the constant into an FP register, since it will probably be used there.
  3911. ;; The "??" is a kludge until we can figure out a more reasonable way
  3912. ;; of handling these non-offsettable values.
  3913. (define_insn ""
  3914.   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,f,f,m")
  3915.     (match_operand:DF 1 "input_operand" "r,o,r,G,f,m,f"))]
  3916.   "! TARGET_POWERPC64 && (register_operand (operands[0], DFmode)
  3917.    || register_operand (operands[1], DFmode))"
  3918.   "*
  3919. {
  3920.   switch (which_alternative)
  3921.     {
  3922.     case 0:
  3923.       /* We normally copy the low-numbered register first.  However, if
  3924.      the first register operand 0 is the same as the second register of
  3925.      operand 1, we must copy in the opposite order.  */
  3926.       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
  3927.     return \"mr %L0,%L1\;mr %0,%1\";
  3928.       else
  3929.     return \"mr %0,%1\;mr %L0,%L1\";
  3930.     case 1:
  3931.       /* If the low-address word is used in the address, we must load it
  3932.      last.  Otherwise, load it first.  Note that we cannot have
  3933.      auto-increment in that case since the address register is known to be
  3934.      dead.  */
  3935.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  3936.                  operands [1], 0))
  3937.     return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
  3938.       else
  3939.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
  3940.     case 2:
  3941.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
  3942.     case 3:
  3943.       return \"#\";
  3944.     case 4:
  3945.       return \"fmr %0,%1\";
  3946.     case 5:
  3947.       return \"lfd%U1%X1 %0,%1\";
  3948.     case 6:
  3949.       return \"stfd%U0%X0 %1,%0\";
  3950.     }
  3951. }"
  3952.   [(set_attr "type" "*,load,*,*,fp,fpload,*")
  3953.    (set_attr "length" "8,8,8,8,*,*,*")])
  3954.  
  3955. (define_insn ""
  3956.   [(set (match_operand:DF 0 "nonimmediate_operand" "=!r,??r,o,!r,f,f,m")
  3957.     (match_operand:DF 1 "input_operand" "r,o,r,G,f,m,f"))]
  3958.   "TARGET_POWERPC64 && (register_operand (operands[0], DFmode)
  3959.    || register_operand (operands[1], DFmode))"
  3960.   "@
  3961.    mr %0,%1
  3962.    ld%U1%X1 %0,%1
  3963.    sd%U0%X0 %1,%0
  3964.    #
  3965.    fmr %0,%1
  3966.    lfd%U1%X1 %0,%1
  3967.    stfd%U0%X0 %1,%0"
  3968.   [(set_attr "type" "*,load,*,*,fp,fpload,*")])
  3969.  
  3970. ;; Next come the multi-word integer load and store and the load and store
  3971. ;; multiple insns.
  3972. (define_expand "movdi"
  3973.   [(set (match_operand:DI 0 "general_operand" "")
  3974.     (match_operand:DI 1 "general_operand" ""))]
  3975.   ""
  3976.   "
  3977. {
  3978.   if (GET_CODE (operands[1]) == CONST_DOUBLE
  3979.       || GET_CODE (operands[1]) == CONST_INT)
  3980.     {
  3981.       emit_move_insn (operand_subword (operands[0], 0, 0, DImode),
  3982.               operand_subword (operands[1], 0, 0, DImode));
  3983.       emit_move_insn (operand_subword (operands[0], 1, 0, DImode),
  3984.               operand_subword (operands[1], 1, 0, DImode));
  3985.       DONE;
  3986.     }
  3987.  
  3988.   if (GET_CODE (operands[0]) == MEM)
  3989.     operands[1] = force_reg (DImode, operands[1]);
  3990.  
  3991.       /* Stores between FPR and any non-FPR registers must go through a
  3992.          temporary stack slot.  */
  3993.  
  3994.   if (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
  3995.       && ((FP_REGNO_P (REGNO (operands[0]))
  3996.        && ! FP_REGNO_P (REGNO (operands[1])))
  3997.       || (FP_REGNO_P (REGNO (operands[1]))
  3998.           && ! FP_REGNO_P (REGNO (operands[0])))))
  3999.     {
  4000.       rtx stack_slot = assign_stack_temp (DImode, 8, 0);
  4001.  
  4002.       emit_move_insn (stack_slot, operands[1]);
  4003.       emit_move_insn (operands[0], stack_slot);
  4004.       DONE;
  4005.     }
  4006. }")
  4007.  
  4008. (define_insn ""
  4009.   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,f,f,m")
  4010.     (match_operand:DI 1 "input_operand" "r,m,r,f,m,f"))]
  4011.   "! TARGET_POWERPC64 && (gpc_reg_operand (operands[0], DImode)
  4012.    || gpc_reg_operand (operands[1], DImode))"
  4013.   "*
  4014. {
  4015.   switch (which_alternative)
  4016.     {
  4017.     case 0:
  4018.       /* We normally copy the low-numbered register first.  However, if
  4019.      the first register operand 0 is the same as the second register of
  4020.      operand 1, we must copy in the opposite order.  */
  4021.       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
  4022.     return \"mr %L0,%L1\;mr %0,%1\";
  4023.       else
  4024.     return \"mr %0,%1\;mr %L0,%L1\";
  4025.     case 1:
  4026.       /* If the low-address word is used in the address, we must load it
  4027.      last.  Otherwise, load it first.  Note that we cannot have
  4028.      auto-increment in that case since the address register is known to be
  4029.      dead.  */
  4030.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  4031.                  operands [1], 0))
  4032.     return \"{l|lwz} %L0,%L1\;{l|lwz} %0,%1\";
  4033.       else
  4034.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\";
  4035.     case 2:
  4036.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\";
  4037.     case 3:
  4038.       return \"fmr %0,%1\";
  4039.     case 4:
  4040.       return \"lfd%U1%X1 %0,%1\";
  4041.     case 5:
  4042.       return \"stfd%U0%X0 %1,%0\";
  4043.     }
  4044. }"
  4045.   [(set_attr "type" "*,load,*,fp,fpload,*")
  4046.    (set_attr "length" "8,8,8,*,*,*")])
  4047.  
  4048. (define_insn ""
  4049.   [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m,r,r,f,f,m,r,*h")
  4050.     (match_operand:DI 1 "input_operand" "r,m,r,I,J,f,m,f,*h,r"))]
  4051.   "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], DImode)
  4052.    || gpc_reg_operand (operands[1], DImode))"
  4053.   "@
  4054.    mr %0,%1
  4055.    ld%U1%X1 %0,%1
  4056.    sd%U0%X0 %1,%0
  4057.    li %0,%1
  4058.    lis %0,%u1
  4059.    fmr %0,%1
  4060.    lfd%U1%X1 %0,%1
  4061.    stfd%U0%X0 %1,%0
  4062.    mf%1 %0
  4063.    mt%0 %1"
  4064.   [(set_attr "type" "*,load,*,*,*,fp,fpload,*,*,mtjmpr")])
  4065.  
  4066. ;; TImode is similar, except that we usually want to compute the address into
  4067. ;; a register and use lsi/stsi (the exception is during reload).  MQ is also
  4068. ;; clobbered in stsi for POWER, so we need a SCRATCH for it.
  4069. (define_expand "movti"
  4070.   [(parallel [(set (match_operand:TI 0 "general_operand" "")
  4071.            (match_operand:TI 1 "general_operand" ""))
  4072.           (clobber (scratch:SI))])]
  4073.   "TARGET_POWER || TARGET_POWERPC64"
  4074.   "
  4075. {
  4076.   if (GET_CODE (operands[0]) == MEM)
  4077.     operands[1] = force_reg (TImode, operands[1]);
  4078.  
  4079.   if (GET_CODE (operands[0]) == MEM
  4080.       && GET_CODE (XEXP (operands[0], 0)) != REG
  4081.       && ! reload_in_progress)
  4082.     operands[0] = change_address (operands[0], TImode,
  4083.                   copy_addr_to_reg (XEXP (operands[0], 0)));
  4084.  
  4085.   if (GET_CODE (operands[1]) == MEM
  4086.       && GET_CODE (XEXP (operands[1], 0)) != REG
  4087.       && ! reload_in_progress)
  4088.     operands[1] = change_address (operands[1], TImode,
  4089.                   copy_addr_to_reg (XEXP (operands[1], 0)));
  4090. }")
  4091.  
  4092. ;; We say that MQ is clobbered in the last alternative because the first
  4093. ;; alternative would never get used otherwise since it would need a reload
  4094. ;; while the 2nd alternative would not.  We put memory cases first so they
  4095. ;; are preferred.  Otherwise, we'd try to reload the output instead of
  4096. ;; giving the SCRATCH mq.
  4097. (define_insn ""
  4098.   [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,m,????r,????r,????r")
  4099.     (match_operand:TI 1 "reg_or_mem_operand" "r,r,r,Q,m"))
  4100.    (clobber (match_scratch:SI 2 "=q,q#X,X,X,X"))]
  4101.   "TARGET_POWER && ! TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
  4102.    || gpc_reg_operand (operands[1], TImode))"
  4103.   "*
  4104. {
  4105.   switch (which_alternative)
  4106.     {
  4107.     case 0:
  4108.       return \"{stsi|stswi} %1,%P0,16\";
  4109.  
  4110.     case 1:
  4111.       return \"{st%U0|stw%U0} %1,%0\;{st|stw} %L1,%L0\;{st|stw} %Y1,%Y0\;{st|stw} %Z1,%Z0\";
  4112.  
  4113.     case 2:
  4114.       /* Normally copy registers with lowest numbered register copied first.
  4115.      But copy in the other order if the first register of the output
  4116.      is the second, third, or fourth register in the input.  */
  4117.       if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
  4118.       && REGNO (operands[0]) <= REGNO (operands[1]) + 3)
  4119.     return \"mr %Z0,%Z1\;mr %Y0,%Y1\;mr %L0,%L1\;mr %0,%1\";
  4120.       else
  4121.     return \"mr %0,%1\;mr %L0,%L1\;mr %Y0,%Y1\;mr %Z0,%Z1\";
  4122.     case 3:
  4123.       /* If the address is not used in the output, we can use lsi.  Otherwise,
  4124.      fall through to generating four loads.  */
  4125.       if (! reg_overlap_mentioned_p (operands[0], operands[1]))
  4126.     return \"{lsi|lswi} %0,%P1,16\";
  4127.       /* ... fall through ... */
  4128.     case 4:
  4129.       /* If the address register is the same as the register for the lowest-
  4130.      addressed word, load it last.  Similarly for the next two words.
  4131.      Otherwise load lowest address to highest.  */
  4132.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  4133.                  operands[1], 0))
  4134.     return \"{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %0,%1\";
  4135.       else if (refers_to_regno_p (REGNO (operands[0]) + 1,
  4136.                   REGNO (operands[0]) + 2, operands[1], 0))
  4137.     return \"{l|lwz} %0,%1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\;{l|lwz} %L0,%L1\";
  4138.       else if (refers_to_regno_p (REGNO (operands[0]) + 2,
  4139.                   REGNO (operands[0]) + 3, operands[1], 0))
  4140.     return \"{l|lwz} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Z0,%Z1\;{l|lwz} %Y0,%Y1\";
  4141.       else
  4142.     return \"{l%U1|lwz%U1} %0,%1\;{l|lwz} %L0,%L1\;{l|lwz} %Y0,%Y1\;{l|lwz} %Z0,%Z1\";
  4143.     }
  4144. }"
  4145.   [(set_attr "type" "*,load,load,*,*")
  4146.    (set_attr "length" "*,16,16,*,16")])
  4147.  
  4148. (define_insn ""
  4149.   [(set (match_operand:TI 0 "nonimmediate_operand" "=r,r,m")
  4150.     (match_operand:TI 1 "input_operand" "r,m,r"))]
  4151.   "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode)
  4152.    || gpc_reg_operand (operands[1], TImode))"
  4153.   "*
  4154. {
  4155.   switch (which_alternative)
  4156.     {
  4157.     case 0:
  4158.       /* We normally copy the low-numbered register first.  However, if
  4159.      the first register operand 0 is the same as the second register of
  4160.      operand 1, we must copy in the opposite order.  */
  4161.       if (REGNO (operands[0]) == REGNO (operands[1]) + 1)
  4162.     return \"mr %L0,%L1\;mr %0,%1\";
  4163.       else
  4164.     return \"mr %0,%1\;mr %L0,%L1\";
  4165.     case 1:
  4166.       /* If the low-address word is used in the address, we must load it
  4167.      last.  Otherwise, load it first.  Note that we cannot have
  4168.      auto-increment in that case since the address register is known to be
  4169.      dead.  */
  4170.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  4171.                  operands [1], 0))
  4172.     return \"ld %L0,%L1\;ld %0,%1\";
  4173.       else
  4174.     return \"ld%U1 %0,%1\;ld %L0,%L1\";
  4175.     case 2:
  4176.       return \"std%U0 %1,%0\;std %L1,%L0\";
  4177.     }
  4178. }"
  4179.   [(set_attr "type" "*,load,*")
  4180.    (set_attr "length" "8,8,8")])
  4181.  
  4182. (define_expand "load_multiple"
  4183.   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
  4184.               (match_operand:SI 1 "" ""))
  4185.              (use (match_operand:SI 2 "" ""))])]
  4186.   "TARGET_POWER"
  4187.   "
  4188. {
  4189.   int regno;
  4190.   int count;
  4191.   rtx from;
  4192.   int i;
  4193.  
  4194.   /* Support only loading a constant number of fixed-point registers from
  4195.      memory and only bother with this if more than two; the machine
  4196.      doesn't support more than eight.  */
  4197.   if (GET_CODE (operands[2]) != CONST_INT
  4198.       || INTVAL (operands[2]) <= 2
  4199.       || INTVAL (operands[2]) > 8
  4200.       || GET_CODE (operands[1]) != MEM
  4201.       || GET_CODE (operands[0]) != REG
  4202.       || REGNO (operands[0]) >= 32)
  4203.     FAIL;
  4204.  
  4205.   count = INTVAL (operands[2]);
  4206.   regno = REGNO (operands[0]);
  4207.  
  4208.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count));
  4209.   from = force_reg (SImode, XEXP (operands[1], 0));
  4210.  
  4211.   for (i = 0; i < count; i++)
  4212.     XVECEXP (operands[3], 0, i)
  4213.       = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
  4214.          gen_rtx (MEM, SImode, plus_constant (from, i * 4)));
  4215. }")
  4216.  
  4217. (define_insn ""
  4218.   [(match_parallel 0 "load_multiple_operation"
  4219.            [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
  4220.              (match_operand:SI 2 "indirect_operand" "Q"))])]
  4221.   "TARGET_POWER"
  4222.   "*
  4223. {
  4224.   /* We have to handle the case where the pseudo used to contain the address
  4225.      is assigned to one of the output registers.  In that case, do the
  4226.      lsi, but then load the correct value.  This is a bit of a mess, but is
  4227.      the best we can do.
  4228.      We set the length attribute to the maximum possible size (8 bytes).  */
  4229.   static char result[100];
  4230.   char newload[40];
  4231.   int i;
  4232.  
  4233.   strcpy (result, \"{lsi|lswi} %1,%P2,%N0\");
  4234.   for (i = 0; i < XVECLEN (operands[0], 0); i++)
  4235.     if (refers_to_regno_p (REGNO (operands[1]) + i,
  4236.                REGNO (operands[1]) + i + 1, operands[2], 0))
  4237.       {
  4238.     sprintf (newload, \"\;{l|lwz} %d,%d(%d)\",
  4239.          REGNO (operands[1]) + i,
  4240.          i * 4, REGNO (XEXP (operands[2], 0)));
  4241.     strcat (result, newload);
  4242.       }
  4243.  
  4244.   return result;
  4245. }"
  4246.   [(set_attr "type" "load")
  4247.    (set_attr "length" "8")])
  4248.  
  4249.  
  4250. (define_expand "store_multiple"
  4251.   [(match_par_dup 3 [(set (match_operand:SI 0 "" "")
  4252.               (match_operand:SI 1 "" ""))
  4253.              (clobber (scratch:SI))
  4254.              (use (match_operand:SI 2 "" ""))])]
  4255.   "TARGET_POWER"
  4256.   "
  4257. {
  4258.   int regno;
  4259.   int count;
  4260.   rtx to;
  4261.   int i;
  4262.  
  4263.   /* Support only storing a constant number of fixed-point registers to
  4264.      memory and only bother with this if more than two; the machine
  4265.      doesn't support more than eight.  */
  4266.   if (GET_CODE (operands[2]) != CONST_INT
  4267.       || INTVAL (operands[2]) <= 2
  4268.       || INTVAL (operands[2]) > 8
  4269.       || GET_CODE (operands[0]) != MEM
  4270.       || GET_CODE (operands[1]) != REG
  4271.       || REGNO (operands[1]) >= 32)
  4272.     FAIL;
  4273.  
  4274.   count = INTVAL (operands[2]);
  4275.   regno = REGNO (operands[1]);
  4276.  
  4277.   operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
  4278.   to = force_reg (SImode, XEXP (operands[0], 0));
  4279.  
  4280.   XVECEXP (operands[3], 0, 0)
  4281.     = gen_rtx (SET, VOIDmode, gen_rtx (MEM, SImode, to), operands[1]);
  4282.   XVECEXP (operands[3], 0, 1) = gen_rtx (CLOBBER, VOIDmode,
  4283.                           gen_rtx (SCRATCH, SImode));
  4284.  
  4285.   for (i = 1; i < count; i++)
  4286.     XVECEXP (operands[3], 0, i + 1)
  4287.       = gen_rtx (SET, VOIDmode,
  4288.          gen_rtx (MEM, SImode, plus_constant (to, i * 4)),
  4289.          gen_rtx (REG, SImode, regno + i));
  4290. }")
  4291.  
  4292. (define_insn ""
  4293.   [(match_parallel 0 "store_multiple_operation"
  4294.            [(set (match_operand:SI 1 "indirect_operand" "=Q")
  4295.              (match_operand:SI 2 "gpc_reg_operand" "r"))
  4296.             (clobber (match_scratch:SI 3 "=q"))])]
  4297.   "TARGET_POWER"
  4298.   "{stsi|stswi} %2,%P1,%O0")
  4299.  
  4300. ;; Define insns that do load or store with update.  Some of these we can 
  4301. ;; get by using pre-decrement or pre-increment, but the hardware can also
  4302. ;; do cases where the increment is not the size of the object.
  4303. ;;
  4304. ;; In all these cases, we use operands 0 and 1 for the register being
  4305. ;; incremented because those are the operands that local-alloc will
  4306. ;; tie and these are the pair most likely to be tieable (and the ones
  4307. ;; that will benefit the most).
  4308.  
  4309. (define_insn ""
  4310.   [(set (match_operand:DI 3 "gpc_reg_operand" "=r,r")
  4311.     (mem:SI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
  4312.              (match_operand:DI 2 "reg_or_short_operand" "r,I"))))
  4313.    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
  4314.     (plus:DI (match_dup 1) (match_dup 2)))]
  4315.   "TARGET_POWERPC64"
  4316.   "@
  4317.    ldux %3,%0,%2
  4318.    ldu %3,%2(%0)"
  4319.   [(set_attr "type" "load")])
  4320.  
  4321. (define_insn ""
  4322.   [(set (mem:DI (plus:DI (match_operand:DI 1 "gpc_reg_operand" "0,0")
  4323.              (match_operand:DI 2 "reg_or_short_operand" "r,I")))
  4324.     (match_operand:DI 3 "gpc_reg_operand" "r,r"))
  4325.    (set (match_operand:DI 0 "gpc_reg_operand" "=b,b")
  4326.     (plus:DI (match_dup 1) (match_dup 2)))]
  4327.   "TARGET_POWERPC64"
  4328.   "@
  4329.    stdux %3,%0,%2
  4330.    stdu %3,%2(%0)")
  4331.  
  4332. (define_insn ""
  4333.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  4334.     (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4335.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  4336.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4337.     (plus:SI (match_dup 1) (match_dup 2)))]
  4338.   ""
  4339.   "@
  4340.    {lux|lwzux} %3,%0,%2
  4341.    {lu|lwzu} %3,%2(%0)"
  4342.   [(set_attr "type" "load")])
  4343.  
  4344. (define_insn ""
  4345.   [(set (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4346.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  4347.     (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  4348.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4349.     (plus:SI (match_dup 1) (match_dup 2)))]
  4350.   ""
  4351.   "@
  4352.    {stux|stwux} %3,%0,%2
  4353.    {stu|stwu} %3,%2(%0)")
  4354.  
  4355. (define_insn ""
  4356.   [(set (match_operand:HI 3 "gpc_reg_operand" "=r,r")
  4357.     (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4358.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  4359.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4360.     (plus:SI (match_dup 1) (match_dup 2)))]
  4361.   ""
  4362.   "@
  4363.    lhzux %3,%0,%2
  4364.    lhzu %3,%2(%0)"
  4365.   [(set_attr "type" "load")])
  4366.  
  4367. (define_insn ""
  4368.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  4369.     (zero_extend:SI
  4370.      (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4371.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  4372.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4373.     (plus:SI (match_dup 1) (match_dup 2)))]
  4374.   ""
  4375.   "@
  4376.    lhzux %3,%0,%2
  4377.    lhzu %3,%2(%0)"
  4378.   [(set_attr "type" "load")])
  4379.  
  4380. (define_insn ""
  4381.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  4382.     (sign_extend:SI
  4383.      (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4384.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  4385.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4386.     (plus:SI (match_dup 1) (match_dup 2)))]
  4387.   ""
  4388.   "@
  4389.    lhaux %3,%0,%2
  4390.    lhau %3,%2(%0)"
  4391.   [(set_attr "type" "load")])
  4392.  
  4393. (define_insn ""
  4394.   [(set (mem:HI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4395.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  4396.     (match_operand:HI 3 "gpc_reg_operand" "r,r"))
  4397.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4398.     (plus:SI (match_dup 1) (match_dup 2)))]
  4399.   ""
  4400.   "@
  4401.    sthux %3,%0,%2
  4402.    sthu %3,%2(%0)")
  4403.  
  4404. (define_insn ""
  4405.   [(set (match_operand:QI 3 "gpc_reg_operand" "=r,r")
  4406.     (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4407.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  4408.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4409.     (plus:SI (match_dup 1) (match_dup 2)))]
  4410.   ""
  4411.   "@
  4412.    lbzux %3,%0,%2
  4413.    lbzu %3,%2(%0)"
  4414.   [(set_attr "type" "load")])
  4415.  
  4416. (define_insn ""
  4417.   [(set (match_operand:SI 3 "gpc_reg_operand" "=r,r")
  4418.     (zero_extend:SI
  4419.      (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4420.               (match_operand:SI 2 "reg_or_short_operand" "r,I")))))
  4421.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4422.     (plus:SI (match_dup 1) (match_dup 2)))]
  4423.   ""
  4424.   "@
  4425.    lbzux %3,%0,%2
  4426.    lbzu %3,%2(%0)"
  4427.   [(set_attr "type" "load")])
  4428.  
  4429. (define_insn ""
  4430.   [(set (mem:QI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4431.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  4432.     (match_operand:QI 3 "gpc_reg_operand" "r,r"))
  4433.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4434.     (plus:SI (match_dup 1) (match_dup 2)))]
  4435.   ""
  4436.   "@
  4437.    stbux %3,%0,%2
  4438.    stbu %3,%2(%0)")
  4439.  
  4440. (define_insn ""
  4441.   [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f")
  4442.     (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4443.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  4444.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4445.     (plus:SI (match_dup 1) (match_dup 2)))]
  4446.   ""
  4447.   "@
  4448.    lfsux %3,%0,%2
  4449.    lfsu %3,%2(%0)"
  4450.   [(set_attr "type" "fpload")])
  4451.  
  4452. (define_insn ""
  4453.   [(set (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4454.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  4455.     (match_operand:SF 3 "gpc_reg_operand" "f,f"))
  4456.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4457.     (plus:SI (match_dup 1) (match_dup 2)))]
  4458.   ""
  4459.   "@
  4460.    stfsux %3,%0,%2
  4461.    stfsu %3,%2(%0)")
  4462.  
  4463. (define_insn ""
  4464.   [(set (match_operand:DF 3 "gpc_reg_operand" "=f,f")
  4465.     (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4466.              (match_operand:SI 2 "reg_or_short_operand" "r,I"))))
  4467.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4468.     (plus:SI (match_dup 1) (match_dup 2)))]
  4469.   ""
  4470.   "@
  4471.    lfdux %3,%0,%2
  4472.    lfdu %3,%2(%0)"
  4473.   [(set_attr "type" "fpload")])
  4474.  
  4475. (define_insn ""
  4476.   [(set (mem:DF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0")
  4477.              (match_operand:SI 2 "reg_or_short_operand" "r,I")))
  4478.     (match_operand:DF 3 "gpc_reg_operand" "f,f"))
  4479.    (set (match_operand:SI 0 "gpc_reg_operand" "=b,b")
  4480.     (plus:SI (match_dup 1) (match_dup 2)))]
  4481.   ""
  4482.   "@
  4483.    stfdux %3,%0,%2
  4484.    stfdu %3,%2(%0)")
  4485.  
  4486. ;; Next come insns related to the calling sequence.
  4487. ;;
  4488. ;; First, an insn to allocate new stack space for dynamic use (e.g., alloca).
  4489. ;; We move the back-chain and decrement the stack pointer.  
  4490.  
  4491. (define_expand "allocate_stack"
  4492.   [(set (reg:SI 1)
  4493.     (minus:SI (reg:SI 1) (match_operand:SI 0 "reg_or_short_operand" "")))]
  4494.   ""
  4495.   "
  4496. { rtx chain = gen_reg_rtx (SImode);
  4497.   rtx stack_bot = gen_rtx (MEM, Pmode, stack_pointer_rtx);
  4498.  
  4499.   emit_move_insn (chain, stack_bot);
  4500.   emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, operands[0]));
  4501.   emit_move_insn (stack_bot, chain);
  4502.   DONE;
  4503. }")
  4504.  
  4505. ;; These patterns say how to save and restore the stack pointer.  We need not
  4506. ;; save the stack pointer at function level since we are careful to
  4507. ;; preserve the backchain.  At block level, we have to restore the backchain
  4508. ;; when we restore the stack pointer.
  4509. ;;
  4510. ;; For nonlocal gotos, we must save both the stack pointer and its
  4511. ;; backchain and restore both.  Note that in the nonlocal case, the
  4512. ;; save area is a memory location.
  4513.  
  4514. (define_expand "save_stack_function"
  4515.   [(use (const_int 0))]
  4516.   ""
  4517.   "")
  4518.  
  4519. (define_expand "restore_stack_function"
  4520.   [(use (const_int 0))]
  4521.   ""
  4522.   "")
  4523.  
  4524. (define_expand "restore_stack_block"
  4525.   [(set (match_dup 2) (mem:SI (match_operand:SI 0 "register_operand" "")))
  4526.    (set (match_dup 0) (match_operand:SI 1 "register_operand" ""))
  4527.    (set (mem:SI (match_dup 0)) (match_dup 2))]
  4528.   ""
  4529.   "
  4530. { operands[2] = gen_reg_rtx (SImode); }")
  4531.  
  4532. (define_expand "save_stack_nonlocal"
  4533.   [(match_operand:DI 0 "memory_operand" "")
  4534.    (match_operand:SI 1 "register_operand" "")]
  4535.   ""
  4536.   "
  4537. {
  4538.   rtx temp = gen_reg_rtx (SImode);
  4539.  
  4540.   /* Copy the backchain to the first word, sp to the second.  */
  4541.   emit_move_insn (temp, gen_rtx (MEM, SImode, operands[1]));
  4542.   emit_move_insn (operand_subword (operands[0], 0, 0, DImode), temp);
  4543.   emit_move_insn (operand_subword (operands[0], 1, 0, DImode), operands[1]);
  4544.   DONE;
  4545. }")
  4546.           
  4547. (define_expand "restore_stack_nonlocal"
  4548.   [(match_operand:SI 0 "register_operand" "")
  4549.    (match_operand:DI 1 "memory_operand" "")]
  4550.   ""
  4551.   "
  4552. {
  4553.   rtx temp = gen_reg_rtx (SImode);
  4554.  
  4555.   /* Restore the backchain from the first word, sp from the second.  */
  4556.   emit_move_insn (temp, operand_subword (operands[1], 0, 0, DImode));
  4557.   emit_move_insn (operands[0], operand_subword (operands[1], 1, 0, DImode));
  4558.   emit_move_insn (gen_rtx (MEM, SImode, operands[0]), temp);
  4559.   DONE;
  4560. }")
  4561.  
  4562. ;; A function pointer is a pointer to a data area whose first word contains
  4563. ;; the actual address of the function, whose second word contains a pointer
  4564. ;; to its TOC, and whose third word contains a value to place in the static
  4565. ;; chain register (r11).  Note that if we load the static chain, our 
  4566. ;; "trampoline" need not have any executable code.
  4567. ;;
  4568. ;; operands[0] is an SImode pseudo in which we place the address of the
  4569. ;;            function.
  4570. ;; operands[1] is the address of data area of the function to call
  4571.  
  4572. (define_expand "call_via_ptr"
  4573.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  4574.     (mem:SI (match_operand:SI 1 "gpc_reg_operand" "")))
  4575.    (set (mem:SI (plus:SI (reg:SI 1) (const_int 20)))
  4576.     (reg:SI 2))
  4577.    (set (reg:SI 2)
  4578.     (mem:SI (plus:SI (match_dup 1)
  4579.              (const_int 4))))
  4580.    (set (reg:SI 11)
  4581.     (mem:SI (plus:SI (match_dup 1)
  4582.              (const_int 8))))
  4583.    (use (reg:SI 2))
  4584.    (use (reg:SI 11))]
  4585.   ""
  4586.   "")
  4587.  
  4588. (define_expand "call"
  4589.   [(parallel [(call (mem:SI (match_operand:SI 0 "address_operand" ""))
  4590.             (match_operand 1 "" ""))
  4591.           (clobber (scratch:SI))])]
  4592.   ""
  4593.   "
  4594. {
  4595.   if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
  4596.     abort ();
  4597.  
  4598.   operands[0] = XEXP (operands[0], 0);
  4599.   if (GET_CODE (operands[0]) != SYMBOL_REF)
  4600.     {
  4601.       rtx temp = gen_reg_rtx (SImode);
  4602.  
  4603.       emit_insn (gen_call_via_ptr (temp, force_reg (SImode, operands[0])));
  4604.       operands[0] = temp;
  4605.     }
  4606. }")
  4607.  
  4608. (define_expand "call_value"
  4609.   [(parallel [(set (match_operand 0 "" "")
  4610.            (call (mem:SI (match_operand:SI 1 "address_operand" ""))
  4611.              (match_operand 2 "" "")))
  4612.           (clobber (scratch:SI))])]
  4613.   ""
  4614.   "
  4615. {
  4616.   if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
  4617.     abort ();
  4618.  
  4619.   operands[1] = XEXP (operands[1], 0);
  4620.   if (GET_CODE (operands[1]) != SYMBOL_REF)
  4621.     {
  4622.       rtx temp = gen_reg_rtx (SImode);
  4623.  
  4624.       emit_insn (gen_call_via_ptr (temp, force_reg (SImode, operands[1])));
  4625.       operands[1] = temp;
  4626.     }
  4627. }")
  4628.  
  4629. ;; Call to function in current module.  No TOC pointer reload needed.
  4630.  
  4631. (define_insn ""
  4632.   [(call (mem:SI (match_operand:SI 0 "current_file_function_operand" "s"))
  4633.      (match_operand 1 "" "g"))
  4634.    (clobber (match_scratch:SI 2 "=l"))]
  4635.   ""
  4636.   "bl %z0")
  4637.  
  4638. ;; Call to function which may be in another module.  Restore the TOC
  4639. ;; pointer (r2) after the call.
  4640.  
  4641. (define_insn ""
  4642.   [(call (mem:SI (match_operand:SI 0 "call_operand" "l,s"))
  4643.      (match_operand 1 "" "fg,fg"))
  4644.    (clobber (match_scratch:SI 2 "=l,l"))]
  4645.   ""
  4646.   "@
  4647.    {brl|blrl}\;{l|lwz} 2,20(1)
  4648.    bl %z0\;%."
  4649.   [(set_attr "length" "8")])
  4650.  
  4651. (define_insn ""
  4652.   [(set (match_operand 0 "" "=fg")
  4653.     (call (mem:SI (match_operand:SI 1 "current_file_function_operand" "s"))
  4654.           (match_operand 2 "" "g")))
  4655.    (clobber (match_scratch:SI 3 "=l"))]
  4656.   ""
  4657.   "bl %z1")
  4658.  
  4659. (define_insn ""
  4660.   [(set (match_operand 0 "" "=fg,fg")
  4661.     (call (mem:SI (match_operand:SI 1 "call_operand" "l,s"))
  4662.           (match_operand 2 "" "fg,fg")))
  4663.    (clobber (match_scratch:SI 3 "=l,l"))]
  4664.   ""
  4665.   "@
  4666.    {brl|blrl}\;{l|lwz} 2,20(1)
  4667.    bl %z1\;%."
  4668.   [(set_attr "length" "8")])
  4669.  
  4670. ;; Call subroutine returning any type.
  4671.  
  4672. (define_expand "untyped_call"
  4673.   [(parallel [(call (match_operand 0 "" "")
  4674.             (const_int 0))
  4675.           (match_operand 1 "" "")
  4676.           (match_operand 2 "" "")])]
  4677.   ""
  4678.   "
  4679. {
  4680.   int i;
  4681.  
  4682.   emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx));
  4683.  
  4684.   for (i = 0; i < XVECLEN (operands[2], 0); i++)
  4685.     {
  4686.       rtx set = XVECEXP (operands[2], 0, i);
  4687.       emit_move_insn (SET_DEST (set), SET_SRC (set));
  4688.     }
  4689.  
  4690.   /* The optimizer does not know that the call sets the function value
  4691.      registers we stored in the result block.  We avoid problems by
  4692.      claiming that all hard registers are used and clobbered at this
  4693.      point.  */
  4694.   emit_insn (gen_blockage ());
  4695.  
  4696.   DONE;
  4697. }")
  4698.  
  4699. ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
  4700. ;; all of memory.  This blocks insns from being moved across this point.
  4701.  
  4702. (define_insn "blockage"
  4703.   [(unspec_volatile [(const_int 0)] 0)]
  4704.   ""
  4705.   "")
  4706.  
  4707. ;; Compare insns are next.  Note that the RS/6000 has two types of compares,
  4708. ;; signed & unsigned, and one type of branch.  
  4709. ;;
  4710. ;; Start with the DEFINE_EXPANDs to generate the rtl for compares, scc
  4711. ;; insns, and branches.  We store the operands of compares until we see
  4712. ;; how it is used.
  4713. (define_expand "cmpsi"
  4714.   [(set (cc0)
  4715.         (compare (match_operand:SI 0 "gpc_reg_operand" "")
  4716.            (match_operand:SI 1 "reg_or_short_operand" "")))]
  4717.   ""
  4718.   "
  4719. {
  4720.   /* Take care of the possibility that operands[1] might be negative but
  4721.      this might be a logical operation.  That insn doesn't exist.  */
  4722.   if (GET_CODE (operands[1]) == CONST_INT
  4723.       && INTVAL (operands[1]) < 0)
  4724.     operands[1] = force_reg (SImode, operands[1]);
  4725.  
  4726.   rs6000_compare_op0 = operands[0];
  4727.   rs6000_compare_op1 = operands[1];
  4728.   rs6000_compare_fp_p = 0;
  4729.   DONE;
  4730. }")
  4731.  
  4732. (define_expand "cmpsf"
  4733.   [(set (cc0) (compare (match_operand:SF 0 "gpc_reg_operand" "")
  4734.                (match_operand:SF 1 "gpc_reg_operand" "")))]
  4735.   ""
  4736.   "
  4737. {
  4738.   rs6000_compare_op0 = operands[0];
  4739.   rs6000_compare_op1 = operands[1];
  4740.   rs6000_compare_fp_p = 1;
  4741.   DONE;
  4742. }")
  4743.  
  4744. (define_expand "cmpdf"
  4745.   [(set (cc0) (compare (match_operand:DF 0 "gpc_reg_operand" "")
  4746.                (match_operand:DF 1 "gpc_reg_operand" "")))]
  4747.   ""
  4748.   "
  4749. {
  4750.   rs6000_compare_op0 = operands[0];
  4751.   rs6000_compare_op1 = operands[1];
  4752.   rs6000_compare_fp_p = 1;
  4753.   DONE;
  4754. }")
  4755.  
  4756. (define_expand "beq"
  4757.   [(set (match_dup 2) (match_dup 1))
  4758.    (set (pc)
  4759.     (if_then_else (eq (match_dup 2)
  4760.               (const_int 0))
  4761.               (label_ref (match_operand 0 "" ""))
  4762.               (pc)))]
  4763.   ""
  4764.   "
  4765. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4766.   operands[1] = gen_rtx (COMPARE, mode,
  4767.              rs6000_compare_op0, rs6000_compare_op1);
  4768.   operands[2] = gen_reg_rtx (mode);
  4769. }")
  4770.  
  4771. (define_expand "bne"
  4772.   [(set (match_dup 2) (match_dup 1))
  4773.    (set (pc)
  4774.     (if_then_else (ne (match_dup 2)
  4775.               (const_int 0))
  4776.               (label_ref (match_operand 0 "" ""))
  4777.               (pc)))]
  4778.   ""
  4779.   "
  4780. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4781.   operands[1] = gen_rtx (COMPARE, mode,
  4782.              rs6000_compare_op0, rs6000_compare_op1);
  4783.   operands[2] = gen_reg_rtx (mode);
  4784. }")
  4785.  
  4786. (define_expand "blt"
  4787.   [(set (match_dup 2) (match_dup 1))
  4788.    (set (pc)
  4789.     (if_then_else (lt (match_dup 2)
  4790.               (const_int 0))
  4791.               (label_ref (match_operand 0 "" ""))
  4792.               (pc)))]
  4793.   ""
  4794.   "
  4795. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4796.   operands[1] = gen_rtx (COMPARE, mode,
  4797.              rs6000_compare_op0, rs6000_compare_op1);
  4798.   operands[2] = gen_reg_rtx (mode);
  4799. }")
  4800.  
  4801. (define_expand "bgt"
  4802.   [(set (match_dup 2) (match_dup 1))
  4803.    (set (pc)
  4804.     (if_then_else (gt (match_dup 2)
  4805.               (const_int 0))
  4806.               (label_ref (match_operand 0 "" ""))
  4807.               (pc)))]
  4808.   ""
  4809.   "
  4810. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4811.   operands[1] = gen_rtx (COMPARE, mode,
  4812.              rs6000_compare_op0, rs6000_compare_op1);
  4813.   operands[2] = gen_reg_rtx (mode);
  4814. }")
  4815.  
  4816. (define_expand "ble"
  4817.   [(set (match_dup 2) (match_dup 1))
  4818.    (set (pc)
  4819.     (if_then_else (le (match_dup 2)
  4820.               (const_int 0))
  4821.               (label_ref (match_operand 0 "" ""))
  4822.               (pc)))]
  4823.   ""
  4824.   "
  4825. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4826.   operands[1] = gen_rtx (COMPARE, mode,
  4827.              rs6000_compare_op0, rs6000_compare_op1);
  4828.   operands[2] = gen_reg_rtx (mode);
  4829. }")
  4830.  
  4831. (define_expand "bge"
  4832.   [(set (match_dup 2) (match_dup 1))
  4833.    (set (pc)
  4834.     (if_then_else (ge (match_dup 2)
  4835.               (const_int 0))
  4836.               (label_ref (match_operand 0 "" ""))
  4837.               (pc)))]
  4838.   ""
  4839.   "
  4840. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4841.   operands[1] = gen_rtx (COMPARE, mode,
  4842.              rs6000_compare_op0, rs6000_compare_op1);
  4843.   operands[2] = gen_reg_rtx (mode);
  4844. }")
  4845.  
  4846. (define_expand "bgtu"
  4847.   [(set (match_dup 2) (match_dup 1))
  4848.    (set (pc)
  4849.     (if_then_else (gtu (match_dup 2)
  4850.                (const_int 0))
  4851.               (label_ref (match_operand 0 "" ""))
  4852.               (pc)))]
  4853.   ""
  4854.   "
  4855. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4856.              rs6000_compare_op0, rs6000_compare_op1);
  4857.   operands[2] = gen_reg_rtx (CCUNSmode);
  4858. }")
  4859.  
  4860. (define_expand "bltu"
  4861.   [(set (match_dup 2) (match_dup 1))
  4862.    (set (pc)
  4863.     (if_then_else (ltu (match_dup 2)
  4864.                (const_int 0))
  4865.               (label_ref (match_operand 0 "" ""))
  4866.               (pc)))]
  4867.   ""
  4868.   "
  4869. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4870.              rs6000_compare_op0, rs6000_compare_op1);
  4871.   operands[2] = gen_reg_rtx (CCUNSmode);
  4872. }")
  4873.  
  4874. (define_expand "bgeu"
  4875.   [(set (match_dup 2) (match_dup 1))
  4876.    (set (pc)
  4877.     (if_then_else (geu (match_dup 2)
  4878.                (const_int 0))
  4879.               (label_ref (match_operand 0 "" ""))
  4880.               (pc)))]
  4881.   ""
  4882.   "
  4883. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4884.              rs6000_compare_op0, rs6000_compare_op1);
  4885.   operands[2] = gen_reg_rtx (CCUNSmode);
  4886. }")
  4887.  
  4888. (define_expand "bleu"
  4889.   [(set (match_dup 2) (match_dup 1))
  4890.    (set (pc)
  4891.     (if_then_else (leu (match_dup 2)
  4892.                (const_int 0))
  4893.               (label_ref (match_operand 0 "" ""))
  4894.               (pc)))]
  4895.   ""
  4896.   "
  4897. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  4898.              rs6000_compare_op0, rs6000_compare_op1);
  4899.   operands[2] = gen_reg_rtx (CCUNSmode);
  4900. }")
  4901.  
  4902. ;; For SNE, we would prefer that the xor/abs sequence be used for integers.
  4903. ;; For SEQ, likewise, except that comparisons with zero should be done
  4904. ;; with an scc insns.  However, due to the order that combine see the
  4905. ;; resulting insns, we must, in fact, allow SEQ for integers.  Fail in
  4906. ;; the cases we don't want to handle.
  4907. (define_expand "seq"
  4908.   [(set (match_dup 2) (match_dup 1))
  4909.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4910.     (eq:SI (match_dup 2) (const_int 0)))]
  4911.   ""
  4912.   "
  4913. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4914.   operands[1] = gen_rtx (COMPARE, mode,
  4915.              rs6000_compare_op0, rs6000_compare_op1);
  4916.   operands[2] = gen_reg_rtx (mode);
  4917. }")
  4918.  
  4919. (define_expand "sne"
  4920.   [(set (match_dup 2) (match_dup 1))
  4921.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4922.     (ne:SI (match_dup 2) (const_int 0)))]
  4923.   ""
  4924.   "
  4925. { if (! rs6000_compare_fp_p)
  4926.     FAIL;
  4927.  
  4928.   operands[1] = gen_rtx (COMPARE, CCFPmode,
  4929.              rs6000_compare_op0, rs6000_compare_op1);
  4930.   operands[2] = gen_reg_rtx (CCFPmode);
  4931. }")
  4932.  
  4933. ;; A > 0 is best done using the portable sequence, so fail in that case.
  4934. (define_expand "sgt"
  4935.   [(set (match_dup 2) (match_dup 1))
  4936.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4937.     (gt:SI (match_dup 2) (const_int 0)))]
  4938.   ""
  4939.   "
  4940. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4941.  
  4942.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  4943.     FAIL;
  4944.  
  4945.   operands[1] = gen_rtx (COMPARE, mode,
  4946.              rs6000_compare_op0, rs6000_compare_op1);
  4947.   operands[2] = gen_reg_rtx (mode);
  4948. }")
  4949.  
  4950. ;; A < 0 is best done in the portable way for A an integer.
  4951. (define_expand "slt"
  4952.   [(set (match_dup 2) (match_dup 1))
  4953.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4954.     (lt:SI (match_dup 2) (const_int 0)))]
  4955.   ""
  4956.   "
  4957. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4958.  
  4959.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  4960.     FAIL;
  4961.  
  4962.   operands[1] = gen_rtx (COMPARE, mode,
  4963.              rs6000_compare_op0, rs6000_compare_op1);
  4964.   operands[2] = gen_reg_rtx (mode);
  4965. }")
  4966.  
  4967. (define_expand "sge"
  4968.   [(set (match_dup 2) (match_dup 1))
  4969.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4970.     (ge:SI (match_dup 2) (const_int 0)))]
  4971.   ""
  4972.   "
  4973. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4974.   operands[1] = gen_rtx (COMPARE, mode,
  4975.              rs6000_compare_op0, rs6000_compare_op1);
  4976.   operands[2] = gen_reg_rtx (mode);
  4977. }")
  4978.  
  4979. ;; A <= 0 is best done the portable way for A an integer.
  4980. (define_expand "sle"
  4981.   [(set (match_dup 2) (match_dup 1))
  4982.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4983.     (le:SI (match_dup 2) (const_int 0)))]
  4984.   ""
  4985.   "
  4986. { enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
  4987.  
  4988.   if (! rs6000_compare_fp_p && rs6000_compare_op1 == const0_rtx)
  4989.     FAIL;
  4990.  
  4991.   operands[1] = gen_rtx (COMPARE, mode,
  4992.              rs6000_compare_op0, rs6000_compare_op1);
  4993.   operands[2] = gen_reg_rtx (mode);
  4994. }")
  4995.  
  4996. (define_expand "sgtu"
  4997.   [(set (match_dup 2) (match_dup 1))
  4998.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  4999.     (gtu:SI (match_dup 2) (const_int 0)))]
  5000.   ""
  5001.   "
  5002. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  5003.              rs6000_compare_op0, rs6000_compare_op1);
  5004.   operands[2] = gen_reg_rtx (CCUNSmode);
  5005. }")
  5006.  
  5007. (define_expand "sltu"
  5008.   [(set (match_dup 2) (match_dup 1))
  5009.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5010.     (ltu:SI (match_dup 2) (const_int 0)))]
  5011.   ""
  5012.   "
  5013. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  5014.              rs6000_compare_op0, rs6000_compare_op1);
  5015.   operands[2] = gen_reg_rtx (CCUNSmode);
  5016. }")
  5017.  
  5018. (define_expand "sgeu"
  5019.   [(set (match_dup 2) (match_dup 1))
  5020.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5021.     (geu:SI (match_dup 2) (const_int 0)))]
  5022.   ""
  5023.   "
  5024. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  5025.              rs6000_compare_op0, rs6000_compare_op1);
  5026.   operands[2] = gen_reg_rtx (CCUNSmode);
  5027. }")
  5028.  
  5029. (define_expand "sleu"
  5030.   [(set (match_dup 2) (match_dup 1))
  5031.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5032.     (leu:SI (match_dup 2) (const_int 0)))]
  5033.   ""
  5034.   "
  5035. { operands[1] = gen_rtx (COMPARE, CCUNSmode,
  5036.              rs6000_compare_op0, rs6000_compare_op1);
  5037.   operands[2] = gen_reg_rtx (CCUNSmode);
  5038. }")
  5039.  
  5040. ;; Here are the actual compare insns.
  5041. (define_insn ""
  5042.   [(set (match_operand:CC 0 "cc_reg_operand" "=y")
  5043.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  5044.             (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  5045.   ""
  5046.   "{cmp%I2|cmpw%I2} %0,%1,%2"
  5047.   [(set_attr "type" "compare")])
  5048.  
  5049. ;; If we are comparing a register for equality with a large constant,
  5050. ;; we can do this with an XOR followed by a compare.  But we need a scratch
  5051. ;; register for the result of the XOR.
  5052.  
  5053. (define_split
  5054.   [(set (match_operand:CC 0 "cc_reg_operand" "")
  5055.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
  5056.             (match_operand:SI 2 "non_short_cint_operand" "")))
  5057.    (clobber (match_operand:SI 3 "gpc_reg_operand" ""))]
  5058.   "find_single_use (operands[0], insn, 0)
  5059.    && (GET_CODE (*find_single_use (operands[0], insn, 0)) == EQ
  5060.        || GET_CODE (*find_single_use (operands[0], insn, 0)) == NE)"
  5061.   [(set (match_dup 3) (xor:SI (match_dup 1) (match_dup 4)))
  5062.    (set (match_dup 0) (compare:CC (match_dup 3) (match_dup 5)))]
  5063.   "
  5064. {
  5065.   /* Get the constant we are comparing against, C,  and see what it looks like
  5066.      sign-extended to 16 bits.  Then see what constant could be XOR'ed
  5067.      with C to get the sign-extended value.  */
  5068.  
  5069.   int c = INTVAL (operands[2]);
  5070.   int sextc = (c << 16) >> 16;
  5071.   int xorv = c ^ sextc;
  5072.  
  5073.   operands[4] = gen_rtx (CONST_INT, VOIDmode, xorv);
  5074.   operands[5] = gen_rtx (CONST_INT, VOIDmode, sextc);
  5075. }")
  5076.  
  5077. (define_insn ""
  5078.   [(set (match_operand:CCUNS 0 "cc_reg_operand" "=y")
  5079.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
  5080.                (match_operand:SI 2 "reg_or_u_short_operand" "rI")))]
  5081.   ""
  5082.   "{cmpl%I2|cmplw%I2} %0,%1,%W2"
  5083.   [(set_attr "type" "compare")])
  5084.  
  5085. ;; The following two insns don't exist as single insns, but if we provide
  5086. ;; them, we can swap an add and compare, which will enable us to overlap more
  5087. ;; of the required delay between a compare and branch.  We generate code for
  5088. ;; them by splitting.
  5089.  
  5090. (define_insn ""
  5091.   [(set (match_operand:CC 3 "cc_reg_operand" "=y")
  5092.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "r")
  5093.             (match_operand:SI 2 "short_cint_operand" "i")))
  5094.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5095.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
  5096.   ""
  5097.   "#"
  5098.   [(set_attr "length" "8")])
  5099.    
  5100. (define_insn ""
  5101.   [(set (match_operand:CCUNS 3 "cc_reg_operand" "=y")
  5102.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "r")
  5103.                (match_operand:SI 2 "u_short_cint_operand" "i")))
  5104.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5105.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "i")))]
  5106.   ""
  5107.   "#"
  5108.   [(set_attr "length" "8")])
  5109.    
  5110. (define_split
  5111.   [(set (match_operand:CC 3 "cc_reg_operand" "")
  5112.     (compare:CC (match_operand:SI 1 "gpc_reg_operand" "")
  5113.             (match_operand:SI 2 "short_cint_operand" "")))
  5114.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5115.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
  5116.   ""
  5117.   [(set (match_dup 3) (compare:CC (match_dup 1) (match_dup 2)))
  5118.    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
  5119.  
  5120. (define_split
  5121.   [(set (match_operand:CCUNS 3 "cc_reg_operand" "")
  5122.     (compare:CCUNS (match_operand:SI 1 "gpc_reg_operand" "")
  5123.                (match_operand:SI 2 "u_short_cint_operand" "")))
  5124.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  5125.     (plus:SI (match_dup 1) (match_operand:SI 4 "short_cint_operand" "")))]
  5126.   ""
  5127.   [(set (match_dup 3) (compare:CCUNS (match_dup 1) (match_dup 2)))
  5128.    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 4)))])
  5129.  
  5130. (define_insn ""
  5131.   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
  5132.     (compare:CCFP (match_operand:SF 1 "gpc_reg_operand" "f")
  5133.               (match_operand:SF 2 "gpc_reg_operand" "f")))]
  5134.   ""
  5135.   "fcmpu %0,%1,%2"
  5136.   [(set_attr "type" "fpcompare")])
  5137.  
  5138. (define_insn ""
  5139.   [(set (match_operand:CCFP 0 "cc_reg_operand" "=y")
  5140.     (compare:CCFP (match_operand:DF 1 "gpc_reg_operand" "f")
  5141.               (match_operand:DF 2 "gpc_reg_operand" "f")))]
  5142.   ""
  5143.   "fcmpu %0,%1,%2"
  5144.   [(set_attr "type" "fpcompare")])
  5145.  
  5146. ;; Now we have the scc insns.  We can do some combinations because of the
  5147. ;; way the machine works.
  5148. ;;
  5149. ;; Note that this is probably faster if we can put an insn between the
  5150. ;; mfcr and rlinm, but this is tricky.  Let's leave it for now.  In most
  5151. ;; cases the insns below which don't use an intermediate CR field will
  5152. ;; be used instead.
  5153. (define_insn ""
  5154.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5155.     (match_operator:SI 1 "scc_comparison_operator"
  5156.                [(match_operand 2 "cc_reg_operand" "y")
  5157.                 (const_int 0)]))]
  5158.   ""
  5159.   "%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%J1,1"
  5160.   [(set_attr "length" "12")])
  5161.  
  5162. (define_insn ""
  5163.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5164.     (compare:CC (match_operator:SI 1 "scc_comparison_operator"
  5165.                        [(match_operand 2 "cc_reg_operand" "y")
  5166.                     (const_int 0)])
  5167.             (const_int 0)))
  5168.    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
  5169.     (match_op_dup 1 [(match_dup 2) (const_int 0)]))]
  5170.   ""
  5171.   "%D1mfcr %3\;{rlinm.|rlwinm.} %3,%3,%J1,1"
  5172.   [(set_attr "type" "delayed_compare")
  5173.    (set_attr "length" "12")])
  5174.  
  5175. (define_insn ""
  5176.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5177.     (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
  5178.                       [(match_operand 2 "cc_reg_operand" "y")
  5179.                        (const_int 0)])
  5180.            (match_operand:SI 3 "const_int_operand" "n")))]
  5181.   ""
  5182.   "*
  5183. {
  5184.   int is_bit = ccr_bit (operands[1], 1);
  5185.   int put_bit = 31 - (INTVAL (operands[3]) & 31);
  5186.   int count;
  5187.  
  5188.   if (is_bit >= put_bit)
  5189.     count = is_bit - put_bit;
  5190.   else
  5191.     count = 32 - (put_bit - is_bit);
  5192.  
  5193.   operands[4] = gen_rtx (CONST_INT, VOIDmode, count);
  5194.   operands[5] = gen_rtx (CONST_INT, VOIDmode, put_bit);
  5195.  
  5196.   return \"%D1mfcr %0\;{rlinm|rlwinm} %0,%0,%4,%5,%5\";
  5197. }"
  5198.  [(set_attr "length" "12")])
  5199.  
  5200. (define_insn ""
  5201.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5202.     (compare:CC
  5203.      (ashift:SI (match_operator:SI 1 "scc_comparison_operator"
  5204.                        [(match_operand 2 "cc_reg_operand" "y")
  5205.                     (const_int 0)])
  5206.             (match_operand:SI 3 "const_int_operand" "n"))
  5207.      (const_int 0)))
  5208.    (set (match_operand:SI 4 "gpc_reg_operand" "=r")
  5209.     (ashift:SI (match_op_dup 1 [(match_dup 2) (const_int 0)])
  5210.            (match_dup 3)))]
  5211.   ""
  5212.   "*
  5213. {
  5214.   int is_bit = ccr_bit (operands[1], 1);
  5215.   int put_bit = 31 - (INTVAL (operands[3]) & 31);
  5216.   int count;
  5217.  
  5218.   if (is_bit >= put_bit)
  5219.     count = is_bit - put_bit;
  5220.   else
  5221.     count = 32 - (put_bit - is_bit);
  5222.  
  5223.   operands[5] = gen_rtx (CONST_INT, VOIDmode, count);
  5224.   operands[6] = gen_rtx (CONST_INT, VOIDmode, put_bit);
  5225.  
  5226.   return \"%D1mfcr %4\;{rlinm.|rlwinm.} %4,%4,%5,%6,%6\";
  5227. }"
  5228.   [(set_attr "type" "delayed_compare")
  5229.    (set_attr "length" "12")])
  5230.  
  5231. ;; If we are comparing the result of two comparisons, this can be done
  5232. ;; using creqv or crxor.
  5233.  
  5234. (define_insn ""
  5235.   [(set (match_operand:CCEQ 0 "cc_reg_operand" "=y")
  5236.     (compare:CCEQ (match_operator 1 "scc_comparison_operator"
  5237.                   [(match_operand 2 "cc_reg_operand" "y")
  5238.                    (const_int 0)])
  5239.               (match_operator 3 "scc_comparison_operator"
  5240.                   [(match_operand 4 "cc_reg_operand" "y")
  5241.                    (const_int 0)])))]
  5242.   "REGNO (operands[2]) != REGNO (operands[4])"
  5243.   "*
  5244. {
  5245.   enum rtx_code code1, code2;
  5246.  
  5247.   code1 = GET_CODE (operands[1]);
  5248.   code2 = GET_CODE (operands[3]);
  5249.  
  5250.   if ((code1 == EQ || code1 == LT || code1 == GT
  5251.        || code1 == LTU || code1 == GTU
  5252.        || (code1 != NE && GET_MODE (operands[2]) == CCFPmode))
  5253.       !=
  5254.       (code2 == EQ || code2 == LT || code2 == GT
  5255.        || code2 == LTU || code2 == GTU
  5256.        || (code2 != NE && GET_MODE (operands[4]) == CCFPmode)))
  5257.     return \"%C1%C3crxor %E0,%j1,%j3\";
  5258.   else
  5259.     return \"%C1%C3creqv %E0,%j1,%j3\";
  5260. }"
  5261.   [(set_attr "length" "12")])
  5262.  
  5263. ;; There is a 3 cycle delay between consecutive mfcr instructions
  5264. ;; so it is useful to combine 2 scc instructions to use only one mfcr.
  5265.  
  5266. (define_peephole
  5267.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5268.     (match_operator:SI 1 "scc_comparison_operator"
  5269.                [(match_operand 2 "cc_reg_operand" "y")
  5270.                 (const_int 0)]))
  5271.    (set (match_operand:SI 3 "gpc_reg_operand" "=r")
  5272.     (match_operator:SI 4 "scc_comparison_operator"
  5273.                [(match_operand 5 "cc_reg_operand" "y")
  5274.                 (const_int 0)]))]
  5275.    "REGNO (operands[2]) != REGNO (operands[5])"
  5276.    "%D1%D4mfcr %3\;{rlinm|rlwinm} %0,%3,%J1,1\;{rlinm|rlwinm} %3,%3,%J4,1"
  5277.    [(set_attr "length" "20")])
  5278.  
  5279. ;; There are some scc insns that can be done directly, without a compare.
  5280. ;; These are faster because they don't involve the communications between
  5281. ;; the FXU and branch units.   In fact, we will be replacing all of the
  5282. ;; integer scc insns here or in the portable methods in emit_store_flag.
  5283. ;;
  5284. ;; Also support (neg (scc ..)) since that construct is used to replace
  5285. ;; branches, (plus (scc ..) ..) since that construct is common and
  5286. ;; takes no more insns than scc, and (and (neg (scc ..)) ..) in the
  5287. ;; cases where it is no more expensive than (neg (scc ..)).
  5288.  
  5289. ;; Have reload force a constant into a register for the simple insns that
  5290. ;; otherwise won't accept constants.  We do this because it is faster than
  5291. ;; the cmp/mfcr sequence we would otherwise generate.
  5292.  
  5293. (define_insn ""
  5294.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  5295.     (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5296.            (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I")))
  5297.    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
  5298.   ""
  5299.   "@
  5300.    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  5301.    {sfi|subfic} %3,%1,0\;{ae|adde} %0,%3,%1
  5302.    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  5303.    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0
  5304.    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae|adde} %0,%3,%0"
  5305.   [(set_attr "length" "12,8,12,12,12")])
  5306.  
  5307. (define_insn ""
  5308.   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x,x,x,x")
  5309.     (compare:CC 
  5310.      (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5311.         (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  5312.      (const_int 0)))
  5313.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  5314.     (eq:SI (match_dup 1) (match_dup 2)))
  5315.    (clobber (match_scratch:SI 3 "=r,&r,r,r,r"))]
  5316.   ""
  5317.   "@
  5318.    xor %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  5319.    {sfi|subfic} %3,%1,0\;{ae.|adde.} %0,%3,%1
  5320.    {xoril|xori} %0,%1,%b2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  5321.    {xoriu|xoris} %0,%1,%u2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0
  5322.    {sfi|subfic} %0,%1,%2\;{sfi|subfic} %3,%0,0\;{ae.|adde.} %0,%3,%0"
  5323.   [(set_attr "type" "compare")
  5324.    (set_attr "length" "12,8,12,12,12")])
  5325.  
  5326. ;; We have insns of the form shown by the first define_insn below.  If
  5327. ;; there is something inside the comparison operation, we must split it.
  5328. (define_split
  5329.   [(set (match_operand:SI 0 "gpc_reg_operand" "")
  5330.     (plus:SI (match_operator 1 "comparison_operator"
  5331.                  [(match_operand:SI 2 "" "")
  5332.                   (match_operand:SI 3
  5333.                             "reg_or_cint_operand" "")])
  5334.          (match_operand:SI 4 "gpc_reg_operand" "")))
  5335.    (clobber (match_operand:SI 5 "register_operand" ""))]
  5336.   "! gpc_reg_operand (operands[2], SImode)"
  5337.   [(set (match_dup 5) (match_dup 2))
  5338.    (set (match_dup 2) (plus:SI (match_op_dup 1 [(match_dup 2) (match_dup 3)])
  5339.                    (match_dup 4)))])
  5340.  
  5341. (define_insn ""
  5342.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  5343.     (plus:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5344.             (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  5345.          (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r")))
  5346.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  5347.   ""
  5348.   "@
  5349.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  5350.    {sfi|subfic} %4,%1,0\;{aze|addze} %0,%3
  5351.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  5352.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  5353.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
  5354.   [(set_attr "length" "12,8,12,12,12")])
  5355.  
  5356. (define_insn ""
  5357.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x,x,x,x")
  5358.     (compare:CC 
  5359.      (plus:SI
  5360.       (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5361.          (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  5362.       (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
  5363.      (const_int 0)))
  5364.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  5365.   ""
  5366.   "@
  5367.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  5368.    {sfi|subfic} %4,%1,0\;{aze.|addze.} %0,%3
  5369.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  5370.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  5371.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
  5372.   [(set_attr "type" "compare")
  5373.    (set_attr "length" "12,8,12,12,12")])
  5374.  
  5375. (define_insn ""
  5376.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x,x,x,x")
  5377.     (compare:CC 
  5378.      (plus:SI
  5379.       (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5380.          (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))
  5381.       (match_operand:SI 3 "gpc_reg_operand" "r,r,r,r,r"))
  5382.      (const_int 0)))
  5383.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  5384.     (plus:SI (eq:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5385.    (clobber (match_scratch:SI 4 "=&r,&r,&r,&r,&r"))]
  5386.   ""
  5387.   "@
  5388.    xor %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  5389.    {sfi|subfic} %4,%1,0\;{aze.|addze.} %4,%3
  5390.    {xoril|xori} %4,%1,%b2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  5391.    {xoriu|xoris} %4,%1,%u2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  5392.    {sfi|subfic} %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
  5393.   [(set_attr "type" "compare")
  5394.    (set_attr "length" "12,8,12,12,12")])
  5395.  
  5396. (define_insn ""
  5397.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r,r")
  5398.     (neg:SI (eq:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r,r")
  5399.                (match_operand:SI 2 "reg_or_cint_operand" "r,O,K,J,I"))))]
  5400.   ""
  5401.   "@
  5402.    xor %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  5403.    {ai|addic} %0,%1,-1\;{sfe|subfe} %0,%0,%0
  5404.    {xoril|xori} %0,%1,%b2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  5405.    {xoriu|xoris} %0,%1,%u2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  5406.    {sfi|subfic} %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
  5407.    [(set_attr "length" "12,8,12,12,12")])
  5408.  
  5409. ;; This is what (plus (ne X (const_int 0)) Y) looks like.
  5410. (define_insn ""
  5411.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5412.     (plus:SI (lshiftrt:SI
  5413.           (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  5414.           (const_int 31))
  5415.          (match_operand:SI 2 "gpc_reg_operand" "r")))
  5416.    (clobber (match_scratch:SI 3 "=&r"))]
  5417.   ""
  5418.   "{ai|addic} %3,%1,-1\;{aze|addze} %0,%2"
  5419.   [(set_attr "length" "8")])
  5420.  
  5421. (define_insn ""
  5422.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5423.     (compare:CC
  5424.      (plus:SI (lshiftrt:SI
  5425.            (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  5426.            (const_int 31))
  5427.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  5428.      (const_int 0)))
  5429.    (clobber (match_scratch:SI 3 "=&r"))]
  5430.   ""
  5431.   "{ai|addic} %3,%1,-1\;{aze.|addze.} %3,%2"
  5432.   [(set_attr "type" "compare")
  5433.    (set_attr "length" "8")])
  5434.  
  5435. (define_insn ""
  5436.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  5437.     (compare:CC
  5438.      (plus:SI (lshiftrt:SI
  5439.            (neg:SI (abs:SI (match_operand:SI 1 "gpc_reg_operand" "r")))
  5440.            (const_int 31))
  5441.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  5442.      (const_int 0)))
  5443.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5444.     (plus:SI (lshiftrt:SI (neg:SI (abs:SI (match_dup 1))) (const_int 31))
  5445.          (match_dup 2)))
  5446.    (clobber (match_scratch:SI 3 "=&r"))]
  5447.   ""
  5448.   "{ai|addic} %3,%1,-1\;{aze.|addze.} %0,%2"
  5449.   [(set_attr "type" "compare")
  5450.    (set_attr "length" "8")])
  5451.  
  5452. (define_insn ""
  5453.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5454.     (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5455.            (match_operand:SI 2 "reg_or_short_operand" "r,O")))
  5456.    (clobber (match_scratch:SI 3 "=r,X"))]
  5457.   "TARGET_POWER"
  5458.   "@
  5459.    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3
  5460.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri|srwi} %0,%0,31"
  5461.   [(set_attr "length" "12")])
  5462.  
  5463. (define_insn ""
  5464.   [(set (match_operand:CC 4 "cc_reg_operand" "=x,x")
  5465.     (compare:CC
  5466.      (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5467.         (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  5468.      (const_int 0)))
  5469.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5470.     (le:SI (match_dup 1) (match_dup 2)))
  5471.    (clobber (match_scratch:SI 3 "=r,X"))]
  5472.   "TARGET_POWER"
  5473.   "@
  5474.    doz %3,%2,%1\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3
  5475.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{sri.|srwi.} %0,%0,31"
  5476.   [(set_attr "type" "compare,delayed_compare")
  5477.    (set_attr "length" "12")])
  5478.  
  5479. (define_insn ""
  5480.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5481.     (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5482.             (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  5483.          (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  5484.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5485.   "TARGET_POWER"
  5486.   "@
  5487.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3
  5488.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze|addze} %0,%3"
  5489.   [(set_attr "length" "12")])
  5490.  
  5491. (define_insn ""
  5492.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5493.     (compare:CC
  5494.      (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5495.              (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  5496.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5497.      (const_int 0)))
  5498.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5499.   "TARGET_POWER"
  5500.   "@
  5501.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3
  5502.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %4,%3"
  5503.   [(set_attr "type" "compare")
  5504.    (set_attr "length" "12")])
  5505.  
  5506. (define_insn ""
  5507.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  5508.     (compare:CC
  5509.      (plus:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5510.              (match_operand:SI 2 "reg_or_short_operand" "r,O"))
  5511.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5512.      (const_int 0)))
  5513.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5514.     (plus:SI (le:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5515.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5516.   "TARGET_POWER"
  5517.   "@
  5518.    doz %4,%2,%1\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3
  5519.    {srai|srawi} %4,%1,31\;{sf|subfc} %4,%1,%4\;{aze.|addze.} %0,%3"
  5520.   [(set_attr "type" "compare")
  5521.    (set_attr "length" "12")])
  5522.  
  5523. (define_insn ""
  5524.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5525.     (neg:SI (le:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5526.                (match_operand:SI 2 "reg_or_short_operand" "r,O"))))]
  5527.   "TARGET_POWER"
  5528.   "@
  5529.    doz %0,%2,%1\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0
  5530.    {ai|addic} %0,%1,-1\;{aze|addze} %0,%0\;{srai|srawi} %0,%0,31"
  5531.   [(set_attr "length" "12")])
  5532.  
  5533. (define_insn ""
  5534.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5535.     (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5536.         (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  5537.   ""
  5538.   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
  5539.   [(set_attr "length" "12")])
  5540.  
  5541. (define_insn ""
  5542.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  5543.     (compare:CC
  5544.      (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5545.          (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5546.      (const_int 0)))
  5547.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5548.     (leu:SI (match_dup 1) (match_dup 2)))]
  5549.    ""
  5550.   "{sf%I2|subf%I2c} %0,%1,%2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
  5551.   [(set_attr "type" "compare")
  5552.    (set_attr "length" "12")])
  5553.  
  5554. (define_insn ""
  5555.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5556.     (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5557.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5558.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  5559.    (clobber (match_scratch:SI 4 "=&r"))]
  5560.   ""
  5561.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze|addze} %0,%3"
  5562.   [(set_attr "length" "8")])
  5563.  
  5564. (define_insn ""
  5565.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5566.     (compare:CC
  5567.      (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5568.               (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5569.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5570.      (const_int 0)))
  5571.    (clobber (match_scratch:SI 4 "=&r"))]
  5572.   ""
  5573.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %4,%3"
  5574.   [(set_attr "type" "compare")
  5575.    (set_attr "length" "8")])
  5576.  
  5577. (define_insn ""
  5578.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  5579.     (compare:CC
  5580.      (plus:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5581.               (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5582.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5583.      (const_int 0)))
  5584.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5585.     (plus:SI (leu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5586.    (clobber (match_scratch:SI 4 "=&r"))]
  5587.   ""
  5588.   "{sf%I2|subf%I2c} %4,%1,%2\;{aze.|addze.} %0,%3"
  5589.   [(set_attr "type" "compare")
  5590.    (set_attr "length" "8")])
  5591.  
  5592. (define_insn ""
  5593.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5594.     (neg:SI (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5595.             (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  5596.   ""
  5597.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0"
  5598.    [(set_attr "length" "12")])
  5599.  
  5600. (define_insn ""
  5601.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5602.     (and:SI (neg:SI
  5603.          (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5604.              (match_operand:SI 2 "reg_or_short_operand" "rI")))
  5605.         (match_operand:SI 3 "gpc_reg_operand" "r")))
  5606.    (clobber (match_scratch:SI 4 "=&r"))]
  5607.   ""
  5608.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
  5609.   [(set_attr "length" "12")])
  5610.  
  5611. (define_insn ""
  5612.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5613.     (compare:CC
  5614.      (and:SI (neg:SI
  5615.           (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5616.               (match_operand:SI 2 "reg_or_short_operand" "rI")))
  5617.          (match_operand:SI 3 "gpc_reg_operand" "r"))
  5618.      (const_int 0)))
  5619.    (clobber (match_scratch:SI 4 "=&r"))]
  5620.   ""
  5621.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
  5622.   [(set_attr "type" "compare")
  5623.    (set_attr "length" "12")])
  5624.  
  5625. (define_insn ""
  5626.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  5627.     (compare:CC
  5628.      (and:SI (neg:SI
  5629.           (leu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5630.               (match_operand:SI 2 "reg_or_short_operand" "rI")))
  5631.          (match_operand:SI 3 "gpc_reg_operand" "r"))
  5632.      (const_int 0)))
  5633.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5634.     (and:SI (neg:SI (leu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
  5635.    (clobber (match_scratch:SI 4 "=&r"))]
  5636.   ""
  5637.   "{sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
  5638.   [(set_attr "type" "compare")
  5639.    (set_attr "length" "12")])
  5640.  
  5641. (define_insn ""
  5642.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5643.     (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5644.            (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  5645.   "TARGET_POWER"
  5646.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri|srwi} %0,%0,31"
  5647.    [(set_attr "length" "12")])
  5648.  
  5649. (define_insn ""
  5650.   [(set (match_operand:SI 3 "cc_reg_operand" "=x")
  5651.     (compare:CC
  5652.      (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5653.         (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5654.      (const_int 0)))
  5655.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5656.     (lt:SI (match_dup 1) (match_dup 2)))]
  5657.   "TARGET_POWER"
  5658.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
  5659.   [(set_attr "type" "delayed_compare")
  5660.    (set_attr "length" "12")])
  5661.  
  5662. (define_insn ""
  5663.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5664.     (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5665.             (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5666.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  5667.    (clobber (match_scratch:SI 4 "=&r"))]
  5668.   "TARGET_POWER"
  5669.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
  5670.   [(set_attr "length" "12")])
  5671.  
  5672. (define_insn ""
  5673.   [(set (match_operand:SI 0 "cc_reg_operand" "=x")
  5674.     (compare:CC
  5675.      (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5676.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5677.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5678.      (const_int 0)))
  5679.    (clobber (match_scratch:SI 4 "=&r"))]
  5680.   "TARGET_POWER"
  5681.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
  5682.   [(set_attr "type" "compare")
  5683.    (set_attr "length" "12")])
  5684.  
  5685. (define_insn ""
  5686.   [(set (match_operand:SI 5 "cc_reg_operand" "=x")
  5687.     (compare:CC
  5688.      (plus:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5689.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5690.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5691.      (const_int 0)))
  5692.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5693.     (plus:SI (lt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5694.    (clobber (match_scratch:SI 4 "=&r"))]
  5695.   "TARGET_POWER"
  5696.   "doz%I2 %4,%1,%2\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
  5697.   [(set_attr "type" "compare")
  5698.    (set_attr "length" "12")])
  5699.  
  5700. (define_insn ""
  5701.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5702.     (neg:SI (lt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5703.                (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  5704.   "TARGET_POWER"
  5705.   "doz%I2 %0,%1,%2\;nabs %0,%0\;{srai|srawi} %0,%0,31"
  5706.   [(set_attr "length" "12")])
  5707.  
  5708. (define_insn ""
  5709.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5710.     (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5711.         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
  5712.   ""
  5713.   "@
  5714.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg %0,%0
  5715.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
  5716.   [(set_attr "length" "12")])
  5717.  
  5718. (define_insn ""
  5719.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  5720.     (compare:CC
  5721.      (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5722.          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5723.      (const_int 0)))
  5724.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5725.     (ltu:SI (match_dup 1) (match_dup 2)))]
  5726.   ""
  5727.   "@
  5728.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;neg. %0,%0
  5729.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
  5730.   [(set_attr "type" "compare")
  5731.    (set_attr "length" "12")])
  5732.  
  5733. (define_insn ""
  5734.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r,r")
  5735.     (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r,r")
  5736.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,r,P,P"))
  5737.          (match_operand:SI 3 "reg_or_short_operand" "r,I,r,I")))
  5738.    (clobber (match_scratch:SI 4 "=&r,r,&r,r"))]
  5739.   ""
  5740.   "@
  5741.   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  5742.   {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  5743.   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  5744.   {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
  5745.  [(set_attr "length" "12")])
  5746.  
  5747. (define_insn ""
  5748.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5749.     (compare:CC
  5750.      (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5751.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5752.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5753.      (const_int 0)))
  5754.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5755.   ""
  5756.   "@
  5757.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3
  5758.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %4,%4,%3"
  5759.   [(set_attr "type" "compare")
  5760.    (set_attr "length" "12")])
  5761.  
  5762. (define_insn ""
  5763.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  5764.     (compare:CC
  5765.      (plus:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5766.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5767.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5768.      (const_int 0)))
  5769.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5770.     (plus:SI (ltu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5771.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5772.   ""
  5773.   "@
  5774.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3
  5775.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  5776.   [(set_attr "type" "compare")
  5777.    (set_attr "length" "12")])
  5778.  
  5779. (define_insn ""
  5780.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5781.     (neg:SI (ltu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5782.             (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))))]
  5783.   ""
  5784.   "@
  5785.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0
  5786.    {ai|addic} %0,%1,%n2\;{sfe|subfe} %0,%0,%0"
  5787.   [(set_attr "length" "8")])
  5788.  
  5789. (define_insn ""
  5790.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5791.     (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5792.            (match_operand:SI 2 "reg_or_short_operand" "rI")))
  5793.    (clobber (match_scratch:SI 3 "=r"))]
  5794.   "TARGET_POWER"
  5795.   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae|adde} %0,%0,%3"
  5796.    [(set_attr "length" "12")])
  5797.  
  5798. (define_insn ""
  5799.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  5800.     (compare:CC
  5801.      (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5802.         (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5803.      (const_int 0)))
  5804.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5805.     (ge:SI (match_dup 1) (match_dup 2)))
  5806.    (clobber (match_scratch:SI 3 "=r"))]
  5807.   "TARGET_POWER"
  5808.   "doz%I2 %3,%1,%2\;{sfi|subfic} %0,%3,0\;{ae.|adde.} %0,%0,%3"
  5809.   [(set_attr "type" "compare")
  5810.    (set_attr "length" "12")])
  5811.  
  5812. (define_insn ""
  5813.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5814.     (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5815.             (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5816.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  5817.    (clobber (match_scratch:SI 4 "=&r"))]
  5818.   "TARGET_POWER"
  5819.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze|addze} %0,%3"
  5820.   [(set_attr "length" "12")])
  5821.  
  5822. (define_insn ""
  5823.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5824.     (compare:CC
  5825.      (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5826.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5827.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5828.      (const_int 0)))
  5829.    (clobber (match_scratch:SI 4 "=&r"))]
  5830.   "TARGET_POWER"
  5831.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %4,%3"
  5832.   [(set_attr "type" "compare")
  5833.    (set_attr "length" "12")])
  5834.  
  5835. (define_insn ""
  5836.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  5837.     (compare:CC
  5838.      (plus:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5839.              (match_operand:SI 2 "reg_or_short_operand" "rI"))
  5840.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  5841.      (const_int 0)))
  5842.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5843.     (plus:SI (ge:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5844.    (clobber (match_scratch:SI 4 "=&r"))]
  5845.   "TARGET_POWER"
  5846.   "doz%I2 %4,%1,%2\;{sfi|subfic} %4,%4,0\;{aze.|addze.} %0,%3"
  5847.   [(set_attr "type" "compare")
  5848.    (set_attr "length" "12")])
  5849.  
  5850. (define_insn ""
  5851.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5852.     (neg:SI (ge:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  5853.                (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  5854.   "TARGET_POWER"
  5855.   "doz%I2 %0,%1,%2\;{ai|addic} %0,%0,-1\;{sfe|subfe} %0,%0,%0"
  5856.   [(set_attr "length" "12")])
  5857.  
  5858. ;; This is (and (neg (ge X (const_int 0))) Y).
  5859. (define_insn ""
  5860.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5861.     (and:SI (neg:SI
  5862.          (lshiftrt:SI
  5863.           (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  5864.           (const_int 31)))
  5865.         (match_operand:SI 2 "gpc_reg_operand" "r")))
  5866.    (clobber (match_scratch:SI 3 "=&r"))]
  5867.   ""
  5868.   "{srai|srawi} %3,%1,31\;andc %0,%2,%3"
  5869.   [(set_attr "length" "8")])
  5870.  
  5871. (define_insn ""
  5872.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  5873.     (compare:CC
  5874.      (and:SI (neg:SI
  5875.           (lshiftrt:SI
  5876.            (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  5877.            (const_int 31)))
  5878.          (match_operand:SI 2 "gpc_reg_operand" "r"))
  5879.      (const_int 0)))
  5880.    (clobber (match_scratch:SI 3 "=&r"))]
  5881.   ""
  5882.   "{srai|srawi} %3,%1,31\;andc. %3,%2,%3"
  5883.   [(set_attr "type" "compare")
  5884.    (set_attr "length" "8")])
  5885.  
  5886. (define_insn ""
  5887.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  5888.     (compare:CC
  5889.      (and:SI (neg:SI
  5890.           (lshiftrt:SI
  5891.            (not:SI (match_operand:SI 1 "gpc_reg_operand" "r"))
  5892.            (const_int 31)))
  5893.          (match_operand:SI 2 "gpc_reg_operand" "r"))
  5894.      (const_int 0)))
  5895.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  5896.     (and:SI (neg:SI (lshiftrt:SI (not:SI (match_dup 1))
  5897.                      (const_int 31)))
  5898.         (match_dup 2)))
  5899.    (clobber (match_scratch:SI 3 "=&r"))]
  5900.   ""
  5901.   "{srai|srawi} %3,%1,31\;andc. %0,%2,%3"
  5902.   [(set_attr "type" "compare")
  5903.    (set_attr "length" "8")])
  5904.  
  5905. (define_insn ""
  5906.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5907.     (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5908.         (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))]
  5909.   ""
  5910.   "@
  5911.    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0
  5912.    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae|adde} %0,%0,%0"
  5913.   [(set_attr "length" "12")])
  5914.  
  5915. (define_insn ""
  5916.   [(set (match_operand:CC 3 "cc_reg_operand" "=x,x")
  5917.     (compare:CC
  5918.      (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5919.          (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5920.      (const_int 0)))
  5921.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5922.     (geu:SI (match_dup 1) (match_dup 2)))]
  5923.   ""
  5924.   "@
  5925.    {sf|subfc} %0,%2,%1\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0
  5926.    {ai|addic} %0,%1,%n2\;{cal %0,0(0)|li %0,0}\;{ae.|adde.} %0,%0,%0"
  5927.   [(set_attr "type" "compare")
  5928.    (set_attr "length" "12")])
  5929.  
  5930. (define_insn ""
  5931.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5932.     (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5933.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5934.          (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  5935.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5936.   ""
  5937.   "@
  5938.    {sf|subfc} %4,%2,%1\;{aze|addze} %0,%3
  5939.    {ai|addic} %4,%1,%n2\;{aze|addze} %0,%3"
  5940.   [(set_attr "length" "8")])
  5941.  
  5942. (define_insn ""
  5943.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5944.     (compare:CC
  5945.      (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5946.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5947.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5948.      (const_int 0)))
  5949.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5950.   ""
  5951.   "@
  5952.    {sf|subfc} %4,%2,%1\;{aze.|addze.} %4,%3
  5953.    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
  5954.   [(set_attr "type" "compare")
  5955.    (set_attr "length" "8")])
  5956.  
  5957. (define_insn ""
  5958.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  5959.     (compare:CC
  5960.      (plus:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5961.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P"))
  5962.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  5963.      (const_int 0)))
  5964.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5965.     (plus:SI (geu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  5966.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5967.   ""
  5968.   "@
  5969.    {sf|subfc} %4,%2,%1\;{aze.|addze.} %0,%3
  5970.    {ai|addic} %4,%1,%n2\;{aze.|addze.} %4,%3"
  5971.   [(set_attr "type" "compare")
  5972.    (set_attr "length" "8")])
  5973.  
  5974. (define_insn ""
  5975.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5976.     (neg:SI (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5977.             (match_operand:SI 2 "reg_or_short_operand" "r,I"))))]
  5978.   ""
  5979.   "@
  5980.    {sf|subfc} %0,%2,%1\;{sfe|subfe} %0,%0,%0\;nand %0,%0,%0
  5981.    {sfi|subfic} %0,%1,-1\;a%I2 %0,%0,%2\;{sfe|subfe} %0,%0,%0"
  5982.   [(set_attr "length" "12")])
  5983.  
  5984. (define_insn ""
  5985.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  5986.     (and:SI (neg:SI
  5987.          (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  5988.              (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  5989.         (match_operand:SI 3 "gpc_reg_operand" "r,r")))
  5990.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  5991.   ""
  5992.   "@
  5993.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4
  5994.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc %0,%3,%4"
  5995.   [(set_attr "length" "12")])
  5996.  
  5997. (define_insn ""
  5998.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  5999.     (compare:CC
  6000.      (and:SI (neg:SI
  6001.           (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  6002.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  6003.          (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  6004.      (const_int 0)))
  6005.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  6006.   ""
  6007.   "@
  6008.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4
  6009.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %4,%3,%4"
  6010.   [(set_attr "type" "compare")
  6011.    (set_attr "length" "12")])
  6012.  
  6013. (define_insn ""
  6014.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  6015.     (compare:CC
  6016.      (and:SI (neg:SI
  6017.           (geu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  6018.               (match_operand:SI 2 "reg_or_neg_short_operand" "r,P")))
  6019.          (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  6020.      (const_int 0)))
  6021.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  6022.     (and:SI (neg:SI (geu:SI (match_dup 1) (match_dup 2))) (match_dup 3)))
  6023.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  6024.   ""
  6025.   "@
  6026.    {sf|subfc} %4,%2,%1\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4
  6027.    {ai|addic} %4,%1,%n2\;{sfe|subfe} %4,%4,%4\;andc. %0,%3,%4"
  6028.   [(set_attr "type" "compare")
  6029.    (set_attr "length" "12")])
  6030.  
  6031. (define_insn ""
  6032.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6033.     (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6034.            (const_int 0)))]
  6035.   ""
  6036.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri|srwi} %0,%0,31"
  6037.   [(set_attr "length" "12")])
  6038.  
  6039. (define_insn ""
  6040.   [(set (match_operand:CC 2 "cc_reg_operand" "=x")
  6041.     (compare:CC
  6042.      (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6043.         (const_int 0))
  6044.      (const_int 0)))
  6045.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6046.     (gt:SI (match_dup 1) (const_int 0)))]
  6047.   ""
  6048.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{sri.|srwi.} %0,%0,31"
  6049.   [(set_attr "type" "delayed_compare")
  6050.    (set_attr "length" "12")])
  6051.  
  6052. (define_insn ""
  6053.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6054.     (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6055.            (match_operand:SI 2 "reg_or_short_operand" "r")))]
  6056.   "TARGET_POWER"
  6057.   "doz %0,%2,%1\;nabs %0,%0\;{sri|srwi} %0,%0,31"
  6058.   [(set_attr "length" "12")])
  6059.  
  6060. (define_insn ""
  6061.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  6062.     (compare:CC
  6063.      (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6064.         (match_operand:SI 2 "reg_or_short_operand" "r"))
  6065.      (const_int 0)))
  6066.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6067.     (gt:SI (match_dup 1) (match_dup 2)))]
  6068.   "TARGET_POWER"
  6069.   "doz %0,%2,%1\;nabs %0,%0\;{sri.|srwi.} %0,%0,31"
  6070.   [(set_attr "type" "delayed_compare")
  6071.    (set_attr "length" "12")])
  6072.  
  6073. (define_insn ""
  6074.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6075.     (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6076.             (const_int 0))
  6077.          (match_operand:SI 2 "gpc_reg_operand" "r")))
  6078.    (clobber (match_scratch:SI 3 "=&r"))]
  6079.   ""
  6080.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze|addze} %0,%2"
  6081.   [(set_attr "length" "12")])
  6082.  
  6083. (define_insn ""
  6084.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  6085.     (compare:CC
  6086.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6087.              (const_int 0))
  6088.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  6089.      (const_int 0)))
  6090.    (clobber (match_scratch:SI 3 "=&r"))]
  6091.   ""
  6092.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %0,%2"
  6093.   [(set_attr "type" "compare")
  6094.    (set_attr "length" "12")])
  6095.  
  6096. (define_insn ""
  6097.   [(set (match_operand:CC 4 "cc_reg_operand" "=x")
  6098.     (compare:CC
  6099.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6100.              (const_int 0))
  6101.           (match_operand:SI 2 "gpc_reg_operand" "r"))
  6102.      (const_int 0)))
  6103.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6104.     (plus:SI (gt:SI (match_dup 1) (const_int 0)) (match_dup 2)))
  6105.    (clobber (match_scratch:SI 3 "=&r"))]
  6106.   ""
  6107.   "{a|addc} %3,%1,%1\;{sfe|subfe} %3,%1,%3\;{aze.|addze.} %3,%2"
  6108.   [(set_attr "type" "compare")
  6109.    (set_attr "length" "12")])
  6110.  
  6111. (define_insn ""
  6112.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6113.     (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6114.             (match_operand:SI 2 "reg_or_short_operand" "r"))
  6115.          (match_operand:SI 3 "gpc_reg_operand" "r")))
  6116.    (clobber (match_scratch:SI 4 "=&r"))]
  6117.   "TARGET_POWER"
  6118.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze|addze} %0,%3"
  6119.   [(set_attr "length" "12")])
  6120.  
  6121. (define_insn ""
  6122.   [(set (match_operand:CC 0 "cc_reg_operand" "=x")
  6123.     (compare:CC
  6124.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6125.              (match_operand:SI 2 "reg_or_short_operand" "r"))
  6126.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  6127.      (const_int 0)))
  6128.    (clobber (match_scratch:SI 4 "=&r"))]
  6129.   "TARGET_POWER"
  6130.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %4,%3"
  6131.   [(set_attr "type" "compare")
  6132.    (set_attr "length" "12")])
  6133.  
  6134. (define_insn ""
  6135.   [(set (match_operand:CC 5 "cc_reg_operand" "=x")
  6136.     (compare:CC
  6137.      (plus:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6138.              (match_operand:SI 2 "reg_or_short_operand" "r"))
  6139.           (match_operand:SI 3 "gpc_reg_operand" "r"))
  6140.      (const_int 0)))
  6141.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6142.     (plus:SI (gt:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  6143.    (clobber (match_scratch:SI 4 "=&r"))]
  6144.   "TARGET_POWER"
  6145.   "doz %4,%2,%1\;{ai|addic} %4,%4,-1\;{aze.|addze.} %0,%3"
  6146.   [(set_attr "type" "compare")
  6147.    (set_attr "length" "12")])
  6148.  
  6149. (define_insn ""
  6150.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6151.     (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6152.                (const_int 0))))]
  6153.   ""
  6154.   "{sfi|subfic} %0,%1,0\;{ame|addme} %0,%0\;{srai|srawi} %0,%0,31"
  6155.   [(set_attr "length" "12")])
  6156.  
  6157. (define_insn ""
  6158.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6159.     (neg:SI (gt:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6160.                (match_operand:SI 2 "reg_or_short_operand" "r"))))]
  6161.   "TARGET_POWER"
  6162.   "doz %0,%2,%1\;nabs %0,%0\;{srai|srawi} %0,%0,31"
  6163.   [(set_attr "length" "12")])
  6164.  
  6165. (define_insn ""
  6166.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6167.     (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6168.         (match_operand:SI 2 "reg_or_short_operand" "rI")))]
  6169.   ""
  6170.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg %0,%0"
  6171.   [(set_attr "length" "12")])
  6172.  
  6173. (define_insn ""
  6174.   [(set (match_operand:CC 3 "cc_reg_operand" "=x")
  6175.     (compare:CC
  6176.      (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6177.          (match_operand:SI 2 "reg_or_short_operand" "rI"))
  6178.      (const_int 0)))
  6179.    (set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6180.     (gtu:SI (match_dup 1) (match_dup 2)))]
  6181.   ""
  6182.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0\;neg. %0,%0"
  6183.   [(set_attr "type" "compare")
  6184.    (set_attr "length" "12")])
  6185.  
  6186. (define_insn ""
  6187.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r,r")
  6188.     (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r,r")
  6189.              (match_operand:SI 2 "reg_or_short_operand" "I,r,rI"))
  6190.          (match_operand:SI 3 "reg_or_short_operand" "r,r,I")))
  6191.    (clobber (match_scratch:SI 4 "=&r,&r,&r"))]
  6192.   ""
  6193.   "@
  6194.    {ai|addic} %4,%1,%k2\;{aze|addze} %0,%3
  6195.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3
  6196.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf%I3|subf%I3c} %0,%4,%3"
  6197.   [(set_attr "length" "8,12,12")])
  6198.  
  6199. (define_insn ""
  6200.   [(set (match_operand:CC 0 "cc_reg_operand" "=x,x")
  6201.     (compare:CC
  6202.      (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  6203.               (match_operand:SI 2 "reg_or_short_operand" "I,r"))
  6204.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  6205.      (const_int 0)))
  6206.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  6207.   ""
  6208.   "@
  6209.    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
  6210.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  6211.   [(set_attr "type" "compare")
  6212.    (set_attr "length" "8,12")])
  6213.  
  6214. (define_insn ""
  6215.   [(set (match_operand:CC 5 "cc_reg_operand" "=x,x")
  6216.     (compare:CC
  6217.      (plus:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r,r")
  6218.               (match_operand:SI 2 "reg_or_short_operand" "I,r"))
  6219.           (match_operand:SI 3 "gpc_reg_operand" "r,r"))
  6220.      (const_int 0)))
  6221.    (set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
  6222.     (plus:SI (gtu:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
  6223.    (clobber (match_scratch:SI 4 "=&r,&r"))]
  6224.   ""
  6225.   "@
  6226.    {ai|addic} %4,%1,%k2\;{aze.|addze.} %0,%3
  6227.    {sf%I2|subf%I2c} %4,%1,%2\;{sfe|subfe} %4,%4,%4\;{sf.|subfc.} %0,%4,%3"
  6228.   [(set_attr "type" "compare")
  6229.    (set_attr "length" "8,12")])
  6230.  
  6231. (define_insn ""
  6232.   [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
  6233.     (neg:SI (gtu:SI (match_operand:SI 1 "gpc_reg_operand" "r")
  6234.             (match_operand:SI 2 "reg_or_short_operand" "rI"))))]
  6235.   ""
  6236.   "{sf%I2|subf%I2c} %0,%1,%2\;{sfe|subfe} %0,%0,%0"
  6237.   [(set_attr "length" "8")])
  6238.  
  6239. ;; Define both directions of branch and return.  If we need a reload
  6240. ;; register, we'd rather use CR0 since it is much easier to copy a
  6241. ;; register CC value to there.
  6242.  
  6243. (define_insn ""
  6244.   [(set (pc)
  6245.     (if_then_else (match_operator 1 "branch_comparison_operator"
  6246.                       [(match_operand 2
  6247.                               "cc_reg_operand" "x,?y")
  6248.                        (const_int 0)])
  6249.               (label_ref (match_operand 0 "" ""))
  6250.               (pc)))]
  6251.   ""
  6252.   "*
  6253. {
  6254.   if (get_attr_length (insn) == 8)
  6255.     return \"%C1bc %t1,%j1,%l0\";
  6256.   else
  6257.     return \"%C1bc %T1,%j1,$+8\;b %l0\";
  6258. }"
  6259.   [(set_attr "type" "branch")])
  6260.  
  6261. (define_insn ""
  6262.   [(set (pc)
  6263.     (if_then_else (match_operator 0 "branch_comparison_operator"
  6264.                       [(match_operand 1
  6265.                               "cc_reg_operand" "x,?y")
  6266.                        (const_int 0)])
  6267.               (return)
  6268.               (pc)))]
  6269.   "direct_return ()"
  6270.   "{%C0bcr|%C0bclr} %t0,%j0"
  6271.   [(set_attr "length" "8")])
  6272.  
  6273. (define_insn ""
  6274.   [(set (pc)
  6275.     (if_then_else (match_operator 1 "branch_comparison_operator"
  6276.                       [(match_operand 2
  6277.                               "cc_reg_operand" "x,?y")
  6278.                        (const_int 0)])
  6279.               (pc)
  6280.               (label_ref (match_operand 0 "" ""))))]
  6281.   ""
  6282.   "*
  6283. {
  6284.   if (get_attr_length (insn) == 8)
  6285.     return \"%C1bc %T1,%j1,%l0\";
  6286.   else
  6287.     return \"%C1bc %t1,%j1,$+8\;b %l0\";
  6288. }"
  6289.   [(set_attr "type" "branch")])
  6290.  
  6291. (define_insn ""
  6292.   [(set (pc)
  6293.     (if_then_else (match_operator 0 "branch_comparison_operator"
  6294.                       [(match_operand 1
  6295.                               "cc_reg_operand" "x,?y")
  6296.                        (const_int 0)])
  6297.               (pc)
  6298.               (return)))]
  6299.   "direct_return ()"
  6300.   "{%C0bcr|%C0bclr} %T0,%j0"
  6301.   [(set_attr "length" "8")])
  6302.  
  6303. ;; Unconditional branch and return.
  6304.  
  6305. (define_insn "jump"
  6306.   [(set (pc)
  6307.     (label_ref (match_operand 0 "" "")))]
  6308.   ""
  6309.   "b %l0")
  6310.  
  6311. (define_insn "return"
  6312.   [(return)]
  6313.   "direct_return ()"
  6314.   "{br|blr}"
  6315.   [(set_attr "type" "jmpreg")])
  6316.  
  6317. (define_insn "indirect_jump"
  6318.   [(set (pc) (match_operand:SI 0 "register_operand" "c,l"))]
  6319.   ""
  6320.   "@
  6321.    bctr
  6322.    {br|blr}"
  6323.   [(set_attr "type" "jmpreg")])
  6324.  
  6325. ;; Table jump for switch statements:
  6326. (define_expand "tablejump"
  6327.   [(set (match_dup 3)
  6328.     (plus:SI (match_operand:SI 0 "" "")
  6329.          (match_dup 2)))
  6330.    (parallel [(set (pc) (match_dup 3))
  6331.           (use (label_ref (match_operand 1 "" "")))])]
  6332.   ""
  6333.   "
  6334. { operands[0] = force_reg (SImode, operands[0]);
  6335.   operands[2] = force_reg (SImode, gen_rtx (LABEL_REF, VOIDmode, operands[1]));
  6336.   operands[3] = gen_reg_rtx (SImode);
  6337. }")
  6338.  
  6339. (define_insn ""
  6340.   [(set (pc)
  6341.     (match_operand:SI 0 "register_operand" "c,l"))
  6342.    (use (label_ref (match_operand 1 "" "")))]
  6343.   ""
  6344.   "@
  6345.    bctr
  6346.    {br|blr}")
  6347.  
  6348. (define_insn "nop"
  6349.   [(const_int 0)]
  6350.   ""
  6351.   "{cror 0,0,0|nop}")
  6352.  
  6353. ;; Define the subtract-one-and-jump insns, starting with the template 
  6354. ;; so loop.c knows what to generate.
  6355.  
  6356. (define_expand "decrement_and_branchsi"
  6357.   [(parallel [(set (pc) (if_then_else (ne (match_operand:SI 0 "register_operand" "c")
  6358.                       (const_int 1))
  6359.                       (label_ref (match_operand 1 "" ""))
  6360.                       (pc)))
  6361.           (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))])]
  6362.   ""
  6363.   "")
  6364.  
  6365. ;; We need to be able to do this for any operand, including MEM, or we
  6366. ;; will cause reload to blow up since we don't allow output reloads on
  6367. ;; JUMP_INSNs. 
  6368. (define_insn ""
  6369.   [(set (pc)
  6370.     (if_then_else (ne (match_operand:SI 1 "register_operand" "0,*r,*r")
  6371.               (const_int 1))
  6372.               (label_ref (match_operand 2 "" ""))
  6373.               (pc)))
  6374.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  6375.     (plus:SI (match_dup 1) (const_int -1)))
  6376.    (clobber (match_scratch:CC 3 "=X,&x,&x"))
  6377.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  6378.   ""
  6379.   "*
  6380. {
  6381.   if (which_alternative != 0)
  6382.     return \"#\";
  6383.   else if (get_attr_length (insn) == 8)
  6384.     return \"{bdn|bdnz} %l2\";
  6385.   else
  6386.     return \"bdz $+8\;b %l2\";
  6387. }"
  6388.   [(set_attr "type" "branch")
  6389.    (set_attr "length" "*,12,16")])
  6390.                    
  6391. ;; Similar, but we can use GE since we have a REG_NONNEG.
  6392. (define_insn ""
  6393.   [(set (pc)
  6394.     (if_then_else (ge (match_operand:SI 1 "register_operand" "0,*r,*r")
  6395.               (const_int 0))
  6396.               (label_ref (match_operand 2 "" ""))
  6397.               (pc)))
  6398.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  6399.     (plus:SI (match_dup 1) (const_int -1)))
  6400.    (clobber (match_scratch:CC 3 "=X,&x,&X"))
  6401.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  6402.   "find_reg_note (insn, REG_NONNEG, 0)"
  6403.   "*
  6404. {
  6405.   if (which_alternative != 0)
  6406.     return \"#\";
  6407.   else if (get_attr_length (insn) == 8)
  6408.     return \"{bdn|bdnz} %l2\";
  6409.   else
  6410.     return \"bdz $+8\;b %l2\";
  6411. }"
  6412.   [(set_attr "type" "branch")
  6413.    (set_attr "length" "*,12,16")])
  6414.                    
  6415. (define_insn ""
  6416.   [(set (pc)
  6417.     (if_then_else (eq (match_operand:SI 1 "register_operand" "0,*r,*r")
  6418.               (const_int 1))
  6419.               (label_ref (match_operand 2 "" ""))
  6420.               (pc)))
  6421.    (set (match_operand:SI 0 "register_operand" "=c,*r,m*q*c*l")
  6422.     (plus:SI (match_dup 1) (const_int -1)))
  6423.    (clobber (match_scratch:CC 3 "=X,&x,&x"))
  6424.    (clobber (match_scratch:SI 4 "=X,X,r"))]
  6425.   ""
  6426.   "*
  6427. {
  6428.   if (which_alternative != 0)
  6429.     return \"#\";
  6430.   else if (get_attr_length (insn) == 8)
  6431.     return \"bdz %l2\";
  6432.   else
  6433.     return \"{bdn|bdnz} $+8\;b %l2\";
  6434. }"
  6435.   [(set_attr "type" "branch")
  6436.    (set_attr "length" "*,12,16")])
  6437.  
  6438. (define_split
  6439.   [(set (pc)
  6440.     (if_then_else (match_operator 2 "comparison_operator"
  6441.                       [(match_operand:SI 1 "gpc_reg_operand" "")
  6442.                        (const_int 1)])
  6443.               (match_operand 5 "" "")
  6444.               (match_operand 6 "" "")))
  6445.    (set (match_operand:SI 0 "gpc_reg_operand" "")
  6446.     (plus:SI (match_dup 1) (const_int -1)))
  6447.    (clobber (match_scratch:CC 3 ""))
  6448.    (clobber (match_scratch:SI 4 ""))]
  6449.   "reload_completed"
  6450.   [(parallel [(set (match_dup 3)
  6451.            (compare:CC (plus:SI (match_dup 1) (const_int -1))
  6452.                    (const_int 0)))
  6453.           (set (match_dup 0) (plus:SI (match_dup 1) (const_int -1)))])
  6454.    (set (pc) (if_then_else (match_dup 7) (match_dup 5) (match_dup 6)))]
  6455.   "
  6456. { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
  6457.              const0_rtx); }")
  6458.  
  6459. (define_split
  6460.   [(set (pc)
  6461.     (if_then_else (match_operator 2 "comparison_operator"
  6462.                       [(match_operand:SI 1 "gpc_reg_operand" "")
  6463.                        (const_int 1)])
  6464.               (match_operand 5 "" "")
  6465.               (match_operand 6 "" "")))
  6466.    (set (match_operand:SI 0 "general_operand" "")
  6467.     (plus:SI (match_dup 1) (const_int -1)))
  6468.    (clobber (match_scratch:CC 3 ""))
  6469.    (clobber (match_scratch:SI 4 ""))]
  6470.   "reload_completed && ! gpc_reg_operand (operands[0], SImode)"
  6471.   [(parallel [(set (match_dup 3)
  6472.            (compare:CC (plus:SI (match_dup 1) (const_int -1))
  6473.                    (const_int 0)))
  6474.           (set (match_dup 4) (plus:SI (match_dup 1) (const_int -1)))])
  6475.    (set (match_dup 0) (match_dup 4))
  6476.    (set (pc) (if_then_else (match_dup 7) (match_dup 5) (match_dup 6)))]
  6477.   "
  6478. { operands[7] = gen_rtx (GET_CODE (operands[2]), VOIDmode, operands[3],
  6479.              const0_rtx); }")
  6480.