2005-05-09 Adrian Straetling <straetling@de.ibm.com>
[official-gcc.git] / gcc / config / s390 / s390.md
blob0c752f5e02c7a954701cde046ba0894bf8ec4944
1 ;;- Machine description for GNU compiler -- S/390 / zSeries version.
2 ;;  Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 ;;  Free Software Foundation, Inc.
4 ;;  Contributed by Hartmut Penner (hpenner@de.ibm.com) and
5 ;;                 Ulrich Weigand (uweigand@de.ibm.com).
7 ;; This file is part of GCC.
9 ;; GCC is free software; you can redistribute it and/or modify it under
10 ;; the terms of the GNU General Public License as published by the Free
11 ;; Software Foundation; either version 2, or (at your option) any later
12 ;; version.
14 ;; GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 ;; WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 ;; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 ;; for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GCC; see the file COPYING.  If not, write to the Free
21 ;; Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 ;; 02111-1307, USA.
25 ;; Special constraints for s/390 machine description:
27 ;;    a -- Any address register from 1 to 15.
28 ;;    c -- Condition code register 33.
29 ;;    d -- Any register from 0 to 15.
30 ;;    I -- An 8-bit constant (0..255).
31 ;;    J -- A 12-bit constant (0..4095).
32 ;;    K -- A 16-bit constant (-32768..32767).
33 ;;    L -- Value appropriate as displacement.
34 ;;         (0..4095) for short displacement
35 ;;         (-524288..524287) for long displacement
36 ;;    M -- Constant integer with a value of 0x7fffffff.
37 ;;    N -- Multiple letter constraint followed by 4 parameter letters.
38 ;;         0..9,x:  number of the part counting from most to least significant
39 ;;         H,Q:     mode of the part
40 ;;         D,S,H:   mode of the containing operand
41 ;;         0,F:     value of the other parts (F - all bits set)
43 ;;         The constraint matches if the specified part of a constant
44 ;;         has a value different from its other parts.  If the letter x
45 ;;         is specified instead of a part number, the constraint matches
46 ;;         if there is any single part with non-default value.
47 ;;    Q -- Memory reference without index register and with short displacement.
48 ;;    R -- Memory reference with index register and short displacement.
49 ;;    S -- Memory reference without index register but with long displacement.
50 ;;    T -- Memory reference with index register and long displacement.
51 ;;    A -- Multiple letter constraint followed by Q, R, S, or T:
52 ;;         Offsettable memory reference of type specified by second letter.
53 ;;    B -- Multiple letter constraint followed by Q, R, S, or T:
54 ;;         Memory reference of the type specified by second letter that
55 ;;         does *not* refer to a literal pool entry.
56 ;;    U -- Pointer with short displacement.
57 ;;    W -- Pointer with long displacement.
58 ;;    Y -- Shift count operand.
60 ;; Special formats used for outputting 390 instructions.
62 ;;     %C: print opcode suffix for branch condition.
63 ;;     %D: print opcode suffix for inverse branch condition.
64 ;;     %J: print tls_load/tls_gdcall/tls_ldcall suffix
65 ;;     %O: print only the displacement of a memory reference.
66 ;;     %R: print only the base register of a memory reference.
67 ;;     %S: print S-type memory reference (base+displacement).
68 ;;     %N: print the second word of a DImode operand.
69 ;;     %M: print the second word of a TImode operand.
71 ;;     %b: print integer X as if it's an unsigned byte.
72 ;;     %x: print integer X as if it's an unsigned word.
73 ;;     %h: print integer X as if it's a signed word.
74 ;;     %i: print the first nonzero HImode part of X
75 ;;     %j: print the first HImode part unequal to 0xffff of X
78 ;; We have a special constraint for pattern matching.
80 ;;   s_operand -- Matches a valid S operand in a RS, SI or SS type instruction.
84 ;; UNSPEC usage
87 (define_constants
88   [; Miscellaneous
89    (UNSPEC_ROUND                1)
90    (UNSPEC_CMPINT               2)
91    (UNSPEC_SETHIGH              10)
93    ; GOT/PLT and lt-relative accesses
94    (UNSPEC_LTREL_OFFSET         100)
95    (UNSPEC_LTREL_BASE           101)
96    (UNSPEC_GOTENT               110)
97    (UNSPEC_GOT                  111)
98    (UNSPEC_GOTOFF               112)
99    (UNSPEC_PLT                  113)
100    (UNSPEC_PLTOFF               114)
102    ; Literal pool
103    (UNSPEC_RELOAD_BASE          210)
104    (UNSPEC_MAIN_BASE            211)
105    (UNSPEC_LTREF                212)
106    (UNSPEC_INSN                 213)
107    (UNSPEC_EXECUTE              214)
109    ; TLS relocation specifiers
110    (UNSPEC_TLSGD                500)
111    (UNSPEC_TLSLDM               501)
112    (UNSPEC_NTPOFF               502)
113    (UNSPEC_DTPOFF               503)
114    (UNSPEC_GOTNTPOFF            504)
115    (UNSPEC_INDNTPOFF            505)
117    ; TLS support
118    (UNSPEC_TLSLDM_NTPOFF        511)
119    (UNSPEC_TLS_LOAD             512)
121    ; String Functions
122    (UNSPEC_SRST         600)
123  ])
126 ;; UNSPEC_VOLATILE usage
129 (define_constants
130   [; Blockage
131    (UNSPECV_BLOCKAGE            0)
133    ; TPF Support
134    (UNSPECV_TPF_PROLOGUE        20)
135    (UNSPECV_TPF_EPILOGUE        21)
137    ; Literal pool
138    (UNSPECV_POOL                200)
139    (UNSPECV_POOL_SECTION        201)
140    (UNSPECV_POOL_ALIGN          202)
141    (UNSPECV_POOL_ENTRY          203)
142    (UNSPECV_MAIN_POOL           300)
144    ; TLS support
145    (UNSPECV_SET_TP              500)
146   ])
149 ;; Instruction operand type as used in the Principles of Operation.
150 ;; Used to determine defaults for length and other attribute values.
152 (define_attr "op_type"
153   "NN,E,RR,RRE,RX,RS,RSI,RI,SI,S,SS,SSE,RXE,RSE,RIL,RIE,RXY,RSY,SIY"
154   (const_string "NN"))
156 ;; Instruction type attribute used for scheduling.
158 (define_attr "type" "none,integer,load,lr,la,larl,lm,stm,
159                      cs,vs,store,idiv,
160                      imulhi,imulsi,imuldi,
161                      branch,jsr,fsimpdf,fsimpsf,
162                      floaddf,floadsf,fstoredf,fstoresf,
163                      fmuldf,fmulsf,fdivdf,fdivsf,
164                      ftoi,itof,fsqrtdf,fsqrtsf,
165                      other"
166   (cond [(eq_attr "op_type" "NN")  (const_string "other")
167          (eq_attr "op_type" "SS")  (const_string "cs")]
168     (const_string "integer")))
170 ;; Another attribute used for scheduling purposes:
171 ;;   agen: Instruction uses the address generation unit
172 ;;   reg: Instruction does not use the agen unit
174 (define_attr "atype" "agen,reg"
175   (cond [(eq_attr "op_type" "E")   (const_string "reg")
176          (eq_attr "op_type" "RR")  (const_string "reg")
177          (eq_attr "op_type" "RX")  (const_string "agen")
178          (eq_attr "op_type" "RI")  (const_string "reg")
179          (eq_attr "op_type" "RRE") (const_string "reg")
180          (eq_attr "op_type" "RS")  (const_string "agen")
181          (eq_attr "op_type" "RSI") (const_string "agen")
182          (eq_attr "op_type" "S")   (const_string "agen")
183          (eq_attr "op_type" "SI")  (const_string "agen")
184          (eq_attr "op_type" "SS")  (const_string "agen")
185          (eq_attr "op_type" "SSE") (const_string "agen")
186          (eq_attr "op_type" "RXE") (const_string "agen")
187          (eq_attr "op_type" "RSE") (const_string "agen")
188          (eq_attr "op_type" "RIL") (const_string "agen")
189          (eq_attr "op_type" "RXY") (const_string "agen")
190          (eq_attr "op_type" "RSY") (const_string "agen")
191          (eq_attr "op_type" "SIY") (const_string "agen")]
192     (const_string "agen")))
194 ;; Length in bytes.
196 (define_attr "length" ""
197   (cond [(eq_attr "op_type" "E")   (const_int 2)
198          (eq_attr "op_type" "RR")  (const_int 2)
199          (eq_attr "op_type" "RX")  (const_int 4)
200          (eq_attr "op_type" "RI")  (const_int 4)
201          (eq_attr "op_type" "RRE") (const_int 4)
202          (eq_attr "op_type" "RS")  (const_int 4)
203          (eq_attr "op_type" "RSI") (const_int 4)
204          (eq_attr "op_type" "S")   (const_int 4)
205          (eq_attr "op_type" "SI")  (const_int 4)
206          (eq_attr "op_type" "SS")  (const_int 6)
207          (eq_attr "op_type" "SSE") (const_int 6)
208          (eq_attr "op_type" "RXE") (const_int 6)
209          (eq_attr "op_type" "RSE") (const_int 6)
210          (eq_attr "op_type" "RIL") (const_int 6)
211          (eq_attr "op_type" "RXY") (const_int 6)
212          (eq_attr "op_type" "RSY") (const_int 6)
213          (eq_attr "op_type" "SIY") (const_int 6)]
214     (const_int 6)))
217 ;; Processor type.  This attribute must exactly match the processor_type
218 ;; enumeration in s390.h.  The current machine description does not
219 ;; distinguish between g5 and g6, but there are differences between the two
220 ;; CPUs could in theory be modeled.
222 (define_attr "cpu" "g5,g6,z900,z990"
223   (const (symbol_ref "s390_tune")))
225 ;; Pipeline description for z900.  For lack of anything better,
226 ;; this description is also used for the g5 and g6.
227 (include "2064.md")
229 ;; Pipeline description for z990. 
230 (include "2084.md")
232 ;; Predicates
233 (include "predicates.md")
236 ;; Macros
238 ;; This mode macro allows DF and SF patterns to be generated from the
239 ;; same template.
240 (define_mode_macro FPR     [DF SF])
242 ;; These mode macros allow 31-bit and 64-bit GPR patterns to be generated
243 ;; from the same template.
244 (define_mode_macro GPR [(DI "TARGET_64BIT") SI])
245 (define_mode_macro DSI [DI SI])
247 ;; This mode macro allows :P to be used for patterns that operate on
248 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
249 (define_mode_macro P [(DI "TARGET_64BIT") (SI "!TARGET_64BIT")])
251 ;; This mode macro allows the QI and HI patterns to be defined from
252 ;; the same template.
253 (define_mode_macro HQI [HI QI])
255 ;; This mode macro allows the integer patterns to be defined from the
256 ;; same template.
257 (define_mode_macro INT [(DI "TARGET_64BIT") SI HI QI])
259 ;; This macro allows to unify all 'bCOND' expander patterns.
260 (define_code_macro COMPARE [eq ne gt gtu lt ltu ge geu le leu unordered 
261                             ordered uneq unlt ungt unle unge ltgt])
263 ;; This macro allows to unify all 'sCOND' patterns.
264 (define_code_macro SCOND [ltu gtu leu geu])
266 ;; This macro allows some 'ashift' and 'lshiftrt' pattern to be defined from
267 ;; the same template.
268 (define_code_macro SHIFT [ashift lshiftrt])
271 ;; In FPR templates, a string like "lt<de>br" will expand to "ltdbr" in DFmode
272 ;; and "ltebr" in SFmode.
273 (define_mode_attr de [(DF "d") (SF "e")])
275 ;; In FPR templates, a string like "m<dee>br" will expand to "mdbr" in DFmode
276 ;; and "meebr" in SFmode.  This is needed for the 'mul<mode>3' pattern. 
277 (define_mode_attr dee [(DF "d") (SF "ee")])
279 ;; In SHIFT templates, a string like "s<lr>dl" will expand to "sldl" in 
280 ;; 'ashift' and "srdl" in 'lshiftrt'.
281 (define_code_attr lr [(ashift "l") (lshiftrt "r")])
283 ;; In SHIFT templates, this attribute holds the correct standard name for the
284 ;; pattern itself and the corresponding function calls. 
285 (define_code_attr shift [(ashift "ashl") (lshiftrt "lshr")])
287 ;; This attribute handles differences in the instruction 'type' and will result
288 ;; in "RRE" for DImode and "RR" for SImode.
289 (define_mode_attr E [(DI "E") (SI "")])
291 ;; In GPR templates, a string like "lc<g>r" will expand to "lcgr" in DImode
292 ;; and "lcr" in SImode.
293 (define_mode_attr g [(DI "g") (SI "")])
295 ;; ICM mask required to load MODE value into the highest subreg
296 ;; of a SImode register.
297 (define_mode_attr icm_hi [(HI "12") (QI "8")])
299 ;; ICM mask required to load MODE value into the lowest subreg
300 ;; of a SImode register.
301 (define_mode_attr icm_lo [(HI "3") (QI "1")])
303 ;; In HQI templates, a string like "llg<hc>" will expand to "llgh" in
304 ;; HImode and "llgc" in QImode.
305 (define_mode_attr hc [(HI "h") (QI "c")])
307 ;; Maximum unsigned integer that fits in MODE.
308 (define_mode_attr max_uint [(HI "65535") (QI "255")])
312 ;;- Compare instructions.
315 (define_expand "cmp<mode>"
316   [(set (reg:CC 33)
317         (compare:CC (match_operand:GPR 0 "register_operand" "")
318                     (match_operand:GPR 1 "general_operand" "")))]
319   ""
321   s390_compare_op0 = operands[0];
322   s390_compare_op1 = operands[1];
323   DONE;
326 (define_expand "cmp<mode>"
327   [(set (reg:CC 33)
328         (compare:CC (match_operand:FPR 0 "register_operand" "")
329                     (match_operand:FPR 1 "general_operand" "")))]
330   "TARGET_HARD_FLOAT"
332   s390_compare_op0 = operands[0];
333   s390_compare_op1 = operands[1];
334   DONE;
338 ; Test-under-Mask instructions
340 (define_insn "*tmqi_mem"
341   [(set (reg 33)
342         (compare (and:QI (match_operand:QI 0 "memory_operand" "Q,S")
343                          (match_operand:QI 1 "immediate_operand" "n,n"))
344                  (match_operand:QI 2 "immediate_operand" "n,n")))]
345   "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], 0))"
346   "@
347    tm\t%S0,%b1
348    tmy\t%S0,%b1"
349   [(set_attr "op_type" "SI,SIY")])
351 (define_insn "*tmdi_reg"
352   [(set (reg 33)
353         (compare (and:DI (match_operand:DI 0 "nonimmediate_operand" "d,d,d,d")
354                          (match_operand:DI 1 "immediate_operand"
355                                              "N0HD0,N1HD0,N2HD0,N3HD0"))
356                  (match_operand:DI 2 "immediate_operand" "n,n,n,n")))]
357   "TARGET_64BIT
358    && s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], 1))
359    && s390_single_part (operands[1], DImode, HImode, 0) >= 0"
360   "@
361    tmhh\t%0,%i1
362    tmhl\t%0,%i1
363    tmlh\t%0,%i1
364    tmll\t%0,%i1"
365   [(set_attr "op_type" "RI")])
367 (define_insn "*tmsi_reg"
368   [(set (reg 33)
369         (compare (and:SI (match_operand:SI 0 "nonimmediate_operand" "d,d")
370                          (match_operand:SI 1 "immediate_operand" "N0HS0,N1HS0"))
371                  (match_operand:SI 2 "immediate_operand" "n,n")))]
372   "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], 1))
373    && s390_single_part (operands[1], SImode, HImode, 0) >= 0"
374   "@
375    tmh\t%0,%i1
376    tml\t%0,%i1"
377   [(set_attr "op_type" "RI")])
379 (define_insn "*tm<mode>_full"
380   [(set (reg 33)
381         (compare (match_operand:HQI 0 "register_operand" "d")
382                  (match_operand:HQI 1 "immediate_operand" "n")))]
383   "s390_match_ccmode (insn, s390_tm_ccmode (constm1_rtx, operands[1], 1))"
384   "tml\t%0,<max_uint>"
385   [(set_attr "op_type" "RI")])
388 ; Load-and-Test instructions
390 (define_insn "*tstdi_sign"
391   [(set (reg 33)
392         (compare (ashiftrt:DI (ashift:DI (subreg:DI (match_operand:SI 0 "register_operand" "d") 0)
393                                          (const_int 32)) (const_int 32))
394                  (match_operand:DI 1 "const0_operand" "")))
395    (set (match_operand:DI 2 "register_operand" "=d")
396         (sign_extend:DI (match_dup 0)))]
397   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
398   "ltgfr\t%2,%0"
399   [(set_attr "op_type" "RRE")])
401 (define_insn "*tstdi"
402   [(set (reg 33)
403         (compare (match_operand:DI 0 "register_operand" "d")
404                  (match_operand:DI 1 "const0_operand" "")))
405    (set (match_operand:DI 2 "register_operand" "=d")
406         (match_dup 0))]
407   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
408   "ltgr\t%2,%0"
409   [(set_attr "op_type" "RRE")])
411 (define_insn "*tstdi_cconly"
412   [(set (reg 33)
413         (compare (match_operand:DI 0 "register_operand" "d")
414                  (match_operand:DI 1 "const0_operand" "")))]
415   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
416   "ltgr\t%0,%0"
417   [(set_attr "op_type" "RRE")])
419 (define_insn "*tstdi_cconly_31"
420   [(set (reg 33)
421         (compare (match_operand:DI 0 "register_operand" "d")
422                  (match_operand:DI 1 "const0_operand" "")))]
423   "s390_match_ccmode(insn, CCSmode) && !TARGET_64BIT"
424   "srda\t%0,0"
425   [(set_attr "op_type" "RS")
426    (set_attr "atype"   "reg")])
429 (define_insn "*tstsi"
430   [(set (reg 33)
431         (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
432                  (match_operand:SI 1 "const0_operand" "")))
433    (set (match_operand:SI 2 "register_operand" "=d,d,d")
434         (match_dup 0))]
435   "s390_match_ccmode(insn, CCSmode)"
436   "@
437    ltr\t%2,%0
438    icm\t%2,15,%S0
439    icmy\t%2,15,%S0"
440   [(set_attr "op_type" "RR,RS,RSY")])
442 (define_insn "*tstsi_cconly"
443   [(set (reg 33)
444         (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
445                  (match_operand:SI 1 "const0_operand" "")))
446    (clobber (match_scratch:SI 2 "=X,d,d"))]
447   "s390_match_ccmode(insn, CCSmode)"
448   "@
449    ltr\t%0,%0
450    icm\t%2,15,%S0
451    icmy\t%2,15,%S0"
452   [(set_attr "op_type" "RR,RS,RSY")])
454 (define_insn "*tstsi_cconly2"
455   [(set (reg 33)
456         (compare (match_operand:SI 0 "register_operand" "d")
457                  (match_operand:SI 1 "const0_operand" "")))]
458   "s390_match_ccmode(insn, CCSmode)"
459   "ltr\t%0,%0"
460   [(set_attr "op_type" "RR")])
462 (define_insn "*tst<mode>CCT"
463   [(set (reg 33)
464         (compare (match_operand:HQI 0 "nonimmediate_operand" "?Q,?S,d")
465                  (match_operand:HQI 1 "const0_operand" "")))
466    (set (match_operand:HQI 2 "register_operand" "=d,d,0")
467         (match_dup 0))]
468   "s390_match_ccmode(insn, CCTmode)"
469   "@
470    icm\t%2,<icm_lo>,%S0
471    icmy\t%2,<icm_lo>,%S0
472    tml\t%0,<max_uint>"
473   [(set_attr "op_type" "RS,RSY,RI")])
475 (define_insn "*tsthiCCT_cconly"
476   [(set (reg 33)
477         (compare (match_operand:HI 0 "nonimmediate_operand" "Q,S,d")
478                  (match_operand:HI 1 "const0_operand" "")))
479    (clobber (match_scratch:HI 2 "=d,d,X"))]
480   "s390_match_ccmode(insn, CCTmode)"
481   "@
482    icm\t%2,3,%S0
483    icmy\t%2,3,%S0
484    tml\t%0,65535"
485   [(set_attr "op_type" "RS,RSY,RI")])
487 (define_insn "*tstqiCCT_cconly"
488   [(set (reg 33)
489         (compare (match_operand:QI 0 "nonimmediate_operand" "?Q,?S,d")
490                  (match_operand:QI 1 "const0_operand" "")))]
491   "s390_match_ccmode(insn, CCTmode)"
492   "@
493    cli\t%S0,0
494    cliy\t%S0,0
495    tml\t%0,255"
496   [(set_attr "op_type" "SI,SIY,RI")])
498 (define_insn "*tst<mode>"
499   [(set (reg 33)
500         (compare (match_operand:HQI 0 "s_operand" "Q,S")
501                  (match_operand:HQI 1 "const0_operand" "")))
502    (set (match_operand:HQI 2 "register_operand" "=d,d")
503         (match_dup 0))]
504   "s390_match_ccmode(insn, CCSmode)"
505   "@
506    icm\t%2,<icm_lo>,%S0
507    icmy\t%2,<icm_lo>,%S0"
508   [(set_attr "op_type" "RS,RSY")])
510 (define_insn "*tst<mode>_cconly"
511   [(set (reg 33)
512         (compare (match_operand:HQI 0 "s_operand" "Q,S")
513                  (match_operand:HQI 1 "const0_operand" "")))
514    (clobber (match_scratch:HQI 2 "=d,d"))]
515   "s390_match_ccmode(insn, CCSmode)"
516   "@
517    icm\t%2,<icm_lo>,%S0
518    icmy\t%2,<icm_lo>,%S0"
519   [(set_attr "op_type" "RS,RSY")])
522 ; Compare (equality) instructions
524 (define_insn "*cmpdi_cct"
525   [(set (reg 33)
526         (compare (match_operand:DI 0 "nonimmediate_operand" "%d,d,d,Q")
527                  (match_operand:DI 1 "general_operand" "d,K,m,BQ")))]
528   "s390_match_ccmode (insn, CCTmode) && TARGET_64BIT"
529   "@
530    cgr\t%0,%1
531    cghi\t%0,%h1
532    cg\t%0,%1
533    #"
534   [(set_attr "op_type" "RRE,RI,RXY,SS")])
536 (define_insn "*cmpsi_cct"
537   [(set (reg 33)
538         (compare (match_operand:SI 0 "nonimmediate_operand" "%d,d,d,d,Q")
539                  (match_operand:SI 1 "general_operand" "d,K,R,T,BQ")))]
540   "s390_match_ccmode (insn, CCTmode)"
541   "@
542    cr\t%0,%1
543    chi\t%0,%h1
544    c\t%0,%1
545    cy\t%0,%1
546    #"
547   [(set_attr "op_type" "RR,RI,RX,RXY,SS")])
550 ; Compare (signed) instructions
552 (define_insn "*cmpdi_ccs_sign"
553   [(set (reg 33)
554         (compare (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m"))
555                  (match_operand:DI 0 "register_operand" "d,d")))]
556   "s390_match_ccmode(insn, CCSRmode) && TARGET_64BIT"
557   "@
558    cgfr\t%0,%1
559    cgf\t%0,%1"
560   [(set_attr "op_type" "RRE,RXY")])
562 (define_insn "*cmpdi_ccs"
563   [(set (reg 33)
564         (compare (match_operand:DI 0 "register_operand" "d,d,d")
565                  (match_operand:DI 1 "general_operand" "d,K,m")))]
566   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
567   "@
568    cgr\t%0,%1
569    cghi\t%0,%h1
570    cg\t%0,%1"
571   [(set_attr "op_type" "RRE,RI,RXY")])
573 (define_insn "*cmpsi_ccs_sign"
574   [(set (reg 33)
575         (compare (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T"))
576                  (match_operand:SI 0 "register_operand" "d,d")))]
577   "s390_match_ccmode(insn, CCSRmode)"
578   "@
579    ch\t%0,%1
580    chy\t%0,%1"
581   [(set_attr "op_type" "RX,RXY")])
583 (define_insn "*cmpsi_ccs"
584   [(set (reg 33)
585         (compare (match_operand:SI 0 "register_operand" "d,d,d,d")
586                  (match_operand:SI 1 "general_operand" "d,K,R,T")))]
587   "s390_match_ccmode(insn, CCSmode)"
588   "@
589    cr\t%0,%1
590    chi\t%0,%h1
591    c\t%0,%1
592    cy\t%0,%1"
593   [(set_attr "op_type" "RR,RI,RX,RXY")])
596 ; Compare (unsigned) instructions
598 (define_insn "*cmpdi_ccu_zero"
599   [(set (reg 33)
600         (compare (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m"))
601                  (match_operand:DI 0 "register_operand" "d,d")))]
602   "s390_match_ccmode (insn, CCURmode) && TARGET_64BIT"
603   "@
604    clgfr\t%0,%1
605    clgf\t%0,%1"
606   [(set_attr "op_type" "RRE,RXY")])
608 (define_insn "*cmpdi_ccu"
609   [(set (reg 33)
610         (compare (match_operand:DI 0 "nonimmediate_operand" "d,d,Q,BQ")
611                  (match_operand:DI 1 "general_operand" "d,m,BQ,Q")))]
612   "s390_match_ccmode (insn, CCUmode) && TARGET_64BIT"
613   "@
614    clgr\t%0,%1
615    clg\t%0,%1
616    #
617    #"
618   [(set_attr "op_type" "RRE,RXY,SS,SS")])
620 (define_insn "*cmpsi_ccu"
621   [(set (reg 33)
622         (compare (match_operand:SI 0 "nonimmediate_operand" "d,d,d,Q,BQ")
623                  (match_operand:SI 1 "general_operand" "d,R,T,BQ,Q")))]
624   "s390_match_ccmode (insn, CCUmode)"
625   "@
626    clr\t%0,%1
627    cl\t%0,%1
628    cly\t%0,%1
629    #
630    #"
631   [(set_attr "op_type" "RR,RX,RXY,SS,SS")])
633 (define_insn "*cmphi_ccu"
634   [(set (reg 33)
635         (compare (match_operand:HI 0 "nonimmediate_operand" "d,d,Q,BQ")
636                  (match_operand:HI 1 "general_operand" "Q,S,BQ,Q")))]
637   "s390_match_ccmode (insn, CCUmode)
638    && !register_operand (operands[1], HImode)"
639   "@
640    clm\t%0,3,%S1
641    clmy\t%0,3,%S1
642    #
643    #"
644   [(set_attr "op_type" "RS,RSY,SS,SS")])
646 (define_insn "*cmpqi_ccu"
647   [(set (reg 33)
648         (compare (match_operand:QI 0 "nonimmediate_operand" "d,d,Q,S,Q,BQ")
649                  (match_operand:QI 1 "general_operand" "Q,S,n,n,BQ,Q")))]
650   "s390_match_ccmode (insn, CCUmode)
651    && !register_operand (operands[1], QImode)"
652   "@
653    clm\t%0,1,%S1
654    clmy\t%0,1,%S1
655    cli\t%S0,%b1
656    cliy\t%S0,%b1
657    #
658    #"
659   [(set_attr "op_type" "RS,RSY,SI,SIY,SS,SS")])
662 ; Block compare (CLC) instruction patterns.
664 (define_insn "*clc"
665   [(set (reg 33)
666         (compare (match_operand:BLK 0 "memory_operand" "Q")
667                  (match_operand:BLK 1 "memory_operand" "Q")))
668    (use (match_operand 2 "const_int_operand" "n"))]
669   "s390_match_ccmode (insn, CCUmode)
670    && INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
671   "clc\t%O0(%2,%R0),%S1"
672   [(set_attr "op_type" "SS")])
674 (define_split
675   [(set (reg 33)
676         (compare (match_operand 0 "memory_operand" "")
677                  (match_operand 1 "memory_operand" "")))]
678   "reload_completed
679    && s390_match_ccmode (insn, CCUmode)
680    && GET_MODE (operands[0]) == GET_MODE (operands[1])
681    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
682   [(parallel
683     [(set (match_dup 0) (match_dup 1))
684      (use (match_dup 2))])]
686   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
687   operands[0] = adjust_address (operands[0], BLKmode, 0);
688   operands[1] = adjust_address (operands[1], BLKmode, 0);
690   operands[1] = gen_rtx_COMPARE (GET_MODE (SET_DEST (PATTERN (curr_insn))),
691                                  operands[0], operands[1]);
692   operands[0] = SET_DEST (PATTERN (curr_insn));
696 ; (DF|SF) instructions
698 (define_insn "*cmp<mode>_ccs_0"
699   [(set (reg 33)
700         (compare (match_operand:FPR 0 "register_operand" "f")
701                  (match_operand:FPR 1 "const0_operand" "")))]
702   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
703   "lt<de>br\t%0,%0"
704    [(set_attr "op_type" "RRE")
705     (set_attr "type"  "fsimp<mode>")])
707 (define_insn "*cmp<mode>_ccs_0_ibm"
708   [(set (reg 33)
709         (compare (match_operand:FPR 0 "register_operand" "f")
710                  (match_operand:FPR 1 "const0_operand" "")))]
711   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
712   "lt<de>r\t%0,%0"
713    [(set_attr "op_type" "RR")
714     (set_attr "type"  "fsimp<mode>")])
716 (define_insn "*cmp<mode>_ccs"
717   [(set (reg 33)
718         (compare (match_operand:FPR 0 "register_operand" "f,f")
719                  (match_operand:FPR 1 "general_operand" "f,R")))]
720   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
721   "@
722    c<de>br\t%0,%1
723    c<de>b\t%0,%1"
724    [(set_attr "op_type" "RRE,RXE")
725     (set_attr "type"  "fsimp<mode>")])
727 (define_insn "*cmp<mode>_ccs_ibm"
728   [(set (reg 33)
729         (compare (match_operand:FPR 0 "register_operand" "f,f")
730                  (match_operand:FPR 1 "general_operand" "f,R")))]
731   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
732   "@
733    c<de>r\t%0,%1
734    c<de>\t%0,%1"
735    [(set_attr "op_type" "RR,RX")
736     (set_attr "type"  "fsimp<mode>")])
740 ;;- Move instructions.
744 ; movti instruction pattern(s).
747 (define_insn "movti"
748   [(set (match_operand:TI 0 "nonimmediate_operand" "=d,QS,d,o,Q")
749         (match_operand:TI 1 "general_operand" "QS,d,dKm,d,Q"))]
750   "TARGET_64BIT"
751   "@
752    lmg\t%0,%N0,%S1
753    stmg\t%1,%N1,%S0
754    #
755    #
756    #"
757   [(set_attr "op_type" "RSY,RSY,*,*,SS")
758    (set_attr "type" "lm,stm,*,*,*")])
760 (define_split
761   [(set (match_operand:TI 0 "nonimmediate_operand" "")
762         (match_operand:TI 1 "general_operand" ""))]
763   "TARGET_64BIT && reload_completed
764    && s390_split_ok_p (operands[0], operands[1], TImode, 0)"
765   [(set (match_dup 2) (match_dup 4))
766    (set (match_dup 3) (match_dup 5))]
768   operands[2] = operand_subword (operands[0], 0, 0, TImode);
769   operands[3] = operand_subword (operands[0], 1, 0, TImode);
770   operands[4] = operand_subword (operands[1], 0, 0, TImode);
771   operands[5] = operand_subword (operands[1], 1, 0, TImode);
774 (define_split
775   [(set (match_operand:TI 0 "nonimmediate_operand" "")
776         (match_operand:TI 1 "general_operand" ""))]
777   "TARGET_64BIT && reload_completed
778    && s390_split_ok_p (operands[0], operands[1], TImode, 1)"
779   [(set (match_dup 2) (match_dup 4))
780    (set (match_dup 3) (match_dup 5))]
782   operands[2] = operand_subword (operands[0], 1, 0, TImode);
783   operands[3] = operand_subword (operands[0], 0, 0, TImode);
784   operands[4] = operand_subword (operands[1], 1, 0, TImode);
785   operands[5] = operand_subword (operands[1], 0, 0, TImode);
788 (define_split
789   [(set (match_operand:TI 0 "register_operand" "")
790         (match_operand:TI 1 "memory_operand" ""))]
791   "TARGET_64BIT && reload_completed
792    && !s_operand (operands[1], VOIDmode)"
793   [(set (match_dup 0) (match_dup 1))]
795   rtx addr = operand_subword (operands[0], 1, 0, TImode);
796   s390_load_address (addr, XEXP (operands[1], 0));
797   operands[1] = replace_equiv_address (operands[1], addr);
800 (define_expand "reload_outti"
801   [(parallel [(match_operand:TI 0 "" "")
802               (match_operand:TI 1 "register_operand" "d")
803               (match_operand:DI 2 "register_operand" "=&a")])]
804   "TARGET_64BIT"
806   gcc_assert (MEM_P (operands[0]));
807   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
808   operands[0] = replace_equiv_address (operands[0], operands[2]);
809   emit_move_insn (operands[0], operands[1]);
810   DONE;
814 ; movdi instruction pattern(s).
817 (define_expand "movdi"
818   [(set (match_operand:DI 0 "general_operand" "")
819         (match_operand:DI 1 "general_operand" ""))]
820   ""
822   /* Handle symbolic constants.  */
823   if (TARGET_64BIT && SYMBOLIC_CONST (operands[1]))
824     emit_symbolic_move (operands);
827 (define_insn "*movdi_larl"
828   [(set (match_operand:DI 0 "register_operand" "=d")
829         (match_operand:DI 1 "larl_operand" "X"))]
830   "TARGET_64BIT
831    && !FP_REG_P (operands[0])"
832   "larl\t%0,%1"
833    [(set_attr "op_type" "RIL")
834     (set_attr "type"    "larl")])
836 (define_insn "*movdi_64"
837   [(set (match_operand:DI 0 "nonimmediate_operand"
838                             "=d,d,d,d,d,d,d,d,m,!*f,!*f,!*f,!R,!T,d,t,Q,t,?Q")
839         (match_operand:DI 1 "general_operand"
840                             "K,N0HD0,N1HD0,N2HD0,N3HD0,L,d,m,d,*f,R,T,*f,*f,t,d,t,Q,?Q"))]
841   "TARGET_64BIT"
842   "@
843    lghi\t%0,%h1
844    llihh\t%0,%i1
845    llihl\t%0,%i1
846    llilh\t%0,%i1
847    llill\t%0,%i1
848    lay\t%0,%a1
849    lgr\t%0,%1
850    lg\t%0,%1
851    stg\t%1,%0
852    ldr\t%0,%1
853    ld\t%0,%1
854    ldy\t%0,%1
855    std\t%1,%0
856    stdy\t%1,%0
857    #
858    #
859    stam\t%1,%N1,%S0
860    lam\t%0,%N0,%S1
861    #"
862   [(set_attr "op_type" "RI,RI,RI,RI,RI,RXY,RRE,RXY,RXY,
863                         RR,RX,RXY,RX,RXY,*,*,RS,RS,SS")
864    (set_attr "type" "*,*,*,*,*,la,lr,load,store,
865                      floaddf,floaddf,floaddf,fstoredf,fstoredf,*,*,*,*,*")])
867 (define_split
868   [(set (match_operand:DI 0 "register_operand" "")
869         (match_operand:DI 1 "register_operand" ""))]
870   "TARGET_64BIT && ACCESS_REG_P (operands[1])"
871   [(set (match_dup 2) (match_dup 3))
872    (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 32)))
873    (set (strict_low_part (match_dup 2)) (match_dup 4))]
874   "operands[2] = gen_lowpart (SImode, operands[0]);
875    s390_split_access_reg (operands[1], &operands[4], &operands[3]);")
877 (define_split
878   [(set (match_operand:DI 0 "register_operand" "")
879         (match_operand:DI 1 "register_operand" ""))]
880   "TARGET_64BIT && ACCESS_REG_P (operands[0])
881    && dead_or_set_p (insn, operands[1])"
882   [(set (match_dup 3) (match_dup 2))
883    (set (match_dup 1) (lshiftrt:DI (match_dup 1) (const_int 32)))
884    (set (match_dup 4) (match_dup 2))]
885   "operands[2] = gen_lowpart (SImode, operands[1]);
886    s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
888 (define_split
889   [(set (match_operand:DI 0 "register_operand" "")
890         (match_operand:DI 1 "register_operand" ""))]
891   "TARGET_64BIT && ACCESS_REG_P (operands[0])
892    && !dead_or_set_p (insn, operands[1])"
893   [(set (match_dup 3) (match_dup 2))
894    (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))
895    (set (match_dup 4) (match_dup 2))
896    (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))]
897   "operands[2] = gen_lowpart (SImode, operands[1]);
898    s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
900 (define_insn "*movdi_31"
901   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,Q,d,o,!*f,!*f,!*f,!R,!T,Q")
902         (match_operand:DI 1 "general_operand" "Q,d,dKm,d,*f,R,T,*f,*f,Q"))]
903   "!TARGET_64BIT"
904   "@
905    lm\t%0,%N0,%S1
906    stm\t%1,%N1,%S0
907    #
908    #
909    ldr\t%0,%1
910    ld\t%0,%1
911    ldy\t%0,%1
912    std\t%1,%0
913    stdy\t%1,%0
914    #"
915   [(set_attr "op_type" "RS,RS,*,*,RR,RX,RXY,RX,RXY,SS")
916    (set_attr "type" "lm,stm,*,*,floaddf,floaddf,floaddf,fstoredf,fstoredf,*")])
918 (define_split
919   [(set (match_operand:DI 0 "nonimmediate_operand" "")
920         (match_operand:DI 1 "general_operand" ""))]
921   "!TARGET_64BIT && reload_completed
922    && s390_split_ok_p (operands[0], operands[1], DImode, 0)"
923   [(set (match_dup 2) (match_dup 4))
924    (set (match_dup 3) (match_dup 5))]
926   operands[2] = operand_subword (operands[0], 0, 0, DImode);
927   operands[3] = operand_subword (operands[0], 1, 0, DImode);
928   operands[4] = operand_subword (operands[1], 0, 0, DImode);
929   operands[5] = operand_subword (operands[1], 1, 0, DImode);
932 (define_split
933   [(set (match_operand:DI 0 "nonimmediate_operand" "")
934         (match_operand:DI 1 "general_operand" ""))]
935   "!TARGET_64BIT && reload_completed
936    && s390_split_ok_p (operands[0], operands[1], DImode, 1)"
937   [(set (match_dup 2) (match_dup 4))
938    (set (match_dup 3) (match_dup 5))]
940   operands[2] = operand_subword (operands[0], 1, 0, DImode);
941   operands[3] = operand_subword (operands[0], 0, 0, DImode);
942   operands[4] = operand_subword (operands[1], 1, 0, DImode);
943   operands[5] = operand_subword (operands[1], 0, 0, DImode);
946 (define_split
947   [(set (match_operand:DI 0 "register_operand" "")
948         (match_operand:DI 1 "memory_operand" ""))]
949   "!TARGET_64BIT && reload_completed
950    && !FP_REG_P (operands[0])
951    && !s_operand (operands[1], VOIDmode)"
952   [(set (match_dup 0) (match_dup 1))]
954   rtx addr = operand_subword (operands[0], 1, 0, DImode);
955   s390_load_address (addr, XEXP (operands[1], 0));
956   operands[1] = replace_equiv_address (operands[1], addr);
959 (define_expand "reload_outdi"
960   [(parallel [(match_operand:DI 0 "" "")
961               (match_operand:DI 1 "register_operand" "d")
962               (match_operand:SI 2 "register_operand" "=&a")])]
963   "!TARGET_64BIT"
965   gcc_assert (MEM_P (operands[0]));
966   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
967   operands[0] = replace_equiv_address (operands[0], operands[2]);
968   emit_move_insn (operands[0], operands[1]);
969   DONE;
972 (define_peephole2
973   [(set (match_operand:DI 0 "register_operand" "")
974         (mem:DI (match_operand 1 "address_operand" "")))]
975   "TARGET_64BIT
976    && !FP_REG_P (operands[0])
977    && GET_CODE (operands[1]) == SYMBOL_REF
978    && CONSTANT_POOL_ADDRESS_P (operands[1])
979    && get_pool_mode (operands[1]) == DImode
980    && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
981   [(set (match_dup 0) (match_dup 2))]
982   "operands[2] = get_pool_constant (operands[1]);")
984 (define_insn "*la_64"
985   [(set (match_operand:DI 0 "register_operand" "=d,d")
986         (match_operand:QI 1 "address_operand" "U,W"))]
987   "TARGET_64BIT"
988   "@
989    la\t%0,%a1
990    lay\t%0,%a1"
991   [(set_attr "op_type" "RX,RXY")
992    (set_attr "type"    "la")])
994 (define_peephole2
995   [(parallel
996     [(set (match_operand:DI 0 "register_operand" "")
997           (match_operand:QI 1 "address_operand" ""))
998      (clobber (reg:CC 33))])]
999   "TARGET_64BIT
1000    && preferred_la_operand_p (operands[1], const0_rtx)"
1001   [(set (match_dup 0) (match_dup 1))]
1002   "")
1004 (define_peephole2
1005   [(set (match_operand:DI 0 "register_operand" "")
1006         (match_operand:DI 1 "register_operand" ""))
1007    (parallel
1008     [(set (match_dup 0)
1009           (plus:DI (match_dup 0)
1010                    (match_operand:DI 2 "nonmemory_operand" "")))
1011      (clobber (reg:CC 33))])]
1012   "TARGET_64BIT
1013    && !reg_overlap_mentioned_p (operands[0], operands[2])
1014    && preferred_la_operand_p (operands[1], operands[2])"
1015   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))]
1016   "")
1018 (define_expand "reload_indi"
1019   [(parallel [(match_operand:DI 0 "register_operand" "=a")
1020               (match_operand:DI 1 "s390_plus_operand" "")
1021               (match_operand:DI 2 "register_operand" "=&a")])]
1022   "TARGET_64BIT"
1024   s390_expand_plus_operand (operands[0], operands[1], operands[2]);
1025   DONE;
1029 ; movsi instruction pattern(s).
1032 (define_expand "movsi"
1033   [(set (match_operand:SI 0 "general_operand" "")
1034         (match_operand:SI 1 "general_operand" ""))]
1035   ""
1037   /* Handle symbolic constants.  */
1038   if (!TARGET_64BIT && SYMBOLIC_CONST (operands[1]))
1039     emit_symbolic_move (operands);
1042 (define_insn "*movsi_larl"
1043   [(set (match_operand:SI 0 "register_operand" "=d")
1044         (match_operand:SI 1 "larl_operand" "X"))]
1045   "!TARGET_64BIT && TARGET_CPU_ZARCH
1046    && !FP_REG_P (operands[0])"
1047   "larl\t%0,%1"
1048    [(set_attr "op_type" "RIL")
1049     (set_attr "type"    "larl")])
1051 (define_insn "*movsi_zarch"
1052   [(set (match_operand:SI 0 "nonimmediate_operand"
1053                             "=d,d,d,d,d,d,d,R,T,!*f,!*f,!*f,!R,!T,d,t,Q,t,?Q")
1054         (match_operand:SI 1 "general_operand"
1055                             "K,N0HS0,N1HS0,L,d,R,T,d,d,*f,R,T,*f,*f,t,d,t,Q,?Q"))]
1056   "TARGET_ZARCH"
1057   "@
1058    lhi\t%0,%h1
1059    llilh\t%0,%i1
1060    llill\t%0,%i1
1061    lay\t%0,%a1
1062    lr\t%0,%1
1063    l\t%0,%1
1064    ly\t%0,%1
1065    st\t%1,%0
1066    sty\t%1,%0
1067    ler\t%0,%1
1068    le\t%0,%1
1069    ley\t%0,%1
1070    ste\t%1,%0
1071    stey\t%1,%0
1072    ear\t%0,%1
1073    sar\t%0,%1
1074    stam\t%1,%1,%S0
1075    lam\t%0,%0,%S1
1076    #"
1077   [(set_attr "op_type" "RI,RI,RI,RXY,RR,RX,RXY,RX,RXY,
1078                         RR,RX,RXY,RX,RXY,RRE,RRE,RS,RS,SS")
1079    (set_attr "type" "*,*,*,la,lr,load,load,store,store,
1080                      floadsf,floadsf,floadsf,fstoresf,fstoresf,*,*,*,*,*")])
1082 (define_insn "*movsi_esa"
1083   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,R,!*f,!*f,!R,d,t,Q,t,?Q")
1084         (match_operand:SI 1 "general_operand" "K,d,R,d,*f,R,*f,t,d,t,Q,?Q"))]
1085   "!TARGET_ZARCH"
1086   "@
1087    lhi\t%0,%h1
1088    lr\t%0,%1
1089    l\t%0,%1
1090    st\t%1,%0
1091    ler\t%0,%1
1092    le\t%0,%1
1093    ste\t%1,%0
1094    ear\t%0,%1
1095    sar\t%0,%1
1096    stam\t%1,%1,%S0
1097    lam\t%0,%0,%S1
1098    #"
1099   [(set_attr "op_type" "RI,RR,RX,RX,RR,RX,RX,RRE,RRE,RS,RS,SS")
1100    (set_attr "type" "*,lr,load,store,floadsf,floadsf,fstoresf,*,*,*,*,*")])
1102 (define_peephole2
1103   [(set (match_operand:SI 0 "register_operand" "")
1104         (mem:SI (match_operand 1 "address_operand" "")))]
1105   "!FP_REG_P (operands[0])
1106    && GET_CODE (operands[1]) == SYMBOL_REF
1107    && CONSTANT_POOL_ADDRESS_P (operands[1])
1108    && get_pool_mode (operands[1]) == SImode
1109    && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
1110   [(set (match_dup 0) (match_dup 2))]
1111   "operands[2] = get_pool_constant (operands[1]);")
1113 (define_insn "*la_31"
1114   [(set (match_operand:SI 0 "register_operand" "=d,d")
1115         (match_operand:QI 1 "address_operand" "U,W"))]
1116   "!TARGET_64BIT && legitimate_la_operand_p (operands[1])"
1117   "@
1118    la\t%0,%a1
1119    lay\t%0,%a1"
1120   [(set_attr "op_type"  "RX,RXY")
1121    (set_attr "type"     "la")])
1123 (define_peephole2
1124   [(parallel
1125     [(set (match_operand:SI 0 "register_operand" "")
1126           (match_operand:QI 1 "address_operand" ""))
1127      (clobber (reg:CC 33))])]
1128   "!TARGET_64BIT
1129    && preferred_la_operand_p (operands[1], const0_rtx)"
1130   [(set (match_dup 0) (match_dup 1))]
1131   "")
1133 (define_peephole2
1134   [(set (match_operand:SI 0 "register_operand" "")
1135         (match_operand:SI 1 "register_operand" ""))
1136    (parallel
1137     [(set (match_dup 0)
1138           (plus:SI (match_dup 0)
1139                    (match_operand:SI 2 "nonmemory_operand" "")))
1140      (clobber (reg:CC 33))])]
1141   "!TARGET_64BIT
1142    && !reg_overlap_mentioned_p (operands[0], operands[2])
1143    && preferred_la_operand_p (operands[1], operands[2])"
1144   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))]
1145   "")
1147 (define_insn "*la_31_and"
1148   [(set (match_operand:SI 0 "register_operand" "=d,d")
1149         (and:SI (match_operand:QI 1 "address_operand" "U,W")
1150                 (const_int 2147483647)))]
1151   "!TARGET_64BIT"
1152   "@
1153    la\t%0,%a1
1154    lay\t%0,%a1"
1155   [(set_attr "op_type"  "RX,RXY")
1156    (set_attr "type"     "la")])
1158 (define_insn_and_split "*la_31_and_cc"
1159   [(set (match_operand:SI 0 "register_operand" "=d")
1160         (and:SI (match_operand:QI 1 "address_operand" "p")
1161                 (const_int 2147483647)))
1162    (clobber (reg:CC 33))]
1163   "!TARGET_64BIT"
1164   "#"
1165   "&& reload_completed"
1166   [(set (match_dup 0)
1167         (and:SI (match_dup 1) (const_int 2147483647)))]
1168   ""
1169   [(set_attr "op_type"  "RX")
1170    (set_attr "type"     "la")])
1172 (define_insn "force_la_31"
1173   [(set (match_operand:SI 0 "register_operand" "=d,d")
1174         (match_operand:QI 1 "address_operand" "U,W"))
1175    (use (const_int 0))]
1176   "!TARGET_64BIT"
1177   "@
1178    la\t%0,%a1
1179    lay\t%0,%a1"
1180   [(set_attr "op_type"  "RX")
1181    (set_attr "type"     "la")])
1183 (define_expand "reload_insi"
1184   [(parallel [(match_operand:SI 0 "register_operand" "=a")
1185               (match_operand:SI 1 "s390_plus_operand" "")
1186               (match_operand:SI 2 "register_operand" "=&a")])]
1187   "!TARGET_64BIT"
1189   s390_expand_plus_operand (operands[0], operands[1], operands[2]);
1190   DONE;
1194 ; movhi instruction pattern(s).
1197 (define_expand "movhi"
1198   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1199         (match_operand:HI 1 "general_operand" ""))]
1200   ""
1202   /* Make it explicit that loading a register from memory
1203      always sign-extends (at least) to SImode.  */
1204   if (optimize && !no_new_pseudos
1205       && register_operand (operands[0], VOIDmode)
1206       && GET_CODE (operands[1]) == MEM)
1207     {
1208       rtx tmp = gen_reg_rtx (SImode);
1209       rtx ext = gen_rtx_SIGN_EXTEND (SImode, operands[1]);
1210       emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1211       operands[1] = gen_lowpart (HImode, tmp);
1212     }
1215 (define_insn "*movhi"
1216   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d,d,R,T,?Q")
1217         (match_operand:HI 1 "general_operand" "d,n,R,T,d,d,?Q"))]
1218   ""
1219   "@
1220    lr\t%0,%1
1221    lhi\t%0,%h1
1222    lh\t%0,%1
1223    lhy\t%0,%1
1224    sth\t%1,%0
1225    sthy\t%1,%0
1226    #"
1227   [(set_attr "op_type" "RR,RI,RX,RXY,RX,RXY,SS")
1228    (set_attr "type" "lr,*,*,*,store,store,*")])
1230 (define_peephole2
1231   [(set (match_operand:HI 0 "register_operand" "")
1232         (mem:HI (match_operand 1 "address_operand" "")))]
1233   "GET_CODE (operands[1]) == SYMBOL_REF
1234    && CONSTANT_POOL_ADDRESS_P (operands[1])
1235    && get_pool_mode (operands[1]) == HImode
1236    && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1237   [(set (match_dup 0) (match_dup 2))]
1238   "operands[2] = get_pool_constant (operands[1]);")
1241 ; movqi instruction pattern(s).
1244 (define_expand "movqi"
1245   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1246         (match_operand:QI 1 "general_operand" ""))]
1247   ""
1249   /* On z/Architecture, zero-extending from memory to register
1250      is just as fast as a QImode load.  */
1251   if (TARGET_ZARCH && optimize && !no_new_pseudos
1252       && register_operand (operands[0], VOIDmode)
1253       && GET_CODE (operands[1]) == MEM)
1254     {
1255       rtx tmp = gen_reg_rtx (word_mode);
1256       rtx ext = gen_rtx_ZERO_EXTEND (word_mode, operands[1]);
1257       emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1258       operands[1] = gen_lowpart (QImode, tmp);
1259     }
1262 (define_insn "*movqi"
1263   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,d,R,T,Q,S,?Q")
1264         (match_operand:QI 1 "general_operand" "d,n,R,T,d,d,n,n,?Q"))]
1265   ""
1266   "@
1267    lr\t%0,%1
1268    lhi\t%0,%b1
1269    ic\t%0,%1
1270    icy\t%0,%1
1271    stc\t%1,%0
1272    stcy\t%1,%0
1273    mvi\t%S0,%b1
1274    mviy\t%S0,%b1
1275    #"
1276   [(set_attr "op_type" "RR,RI,RX,RXY,RX,RXY,SI,SIY,SS")
1277    (set_attr "type" "lr,*,*,*,store,store,store,store,*")])
1279 (define_peephole2
1280   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1281         (mem:QI (match_operand 1 "address_operand" "")))]
1282   "GET_CODE (operands[1]) == SYMBOL_REF
1283    && CONSTANT_POOL_ADDRESS_P (operands[1])
1284    && get_pool_mode (operands[1]) == QImode
1285    && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1286   [(set (match_dup 0) (match_dup 2))]
1287   "operands[2] = get_pool_constant (operands[1]);")
1290 ; movstrictqi instruction pattern(s).
1293 (define_insn "*movstrictqi"
1294   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d,d"))
1295                          (match_operand:QI 1 "memory_operand" "R,T"))]
1296   ""
1297   "@
1298    ic\t%0,%1
1299    icy\t%0,%1"
1300   [(set_attr "op_type"  "RX,RXY")])
1303 ; movstricthi instruction pattern(s).
1306 (define_insn "*movstricthi"
1307   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d,d"))
1308                          (match_operand:HI 1 "memory_operand" "Q,S"))
1309    (clobber (reg:CC 33))]
1310   ""
1311   "@
1312    icm\t%0,3,%S1
1313    icmy\t%0,3,%S1"
1314   [(set_attr "op_type" "RS,RSY")])
1317 ; movstrictsi instruction pattern(s).
1320 (define_insn "movstrictsi"
1321   [(set (strict_low_part (match_operand:SI 0 "register_operand" "+d,d,d,d"))
1322                          (match_operand:SI 1 "general_operand" "d,R,T,t"))]
1323   "TARGET_64BIT"
1324   "@
1325    lr\t%0,%1
1326    l\t%0,%1
1327    ly\t%0,%1
1328    ear\t%0,%1"
1329   [(set_attr "op_type" "RR,RX,RXY,RRE")
1330    (set_attr "type" "lr,load,load,*")])
1333 ; movdf instruction pattern(s).
1336 (define_expand "movdf"
1337   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1338         (match_operand:DF 1 "general_operand"  ""))]
1339   ""
1340   "")
1342 (define_insn "*movdf_64"
1343   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,R,T,d,d,m,?Q")
1344         (match_operand:DF 1 "general_operand" "f,R,T,f,f,d,m,d,?Q"))]
1345   "TARGET_64BIT"
1346   "@
1347    ldr\t%0,%1
1348    ld\t%0,%1
1349    ldy\t%0,%1
1350    std\t%1,%0
1351    stdy\t%1,%0
1352    lgr\t%0,%1
1353    lg\t%0,%1
1354    stg\t%1,%0
1355    #"
1356   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RRE,RXY,RXY,SS")
1357    (set_attr "type" "floaddf,floaddf,floaddf,fstoredf,fstoredf,lr,load,store,*")])
1359 (define_insn "*movdf_31"
1360   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,R,T,d,Q,d,o,Q")
1361         (match_operand:DF 1 "general_operand" "f,R,T,f,f,Q,d,dKm,d,Q"))]
1362   "!TARGET_64BIT"
1363   "@
1364    ldr\t%0,%1
1365    ld\t%0,%1
1366    ldy\t%0,%1
1367    std\t%1,%0
1368    stdy\t%1,%0
1369    lm\t%0,%N0,%S1
1370    stm\t%1,%N1,%S0
1371    #
1372    #
1373    #"
1374   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RS,RS,*,*,SS")
1375    (set_attr "type" "floaddf,floaddf,floaddf,fstoredf,fstoredf,lm,stm,*,*,*")])
1377 (define_split
1378   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1379         (match_operand:DF 1 "general_operand" ""))]
1380   "!TARGET_64BIT && reload_completed
1381    && s390_split_ok_p (operands[0], operands[1], DFmode, 0)"
1382   [(set (match_dup 2) (match_dup 4))
1383    (set (match_dup 3) (match_dup 5))]
1385   operands[2] = operand_subword (operands[0], 0, 0, DFmode);
1386   operands[3] = operand_subword (operands[0], 1, 0, DFmode);
1387   operands[4] = operand_subword (operands[1], 0, 0, DFmode);
1388   operands[5] = operand_subword (operands[1], 1, 0, DFmode);
1391 (define_split
1392   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1393         (match_operand:DF 1 "general_operand" ""))]
1394   "!TARGET_64BIT && reload_completed
1395    && s390_split_ok_p (operands[0], operands[1], DFmode, 1)"
1396   [(set (match_dup 2) (match_dup 4))
1397    (set (match_dup 3) (match_dup 5))]
1399   operands[2] = operand_subword (operands[0], 1, 0, DFmode);
1400   operands[3] = operand_subword (operands[0], 0, 0, DFmode);
1401   operands[4] = operand_subword (operands[1], 1, 0, DFmode);
1402   operands[5] = operand_subword (operands[1], 0, 0, DFmode);
1405 (define_split
1406   [(set (match_operand:DF 0 "register_operand" "")
1407         (match_operand:DF 1 "memory_operand" ""))]
1408   "!TARGET_64BIT && reload_completed
1409    && !FP_REG_P (operands[0])
1410    && !s_operand (operands[1], VOIDmode)"
1411   [(set (match_dup 0) (match_dup 1))]
1413   rtx addr = operand_subword (operands[0], 1, 0, DFmode);
1414   s390_load_address (addr, XEXP (operands[1], 0));
1415   operands[1] = replace_equiv_address (operands[1], addr);
1418 (define_expand "reload_outdf"
1419   [(parallel [(match_operand:DF 0 "" "")
1420               (match_operand:DF 1 "register_operand" "d")
1421               (match_operand:SI 2 "register_operand" "=&a")])]
1422   "!TARGET_64BIT"
1424   gcc_assert (MEM_P (operands[0]));
1425   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
1426   operands[0] = replace_equiv_address (operands[0], operands[2]);
1427   emit_move_insn (operands[0], operands[1]);
1428   DONE;
1432 ; movsf instruction pattern(s).
1435 (define_insn "movsf"
1436   [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f,R,T,d,d,d,R,T,?Q")
1437         (match_operand:SF 1 "general_operand" "f,R,T,f,f,d,R,T,d,d,?Q"))]
1438   ""
1439   "@
1440    ler\t%0,%1
1441    le\t%0,%1
1442    ley\t%0,%1
1443    ste\t%1,%0
1444    stey\t%1,%0
1445    lr\t%0,%1
1446    l\t%0,%1
1447    ly\t%0,%1
1448    st\t%1,%0
1449    sty\t%1,%0
1450    #"
1451   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RR,RX,RXY,RX,RXY,SS")
1452    (set_attr "type" "floadsf,floadsf,floadsf,fstoresf,fstoresf,
1453                      lr,load,load,store,store,*")])
1456 ; movcc instruction pattern
1459 (define_insn "movcc"
1460   [(set (match_operand:CC 0 "nonimmediate_operand" "=d,c,d,d,d,R,T")
1461         (match_operand:CC 1 "nonimmediate_operand" "d,d,c,R,T,d,d"))]
1462   ""
1463   "@
1464    lr\t%0,%1
1465    tmh\t%1,12288
1466    ipm\t%0
1467    st\t%0,%1
1468    sty\t%0,%1
1469    l\t%1,%0
1470    ly\t%1,%0"
1471   [(set_attr "op_type" "RR,RI,RRE,RX,RXY,RX,RXY")
1472    (set_attr "type" "lr,*,*,store,store,load,load")])
1475 ; Block move (MVC) patterns.
1478 (define_insn "*mvc"
1479   [(set (match_operand:BLK 0 "memory_operand" "=Q")
1480         (match_operand:BLK 1 "memory_operand" "Q"))
1481    (use (match_operand 2 "const_int_operand" "n"))]
1482   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
1483   "mvc\t%O0(%2,%R0),%S1"
1484   [(set_attr "op_type" "SS")])
1486 (define_split
1487   [(set (match_operand 0 "memory_operand" "")
1488         (match_operand 1 "memory_operand" ""))]
1489   "reload_completed
1490    && GET_MODE (operands[0]) == GET_MODE (operands[1])
1491    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
1492   [(parallel
1493     [(set (match_dup 0) (match_dup 1))
1494      (use (match_dup 2))])]
1496   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
1497   operands[0] = adjust_address (operands[0], BLKmode, 0);
1498   operands[1] = adjust_address (operands[1], BLKmode, 0);
1501 (define_peephole2
1502   [(parallel
1503     [(set (match_operand:BLK 0 "memory_operand" "")
1504           (match_operand:BLK 1 "memory_operand" ""))
1505      (use (match_operand 2 "const_int_operand" ""))])
1506    (parallel
1507     [(set (match_operand:BLK 3 "memory_operand" "")
1508           (match_operand:BLK 4 "memory_operand" ""))
1509      (use (match_operand 5 "const_int_operand" ""))])]
1510   "s390_offset_p (operands[0], operands[3], operands[2])
1511    && s390_offset_p (operands[1], operands[4], operands[2])
1512    && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
1513   [(parallel
1514     [(set (match_dup 6) (match_dup 7))
1515      (use (match_dup 8))])]
1516   "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
1517    operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
1518    operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
1522 ; load_multiple pattern(s).
1524 ; ??? Due to reload problems with replacing registers inside match_parallel
1525 ; we currently support load_multiple/store_multiple only after reload.
1528 (define_expand "load_multiple"
1529   [(match_par_dup 3 [(set (match_operand 0 "" "")
1530                           (match_operand 1 "" ""))
1531                      (use (match_operand 2 "" ""))])]
1532   "reload_completed"
1534   enum machine_mode mode;
1535   int regno;
1536   int count;
1537   rtx from;
1538   int i, off;
1540   /* Support only loading a constant number of fixed-point registers from
1541      memory and only bother with this if more than two */
1542   if (GET_CODE (operands[2]) != CONST_INT
1543       || INTVAL (operands[2]) < 2
1544       || INTVAL (operands[2]) > 16
1545       || GET_CODE (operands[1]) != MEM
1546       || GET_CODE (operands[0]) != REG
1547       || REGNO (operands[0]) >= 16)
1548     FAIL;
1550   count = INTVAL (operands[2]);
1551   regno = REGNO (operands[0]);
1552   mode = GET_MODE (operands[0]);
1553   if (mode != SImode && mode != word_mode)
1554     FAIL;
1556   operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
1557   if (no_new_pseudos)
1558     {
1559       if (GET_CODE (XEXP (operands[1], 0)) == REG)
1560         {
1561           from = XEXP (operands[1], 0);
1562           off = 0;
1563         }
1564       else if (GET_CODE (XEXP (operands[1], 0)) == PLUS
1565                && GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == REG
1566                && GET_CODE (XEXP (XEXP (operands[1], 0), 1)) == CONST_INT)
1567         {
1568           from = XEXP (XEXP (operands[1], 0), 0);
1569           off = INTVAL (XEXP (XEXP (operands[1], 0), 1));
1570         }
1571       else
1572         FAIL;
1573     }
1574   else
1575     {
1576       from = force_reg (Pmode, XEXP (operands[1], 0));
1577       off = 0;
1578     }
1580   for (i = 0; i < count; i++)
1581     XVECEXP (operands[3], 0, i)
1582       = gen_rtx_SET (VOIDmode, gen_rtx_REG (mode, regno + i),
1583                      change_address (operands[1], mode,
1584                        plus_constant (from, off + i * GET_MODE_SIZE (mode))));
1587 (define_insn "*load_multiple_di"
1588   [(match_parallel 0 "load_multiple_operation"
1589                    [(set (match_operand:DI 1 "register_operand" "=r")
1590                          (match_operand:DI 2 "s_operand" "QS"))])]
1591   "reload_completed && word_mode == DImode"
1593   int words = XVECLEN (operands[0], 0);
1594   operands[0] = gen_rtx_REG (DImode, REGNO (operands[1]) + words - 1);
1595   return "lmg\t%1,%0,%S2";
1597    [(set_attr "op_type" "RSY")
1598     (set_attr "type"    "lm")])
1600 (define_insn "*load_multiple_si"
1601   [(match_parallel 0 "load_multiple_operation"
1602                    [(set (match_operand:SI 1 "register_operand" "=r,r")
1603                          (match_operand:SI 2 "s_operand" "Q,S"))])]
1604   "reload_completed"
1606   int words = XVECLEN (operands[0], 0);
1607   operands[0] = gen_rtx_REG (SImode, REGNO (operands[1]) + words - 1);
1608   return which_alternative == 0 ? "lm\t%1,%0,%S2" : "lmy\t%1,%0,%S2";
1610    [(set_attr "op_type" "RS,RSY")
1611     (set_attr "type"    "lm")])
1614 ; store multiple pattern(s).
1617 (define_expand "store_multiple"
1618   [(match_par_dup 3 [(set (match_operand 0 "" "")
1619                           (match_operand 1 "" ""))
1620                      (use (match_operand 2 "" ""))])]
1621   "reload_completed"
1623   enum machine_mode mode;
1624   int regno;
1625   int count;
1626   rtx to;
1627   int i, off;
1629   /* Support only storing a constant number of fixed-point registers to
1630      memory and only bother with this if more than two.  */
1631   if (GET_CODE (operands[2]) != CONST_INT
1632       || INTVAL (operands[2]) < 2
1633       || INTVAL (operands[2]) > 16
1634       || GET_CODE (operands[0]) != MEM
1635       || GET_CODE (operands[1]) != REG
1636       || REGNO (operands[1]) >= 16)
1637     FAIL;
1639   count = INTVAL (operands[2]);
1640   regno = REGNO (operands[1]);
1641   mode = GET_MODE (operands[1]);
1642   if (mode != SImode && mode != word_mode)
1643     FAIL;
1645   operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
1647   if (no_new_pseudos)
1648     {
1649       if (GET_CODE (XEXP (operands[0], 0)) == REG)
1650         {
1651           to = XEXP (operands[0], 0);
1652           off = 0;
1653         }
1654       else if (GET_CODE (XEXP (operands[0], 0)) == PLUS
1655                && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
1656                && GET_CODE (XEXP (XEXP (operands[0], 0), 1)) == CONST_INT)
1657         {
1658           to = XEXP (XEXP (operands[0], 0), 0);
1659           off = INTVAL (XEXP (XEXP (operands[0], 0), 1));
1660         }
1661       else
1662         FAIL;
1663     }
1664   else
1665     {
1666       to = force_reg (Pmode, XEXP (operands[0], 0));
1667       off = 0;
1668     }
1670   for (i = 0; i < count; i++)
1671     XVECEXP (operands[3], 0, i)
1672       = gen_rtx_SET (VOIDmode,
1673                      change_address (operands[0], mode,
1674                        plus_constant (to, off + i * GET_MODE_SIZE (mode))),
1675                      gen_rtx_REG (mode, regno + i));
1678 (define_insn "*store_multiple_di"
1679   [(match_parallel 0 "store_multiple_operation"
1680                    [(set (match_operand:DI 1 "s_operand" "=QS")
1681                          (match_operand:DI 2 "register_operand" "r"))])]
1682   "reload_completed && word_mode == DImode"
1684   int words = XVECLEN (operands[0], 0);
1685   operands[0] = gen_rtx_REG (DImode, REGNO (operands[2]) + words - 1);
1686   return "stmg\t%2,%0,%S1";
1688    [(set_attr "op_type" "RSY")
1689     (set_attr "type"    "stm")])
1692 (define_insn "*store_multiple_si"
1693   [(match_parallel 0 "store_multiple_operation"
1694                    [(set (match_operand:SI 1 "s_operand" "=Q,S")
1695                          (match_operand:SI 2 "register_operand" "r,r"))])]
1696   "reload_completed"
1698   int words = XVECLEN (operands[0], 0);
1699   operands[0] = gen_rtx_REG (SImode, REGNO (operands[2]) + words - 1);
1700   return which_alternative == 0 ? "stm\t%2,%0,%S1" : "stmy\t%2,%0,%S1";
1702    [(set_attr "op_type" "RS,RSY")
1703     (set_attr "type"    "stm")])
1706 ;; String instructions.
1709 (define_insn "*execute"
1710   [(match_parallel 0 ""
1711     [(unspec [(match_operand 1 "register_operand" "a")
1712               (match_operand:BLK 2 "memory_operand" "R")
1713               (match_operand 3 "" "")] UNSPEC_EXECUTE)])]
1714   "GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
1715    && GET_MODE_SIZE (GET_MODE (operands[1])) <= UNITS_PER_WORD"
1716   "ex\t%1,%2"
1717   [(set_attr "op_type" "RX")
1718    (set_attr "type" "cs")])
1722 ; strlenM instruction pattern(s).
1725 (define_expand "strlen<mode>"
1726   [(set (reg:QI 0) (match_operand:QI 2 "immediate_operand" ""))
1727    (parallel
1728     [(set (match_dup 4)
1729           (unspec:P [(const_int 0)
1730                       (match_operand:BLK 1 "memory_operand" "")
1731                       (reg:QI 0)
1732                       (match_operand 3 "immediate_operand" "")] UNSPEC_SRST))
1733      (clobber (scratch:P))
1734      (clobber (reg:CC 33))])
1735    (parallel
1736     [(set (match_operand:P 0 "register_operand" "")
1737           (minus:P (match_dup 4) (match_dup 5)))
1738      (clobber (reg:CC 33))])]
1739   ""
1741   operands[4] = gen_reg_rtx (Pmode);
1742   operands[5] = gen_reg_rtx (Pmode);
1743   emit_move_insn (operands[5], force_operand (XEXP (operands[1], 0), NULL_RTX));
1744   operands[1] = replace_equiv_address (operands[1], operands[5]);
1747 (define_insn "*strlen<mode>"
1748   [(set (match_operand:P 0 "register_operand" "=a")
1749         (unspec:P [(match_operand:P 2 "general_operand" "0")
1750                     (mem:BLK (match_operand:P 3 "register_operand" "1"))
1751                     (reg:QI 0)
1752                     (match_operand 4 "immediate_operand" "")] UNSPEC_SRST))
1753    (clobber (match_scratch:P 1 "=a"))
1754    (clobber (reg:CC 33))]
1755   ""
1756   "srst\t%0,%1\;jo\t.-4"
1757   [(set_attr "length" "8")
1758    (set_attr "type" "vs")])
1761 ; movmemM instruction pattern(s).
1764 (define_expand "movmem<mode>"
1765   [(set (match_operand:BLK 0 "memory_operand" "")
1766         (match_operand:BLK 1 "memory_operand" ""))
1767    (use (match_operand:GPR 2 "general_operand" ""))
1768    (match_operand 3 "" "")]
1769   ""
1770   "s390_expand_movmem (operands[0], operands[1], operands[2]); DONE;")
1772 ; Move a block that is up to 256 bytes in length.
1773 ; The block length is taken as (operands[2] % 256) + 1.
1775 (define_expand "movmem_short"
1776   [(parallel
1777     [(set (match_operand:BLK 0 "memory_operand" "")
1778           (match_operand:BLK 1 "memory_operand" ""))
1779      (use (match_operand 2 "nonmemory_operand" ""))
1780      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1781      (clobber (match_dup 3))])]
1782   ""
1783   "operands[3] = gen_rtx_SCRATCH (Pmode);")
1785 (define_insn "*movmem_short"
1786   [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q")
1787         (match_operand:BLK 1 "memory_operand" "Q,Q,Q"))
1788    (use (match_operand 2 "nonmemory_operand" "n,a,a"))
1789    (use (match_operand 3 "immediate_operand" "X,R,X"))
1790    (clobber (match_scratch 4 "=X,X,&a"))]
1791   "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)
1792    && GET_MODE (operands[4]) == Pmode"
1793   "#"
1794   [(set_attr "type" "cs")])
1796 (define_split
1797   [(set (match_operand:BLK 0 "memory_operand" "")
1798         (match_operand:BLK 1 "memory_operand" ""))
1799    (use (match_operand 2 "const_int_operand" ""))
1800    (use (match_operand 3 "immediate_operand" ""))
1801    (clobber (scratch))]
1802   "reload_completed"
1803   [(parallel
1804     [(set (match_dup 0) (match_dup 1))
1805      (use (match_dup 2))])]
1806   "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
1808 (define_split
1809   [(set (match_operand:BLK 0 "memory_operand" "")
1810         (match_operand:BLK 1 "memory_operand" ""))
1811    (use (match_operand 2 "register_operand" ""))
1812    (use (match_operand 3 "memory_operand" ""))
1813    (clobber (scratch))]
1814   "reload_completed"
1815   [(parallel
1816     [(unspec [(match_dup 2) (match_dup 3)
1817               (const_int 0)] UNSPEC_EXECUTE)
1818      (set (match_dup 0) (match_dup 1))
1819      (use (const_int 1))])]
1820   "")
1822 (define_split
1823   [(set (match_operand:BLK 0 "memory_operand" "")
1824         (match_operand:BLK 1 "memory_operand" ""))
1825    (use (match_operand 2 "register_operand" ""))
1826    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1827    (clobber (match_operand 3 "register_operand" ""))]
1828   "reload_completed && TARGET_CPU_ZARCH"
1829   [(set (match_dup 3) (label_ref (match_dup 4)))
1830    (parallel
1831     [(unspec [(match_dup 2) (mem:BLK (match_dup 3)) 
1832               (label_ref (match_dup 4))] UNSPEC_EXECUTE)
1833      (set (match_dup 0) (match_dup 1))
1834      (use (const_int 1))])]
1835   "operands[4] = gen_label_rtx ();")
1837 ; Move a block of arbitrary length.
1839 (define_expand "movmem_long"
1840   [(parallel
1841     [(clobber (match_dup 2))
1842      (clobber (match_dup 3))
1843      (set (match_operand:BLK 0 "memory_operand" "")
1844           (match_operand:BLK 1 "memory_operand" ""))
1845      (use (match_operand 2 "general_operand" ""))
1846      (use (match_dup 3))
1847      (clobber (reg:CC 33))])]
1848   ""
1850   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
1851   rtx reg0 = gen_reg_rtx (dword_mode);
1852   rtx reg1 = gen_reg_rtx (dword_mode);
1853   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
1854   rtx addr1 = gen_lowpart (Pmode, gen_highpart (word_mode, reg1));
1855   rtx len0 = gen_lowpart (Pmode, reg0);
1856   rtx len1 = gen_lowpart (Pmode, reg1);
1858   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
1859   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
1860   emit_move_insn (len0, operands[2]);
1862   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg1));
1863   emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
1864   emit_move_insn (len1, operands[2]);
1866   operands[0] = replace_equiv_address_nv (operands[0], addr0);
1867   operands[1] = replace_equiv_address_nv (operands[1], addr1);
1868   operands[2] = reg0;
1869   operands[3] = reg1;
1872 (define_insn "*movmem_long_64"
1873   [(clobber (match_operand:TI 0 "register_operand" "=d"))
1874    (clobber (match_operand:TI 1 "register_operand" "=d"))
1875    (set (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
1876         (mem:BLK (subreg:DI (match_operand:TI 3 "register_operand" "1") 0)))
1877    (use (match_dup 2))
1878    (use (match_dup 3))
1879    (clobber (reg:CC 33))]
1880   "TARGET_64BIT"
1881   "mvcle\t%0,%1,0\;jo\t.-4"
1882   [(set_attr "length" "8")
1883    (set_attr "type" "vs")])
1885 (define_insn "*movmem_long_31"
1886   [(clobber (match_operand:DI 0 "register_operand" "=d"))
1887    (clobber (match_operand:DI 1 "register_operand" "=d"))
1888    (set (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
1889         (mem:BLK (subreg:SI (match_operand:DI 3 "register_operand" "1") 0)))
1890    (use (match_dup 2))
1891    (use (match_dup 3))
1892    (clobber (reg:CC 33))]
1893   "!TARGET_64BIT"
1894   "mvcle\t%0,%1,0\;jo\t.-4"
1895   [(set_attr "length" "8")
1896    (set_attr "type" "vs")])
1899 ; clrmemM instruction pattern(s).
1902 (define_expand "clrmem<mode>"
1903   [(set (match_operand:BLK 0 "memory_operand" "")
1904         (const_int 0))
1905    (use (match_operand:GPR 1 "general_operand" ""))
1906    (match_operand 2 "" "")]
1907   ""
1908   "s390_expand_clrmem (operands[0], operands[1]); DONE;")
1910 ; Clear a block that is up to 256 bytes in length.
1911 ; The block length is taken as (operands[1] % 256) + 1.
1913 (define_expand "clrmem_short"
1914   [(parallel
1915     [(set (match_operand:BLK 0 "memory_operand" "")
1916           (const_int 0))
1917      (use (match_operand 1 "nonmemory_operand" ""))
1918      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1919      (clobber (match_dup 2))
1920      (clobber (reg:CC 33))])]
1921   ""
1922   "operands[2] = gen_rtx_SCRATCH (Pmode);")
1924 (define_insn "*clrmem_short"
1925   [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q")
1926         (const_int 0))
1927    (use (match_operand 1 "nonmemory_operand" "n,a,a"))
1928    (use (match_operand 2 "immediate_operand" "X,R,X"))
1929    (clobber (match_scratch 3 "=X,X,&a"))
1930    (clobber (reg:CC 33))]
1931   "(GET_MODE (operands[1]) == Pmode || GET_MODE (operands[1]) == VOIDmode)
1932    && GET_MODE (operands[3]) == Pmode"
1933   "#"
1934   [(set_attr "type" "cs")])
1936 (define_split
1937   [(set (match_operand:BLK 0 "memory_operand" "")
1938         (const_int 0))
1939    (use (match_operand 1 "const_int_operand" ""))
1940    (use (match_operand 2 "immediate_operand" ""))
1941    (clobber (scratch))
1942    (clobber (reg:CC 33))]
1943   "reload_completed"
1944   [(parallel
1945     [(set (match_dup 0) (const_int 0))
1946      (use (match_dup 1))
1947      (clobber (reg:CC 33))])]
1948   "operands[1] = GEN_INT ((INTVAL (operands[1]) & 0xff) + 1);")
1950 (define_split
1951   [(set (match_operand:BLK 0 "memory_operand" "")
1952         (const_int 0))
1953    (use (match_operand 1 "register_operand" ""))
1954    (use (match_operand 2 "memory_operand" ""))
1955    (clobber (scratch))
1956    (clobber (reg:CC 33))]
1957   "reload_completed"
1958   [(parallel
1959     [(unspec [(match_dup 1) (match_dup 2)
1960               (const_int 0)] UNSPEC_EXECUTE)
1961      (set (match_dup 0) (const_int 0))
1962      (use (const_int 1))
1963      (clobber (reg:CC 33))])]
1964   "")
1966 (define_split
1967   [(set (match_operand:BLK 0 "memory_operand" "")
1968         (const_int 0))
1969    (use (match_operand 1 "register_operand" ""))
1970    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1971    (clobber (match_operand 2 "register_operand" ""))
1972    (clobber (reg:CC 33))]
1973   "reload_completed && TARGET_CPU_ZARCH"
1974   [(set (match_dup 2) (label_ref (match_dup 3)))
1975    (parallel
1976     [(unspec [(match_dup 1) (mem:BLK (match_dup 2)) 
1977               (label_ref (match_dup 3))] UNSPEC_EXECUTE)
1978      (set (match_dup 0) (const_int 0))
1979      (use (const_int 1))
1980      (clobber (reg:CC 33))])]
1981   "operands[3] = gen_label_rtx ();")
1983 ; Clear a block of arbitrary length.
1985 (define_expand "clrmem_long"
1986   [(parallel
1987     [(clobber (match_dup 1))
1988      (set (match_operand:BLK 0 "memory_operand" "")
1989           (const_int 0))
1990      (use (match_operand 1 "general_operand" ""))
1991      (use (match_dup 2))
1992      (clobber (reg:CC 33))])]
1993   ""
1995   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
1996   rtx reg0 = gen_reg_rtx (dword_mode);
1997   rtx reg1 = gen_reg_rtx (dword_mode);
1998   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
1999   rtx len0 = gen_lowpart (Pmode, reg0);
2001   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
2002   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
2003   emit_move_insn (len0, operands[1]);
2005   emit_move_insn (reg1, const0_rtx);
2007   operands[0] = replace_equiv_address_nv (operands[0], addr0);
2008   operands[1] = reg0;
2009   operands[2] = reg1;
2012 (define_insn "*clrmem_long_64"
2013   [(clobber (match_operand:TI 0 "register_operand" "=d"))
2014    (set (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
2015         (const_int 0))
2016    (use (match_dup 2))
2017    (use (match_operand:TI 1 "register_operand" "d"))
2018    (clobber (reg:CC 33))]
2019   "TARGET_64BIT"
2020   "mvcle\t%0,%1,0\;jo\t.-4"
2021   [(set_attr "length" "8")
2022    (set_attr "type" "vs")])
2024 (define_insn "*clrmem_long_31"
2025   [(clobber (match_operand:DI 0 "register_operand" "=d"))
2026    (set (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
2027         (const_int 0))
2028    (use (match_dup 2))
2029    (use (match_operand:DI 1 "register_operand" "d"))
2030    (clobber (reg:CC 33))]
2031   "!TARGET_64BIT"
2032   "mvcle\t%0,%1,0\;jo\t.-4"
2033   [(set_attr "length" "8")
2034    (set_attr "type" "vs")])
2037 ; cmpmemM instruction pattern(s).
2040 (define_expand "cmpmemsi"
2041   [(set (match_operand:SI 0 "register_operand" "")
2042         (compare:SI (match_operand:BLK 1 "memory_operand" "")
2043                     (match_operand:BLK 2 "memory_operand" "") ) )
2044    (use (match_operand:SI 3 "general_operand" ""))
2045    (use (match_operand:SI 4 "" ""))]
2046   ""
2047   "s390_expand_cmpmem (operands[0], operands[1],
2048                        operands[2], operands[3]); DONE;")
2050 ; Compare a block that is up to 256 bytes in length.
2051 ; The block length is taken as (operands[2] % 256) + 1.
2053 (define_expand "cmpmem_short"
2054   [(parallel
2055     [(set (reg:CCU 33)
2056           (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2057                        (match_operand:BLK 1 "memory_operand" "")))
2058      (use (match_operand 2 "nonmemory_operand" ""))
2059      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2060      (clobber (match_dup 3))])]
2061   ""
2062   "operands[3] = gen_rtx_SCRATCH (Pmode);")
2064 (define_insn "*cmpmem_short"
2065   [(set (reg:CCU 33)
2066         (compare:CCU (match_operand:BLK 0 "memory_operand" "Q,Q,Q")
2067                      (match_operand:BLK 1 "memory_operand" "Q,Q,Q")))
2068    (use (match_operand 2 "nonmemory_operand" "n,a,a"))
2069    (use (match_operand 3 "immediate_operand" "X,R,X"))
2070    (clobber (match_scratch 4 "=X,X,&a"))]
2071   "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)
2072    && GET_MODE (operands[4]) == Pmode"
2073   "#"
2074   [(set_attr "type" "cs")])
2076 (define_split
2077   [(set (reg:CCU 33)
2078         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2079                      (match_operand:BLK 1 "memory_operand" "")))
2080    (use (match_operand 2 "const_int_operand" ""))
2081    (use (match_operand 3 "immediate_operand" ""))
2082    (clobber (scratch))]
2083   "reload_completed"
2084   [(parallel
2085     [(set (reg:CCU 33) (compare:CCU (match_dup 0) (match_dup 1)))
2086      (use (match_dup 2))])]
2087   "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
2089 (define_split
2090   [(set (reg:CCU 33)
2091         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2092                      (match_operand:BLK 1 "memory_operand" "")))
2093    (use (match_operand 2 "register_operand" ""))
2094    (use (match_operand 3 "memory_operand" ""))
2095    (clobber (scratch))]
2096   "reload_completed"
2097   [(parallel
2098     [(unspec [(match_dup 2) (match_dup 3)
2099               (const_int 0)] UNSPEC_EXECUTE)
2100      (set (reg:CCU 33) (compare:CCU (match_dup 0) (match_dup 1)))
2101      (use (const_int 1))])]
2102   "")
2104 (define_split
2105   [(set (reg:CCU 33)
2106         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2107                      (match_operand:BLK 1 "memory_operand" "")))
2108    (use (match_operand 2 "register_operand" ""))
2109    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2110    (clobber (match_operand 3 "register_operand" ""))]
2111   "reload_completed && TARGET_CPU_ZARCH"
2112   [(set (match_dup 3) (label_ref (match_dup 4)))
2113    (parallel
2114     [(unspec [(match_dup 2) (mem:BLK (match_dup 3)) 
2115               (label_ref (match_dup 4))] UNSPEC_EXECUTE)
2116      (set (reg:CCU 33) (compare:CCU (match_dup 0) (match_dup 1)))
2117      (use (const_int 1))])]
2118   "operands[4] = gen_label_rtx ();")
2120 ; Compare a block of arbitrary length.
2122 (define_expand "cmpmem_long"
2123   [(parallel
2124     [(clobber (match_dup 2))
2125      (clobber (match_dup 3))
2126      (set (reg:CCU 33)
2127           (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2128                        (match_operand:BLK 1 "memory_operand" "")))
2129      (use (match_operand 2 "general_operand" ""))
2130      (use (match_dup 3))])]
2131   ""
2133   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
2134   rtx reg0 = gen_reg_rtx (dword_mode);
2135   rtx reg1 = gen_reg_rtx (dword_mode);
2136   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
2137   rtx addr1 = gen_lowpart (Pmode, gen_highpart (word_mode, reg1));
2138   rtx len0 = gen_lowpart (Pmode, reg0);
2139   rtx len1 = gen_lowpart (Pmode, reg1);
2141   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
2142   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
2143   emit_move_insn (len0, operands[2]);
2145   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg1));
2146   emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
2147   emit_move_insn (len1, operands[2]);
2149   operands[0] = replace_equiv_address_nv (operands[0], addr0);
2150   operands[1] = replace_equiv_address_nv (operands[1], addr1);
2151   operands[2] = reg0;
2152   operands[3] = reg1;
2155 (define_insn "*cmpmem_long_64"
2156   [(clobber (match_operand:TI 0 "register_operand" "=d"))
2157    (clobber (match_operand:TI 1 "register_operand" "=d"))
2158    (set (reg:CCU 33)
2159         (compare:CCU (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
2160                      (mem:BLK (subreg:DI (match_operand:TI 3 "register_operand" "1") 0))))
2161    (use (match_dup 2))
2162    (use (match_dup 3))]
2163   "TARGET_64BIT"
2164   "clcle\t%0,%1,0\;jo\t.-4"
2165   [(set_attr "length" "8")
2166    (set_attr "type" "vs")])
2168 (define_insn "*cmpmem_long_31"
2169   [(clobber (match_operand:DI 0 "register_operand" "=d"))
2170    (clobber (match_operand:DI 1 "register_operand" "=d"))
2171    (set (reg:CCU 33)
2172         (compare:CCU (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
2173                      (mem:BLK (subreg:SI (match_operand:DI 3 "register_operand" "1") 0))))
2174    (use (match_dup 2))
2175    (use (match_dup 3))]
2176   "!TARGET_64BIT"
2177   "clcle\t%0,%1,0\;jo\t.-4"
2178   [(set_attr "length" "8")
2179    (set_attr "type" "vs")])
2181 ; Convert CCUmode condition code to integer.
2182 ; Result is zero if EQ, positive if LTU, negative if GTU.
2184 (define_insn_and_split "cmpint"
2185   [(set (match_operand:SI 0 "register_operand" "=d")
2186         (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2187                    UNSPEC_CMPINT))
2188    (clobber (reg:CC 33))]
2189   ""
2190   "#"
2191   "reload_completed"
2192   [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
2193    (parallel
2194     [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))
2195      (clobber (reg:CC 33))])])
2197 (define_insn_and_split "*cmpint_cc"
2198   [(set (reg 33)
2199         (compare (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2200                             UNSPEC_CMPINT)
2201                  (const_int 0)))
2202    (set (match_operand:SI 0 "register_operand" "=d")
2203         (unspec:SI [(match_dup 1)] UNSPEC_CMPINT))]
2204   "s390_match_ccmode (insn, CCSmode)"
2205   "#"
2206   "&& reload_completed"
2207   [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
2208    (parallel
2209     [(set (match_dup 2) (match_dup 3))
2210      (set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))])]
2212   rtx result = gen_rtx_ASHIFTRT (SImode, operands[0], GEN_INT (30));
2213   operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
2214   operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
2217 (define_insn_and_split "*cmpint_sign"
2218   [(set (match_operand:DI 0 "register_operand" "=d")
2219         (sign_extend:DI (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2220                                    UNSPEC_CMPINT)))
2221    (clobber (reg:CC 33))]
2222   "TARGET_64BIT"
2223   "#"
2224   "&& reload_completed"
2225   [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
2226    (parallel
2227     [(set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))
2228      (clobber (reg:CC 33))])])
2230 (define_insn_and_split "*cmpint_sign_cc"
2231   [(set (reg 33)
2232         (compare (ashiftrt:DI (ashift:DI (subreg:DI 
2233                    (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2234                               UNSPEC_CMPINT) 0)
2235                    (const_int 32)) (const_int 32))
2236                  (const_int 0)))
2237    (set (match_operand:DI 0 "register_operand" "=d")
2238         (sign_extend:DI (unspec:SI [(match_dup 1)] UNSPEC_CMPINT)))]
2239   "s390_match_ccmode (insn, CCSmode) && TARGET_64BIT"
2240   "#"
2241   "&& reload_completed"
2242   [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
2243    (parallel
2244     [(set (match_dup 2) (match_dup 3))
2245      (set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))])]
2247   rtx result = gen_rtx_ASHIFTRT (DImode, operands[0], GEN_INT (62));
2248   operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
2249   operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
2254 ;;- Conversion instructions.
2258 (define_insn "*sethigh<mode>si"
2259   [(set (match_operand:SI 0 "register_operand" "=d,d")
2260         (unspec:SI [(match_operand:HQI 1 "s_operand" "Q,S")] UNSPEC_SETHIGH))
2261    (clobber (reg:CC 33))]
2262   ""
2263   "@
2264    icm\t%0,<icm_hi>,%S1
2265    icmy\t%0,<icm_hi>,%S1"
2266   [(set_attr "op_type" "RS,RSY")])
2268 (define_insn "*sethighqidi_64"
2269   [(set (match_operand:DI 0 "register_operand" "=d")
2270         (unspec:DI [(match_operand:QI 1 "s_operand" "QS")] UNSPEC_SETHIGH))
2271    (clobber (reg:CC 33))]
2272   "TARGET_64BIT"
2273   "icmh\t%0,8,%S1"
2274   [(set_attr "op_type" "RSY")])
2276 (define_insn "*sethighqidi_31"
2277   [(set (match_operand:DI 0 "register_operand" "=d,d")
2278         (unspec:DI [(match_operand:QI 1 "s_operand" "Q,S")] UNSPEC_SETHIGH))
2279    (clobber (reg:CC 33))]
2280   "!TARGET_64BIT"
2281   "@
2282    icm\t%0,8,%S1
2283    icmy\t%0,8,%S1"
2284   [(set_attr "op_type" "RS,RSY")])
2286 (define_insn_and_split "*extractqi"
2287   [(set (match_operand:SI 0 "register_operand" "=d")
2288         (zero_extract:SI (match_operand:QI 1 "s_operand" "Q")
2289                          (match_operand 2 "const_int_operand" "n")
2290                          (const_int 0)))
2291    (clobber (reg:CC 33))]
2292   "!TARGET_64BIT
2293    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) < 8"
2294   "#"
2295   "&& reload_completed"
2296   [(parallel
2297     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2298      (clobber (reg:CC 33))])
2299     (set (match_dup 0) (lshiftrt:SI (match_dup 0) (match_dup 2)))]
2301   operands[2] = GEN_INT (32 - INTVAL (operands[2]));
2302   operands[1] = change_address (operands[1], QImode, 0);
2305 (define_insn_and_split "*extracthi"
2306   [(set (match_operand:SI 0 "register_operand" "=d")
2307         (zero_extract:SI (match_operand:QI 1 "s_operand" "Q")
2308                          (match_operand 2 "const_int_operand" "n")
2309                          (const_int 0)))
2310    (clobber (reg:CC 33))]
2311   "!TARGET_64BIT
2312    && INTVAL (operands[2]) >= 8 && INTVAL (operands[2]) < 16"
2313   "#"
2314   "&& reload_completed"
2315   [(parallel
2316     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2317      (clobber (reg:CC 33))])
2318     (set (match_dup 0) (lshiftrt:SI (match_dup 0) (match_dup 2)))]
2320   operands[2] = GEN_INT (32 - INTVAL (operands[2]));
2321   operands[1] = change_address (operands[1], HImode, 0);
2325 ; extendsidi2 instruction pattern(s).
2328 (define_expand "extendsidi2"
2329   [(set (match_operand:DI 0 "register_operand" "")
2330         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
2331   ""
2332   "
2334   if (!TARGET_64BIT)
2335     {
2336       emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
2337       emit_move_insn (gen_highpart (SImode, operands[0]), operands[1]);
2338       emit_move_insn (gen_lowpart (SImode, operands[0]), const0_rtx);
2339       emit_insn (gen_ashrdi3 (operands[0], operands[0], GEN_INT (32)));
2340       DONE;
2341     }
2345 (define_insn "*extendsidi2"
2346   [(set (match_operand:DI 0 "register_operand" "=d,d")
2347         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m")))]
2348   "TARGET_64BIT"
2349   "@
2350    lgfr\t%0,%1
2351    lgf\t%0,%1"
2352   [(set_attr "op_type" "RRE,RXY")])
2355 ; extend(hi|qi)di2 instruction pattern(s).
2358 (define_expand "extend<mode>di2"
2359   [(set (match_operand:DI 0 "register_operand" "")
2360         (sign_extend:DI (match_operand:HQI 1 "register_operand" "")))]
2361   ""
2362   "
2364   if (!TARGET_64BIT)
2365     {
2366       rtx tmp = gen_reg_rtx (SImode);
2367       emit_insn (gen_extend<mode>si2 (tmp, operands[1]));
2368       emit_insn (gen_extendsidi2 (operands[0], tmp));
2369       DONE;
2370     }
2371   else
2372     {
2373       rtx bitcount = GEN_INT (GET_MODE_BITSIZE (DImode) - 
2374                               GET_MODE_BITSIZE (<MODE>mode));
2375       operands[1] = gen_lowpart (DImode, operands[1]);
2376       emit_insn (gen_ashldi3 (operands[0], operands[1], bitcount));
2377       emit_insn (gen_ashrdi3 (operands[0], operands[0], bitcount));
2378       DONE;
2379     }
2383 (define_insn "*extendhidi2"
2384   [(set (match_operand:DI 0 "register_operand" "=d")
2385         (sign_extend:DI (match_operand:HI 1 "memory_operand" "m")))]
2386   "TARGET_64BIT"
2387   "lgh\t%0,%1"
2388   [(set_attr "op_type" "RXY")])
2390 (define_insn "*extendqidi2"
2391   [(set (match_operand:DI 0 "register_operand" "=d")
2392         (sign_extend:DI (match_operand:QI 1 "memory_operand" "m")))]
2393   "TARGET_64BIT && TARGET_LONG_DISPLACEMENT"
2394   "lgb\t%0,%1"
2395   [(set_attr "op_type" "RXY")])
2397 (define_insn_and_split "*extendqidi2_short_displ"
2398   [(set (match_operand:DI 0 "register_operand" "=d")
2399         (sign_extend:DI (match_operand:QI 1 "s_operand" "Q")))
2400    (clobber (reg:CC 33))]
2401   "TARGET_64BIT && !TARGET_LONG_DISPLACEMENT"
2402   "#"
2403   "&& reload_completed"
2404   [(parallel
2405     [(set (match_dup 0) (unspec:DI [(match_dup 1)] UNSPEC_SETHIGH))
2406      (clobber (reg:CC 33))])
2407    (parallel
2408     [(set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 56)))
2409      (clobber (reg:CC 33))])]
2410   "")
2413 ; extend(hi|qi)si2 instruction pattern(s).
2416 (define_expand "extend<mode>si2"
2417   [(set (match_operand:SI 0 "register_operand" "")
2418         (sign_extend:SI (match_operand:HQI 1 "register_operand" "")))]
2419   ""
2420   "
2422   rtx bitcount = GEN_INT (GET_MODE_BITSIZE(SImode) - 
2423                           GET_MODE_BITSIZE(<MODE>mode));
2424   operands[1] = gen_lowpart (SImode, operands[1]);
2425   emit_insn (gen_ashlsi3 (operands[0], operands[1], bitcount));
2426   emit_insn (gen_ashrsi3 (operands[0], operands[0], bitcount));
2427   DONE;
2431 (define_insn "*extendhisi2"
2432   [(set (match_operand:SI 0 "register_operand" "=d,d")
2433         (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T")))]
2434   ""
2435   "@
2436    lh\t%0,%1
2437    lhy\t%0,%1"
2438   [(set_attr "op_type" "RX,RXY")])
2440 (define_insn "*extendqisi2"
2441   [(set (match_operand:SI 0 "register_operand" "=d")
2442         (sign_extend:SI (match_operand:QI 1 "memory_operand" "m")))]
2443   "TARGET_LONG_DISPLACEMENT"
2444   "lb\t%0,%1"
2445   [(set_attr "op_type" "RXY")])
2447 (define_insn_and_split "*extendqisi2_short_displ"
2448   [(set (match_operand:SI 0 "register_operand" "=d")
2449         (sign_extend:SI (match_operand:QI 1 "s_operand" "Q")))
2450    (clobber (reg:CC 33))]
2451   "!TARGET_LONG_DISPLACEMENT"
2452   "#"
2453   "&& reload_completed"
2454   [(parallel
2455     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2456      (clobber (reg:CC 33))])
2457    (parallel
2458     [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 24)))
2459      (clobber (reg:CC 33))])]
2460   "")
2463 ; extendqihi2 instruction pattern(s).
2468 ; zero_extendsidi2 instruction pattern(s).
2471 (define_expand "zero_extendsidi2"
2472   [(set (match_operand:DI 0 "register_operand" "")
2473         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
2474   ""
2475   "
2477   if (!TARGET_64BIT)
2478     {
2479       emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
2480       emit_move_insn (gen_lowpart (SImode, operands[0]), operands[1]);
2481       emit_move_insn (gen_highpart (SImode, operands[0]), const0_rtx);
2482       DONE;
2483     }
2487 (define_insn "*zero_extendsidi2"
2488   [(set (match_operand:DI 0 "register_operand" "=d,d")
2489         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m")))]
2490   "TARGET_64BIT"
2491   "@
2492    llgfr\t%0,%1
2493    llgf\t%0,%1"
2494   [(set_attr "op_type" "RRE,RXY")])
2497 ; zero_extend(hi|qi)di2 instruction pattern(s).
2500 (define_expand "zero_extend<mode>di2"
2501   [(set (match_operand:DI 0 "register_operand" "")
2502         (zero_extend:DI (match_operand:HQI 1 "register_operand" "")))]
2503   ""
2504   "
2506   if (!TARGET_64BIT)
2507     {
2508       rtx tmp = gen_reg_rtx (SImode);
2509       emit_insn (gen_zero_extend<mode>si2 (tmp, operands[1]));
2510       emit_insn (gen_zero_extendsidi2 (operands[0], tmp));
2511       DONE;
2512     }
2513   else
2514     {
2515       rtx bitcount = GEN_INT (GET_MODE_BITSIZE(DImode) - 
2516                               GET_MODE_BITSIZE(<MODE>mode));
2517       operands[1] = gen_lowpart (DImode, operands[1]);
2518       emit_insn (gen_ashldi3 (operands[0], operands[1], bitcount));
2519       emit_insn (gen_lshrdi3 (operands[0], operands[0], bitcount));
2520       DONE;
2521     }
2525 (define_insn "*zero_extend<mode>di2"
2526   [(set (match_operand:DI 0 "register_operand" "=d")
2527         (zero_extend:DI (match_operand:HQI 1 "memory_operand" "m")))]
2528   "TARGET_64BIT"
2529   "llg<hc>\t%0,%1"
2530   [(set_attr "op_type" "RXY")])
2533 ; LLGT-type instructions (zero-extend from 31 bit to 64 bit).
2536 (define_insn "*llgt_sidi"
2537   [(set (match_operand:DI 0 "register_operand" "=d")
2538         (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "m") 0)
2539                 (const_int 2147483647)))]
2540   "TARGET_64BIT"
2541   "llgt\t%0,%1"
2542   [(set_attr "op_type"  "RXE")])
2544 (define_insn_and_split "*llgt_sidi_split"
2545   [(set (match_operand:DI 0 "register_operand" "=d")
2546         (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "m") 0)
2547                 (const_int 2147483647)))
2548    (clobber (reg:CC 33))]
2549   "TARGET_64BIT"
2550   "#"
2551   "&& reload_completed"
2552   [(set (match_dup 0)
2553         (and:DI (subreg:DI (match_dup 1) 0)
2554                 (const_int 2147483647)))]
2555   "")
2557 (define_insn "*llgt_sisi"
2558   [(set (match_operand:SI 0 "register_operand" "=d,d")
2559         (and:SI (match_operand:SI 1 "nonimmediate_operand" "d,m")
2560                 (const_int 2147483647)))]
2561   "TARGET_64BIT"
2562   "@
2563    llgtr\t%0,%1
2564    llgt\t%0,%1"
2565   [(set_attr "op_type"  "RRE,RXE")])
2567 (define_insn "*llgt_didi"
2568   [(set (match_operand:DI 0 "register_operand" "=d,d")
2569         (and:DI (match_operand:DI 1 "nonimmediate_operand" "d,o")
2570                 (const_int 2147483647)))]
2571   "TARGET_64BIT"
2572   "@
2573    llgtr\t%0,%1
2574    llgt\t%0,%N1"
2575   [(set_attr "op_type"  "RRE,RXE")])
2577 (define_split
2578   [(set (match_operand:GPR 0 "register_operand" "")
2579         (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "")
2580                  (const_int 2147483647)))
2581    (clobber (reg:CC 33))]
2582   "TARGET_64BIT && reload_completed"
2583   [(set (match_dup 0)
2584         (and:GPR (match_dup 1)
2585                  (const_int 2147483647)))]
2586   "")
2589 ; zero_extend(hi|qi)si2 instruction pattern(s).
2592 (define_expand "zero_extend<mode>si2"
2593   [(set (match_operand:SI 0 "register_operand" "")
2594         (zero_extend:SI (match_operand:HQI 1 "register_operand" "")))]
2595   ""
2596   "
2598   operands[1] = gen_lowpart (SImode, operands[1]);
2599   emit_insn (gen_andsi3 (operands[0], operands[1], 
2600     GEN_INT ((1 << GET_MODE_BITSIZE(<MODE>mode)) - 1)));
2601   DONE;
2605 (define_insn "*zero_extend<mode>si2_64"
2606   [(set (match_operand:SI 0 "register_operand" "=d")
2607         (zero_extend:SI (match_operand:HQI 1 "memory_operand" "m")))]
2608   "TARGET_ZARCH"
2609   "llg<hc>\t%0,%1"
2610   [(set_attr "op_type" "RXY")])
2612 (define_insn_and_split "*zero_extendhisi2_31"
2613   [(set (match_operand:SI 0 "register_operand" "=&d")
2614         (zero_extend:SI (match_operand:HI 1 "s_operand" "QS")))
2615    (clobber (reg:CC 33))]
2616   "!TARGET_ZARCH"
2617   "#"
2618   "&& reload_completed"
2619   [(set (match_dup 0) (const_int 0))
2620    (parallel
2621     [(set (strict_low_part (match_dup 2)) (match_dup 1))
2622      (clobber (reg:CC 33))])]
2623   "operands[2] = gen_lowpart (HImode, operands[0]);")
2625 (define_insn_and_split "*zero_extendqisi2_31"
2626   [(set (match_operand:SI 0 "register_operand" "=&d")
2627         (zero_extend:SI (match_operand:QI 1 "memory_operand" "m")))]
2628   "!TARGET_ZARCH"
2629   "#"
2630   "&& reload_completed"
2631   [(set (match_dup 0) (const_int 0))
2632    (set (strict_low_part (match_dup 2)) (match_dup 1))]
2633   "operands[2] = gen_lowpart (QImode, operands[0]);")
2636 ; zero_extendqihi2 instruction pattern(s).
2639 (define_expand "zero_extendqihi2"
2640   [(set (match_operand:HI 0 "register_operand" "")
2641         (zero_extend:HI (match_operand:QI 1 "register_operand" "")))]
2642   "TARGET_ZARCH"
2643   "
2645   operands[1] = gen_lowpart (HImode, operands[1]);
2646   emit_insn (gen_andhi3 (operands[0], operands[1], GEN_INT (0xff)));
2647   DONE;
2651 (define_insn "*zero_extendqihi2_64"
2652   [(set (match_operand:HI 0 "register_operand" "=d")
2653         (zero_extend:HI (match_operand:QI 1 "memory_operand" "m")))]
2654   "TARGET_ZARCH"
2655   "llgc\t%0,%1"
2656   [(set_attr "op_type" "RXY")])
2658 (define_insn_and_split "*zero_extendqihi2_31"
2659   [(set (match_operand:HI 0 "register_operand" "=&d")
2660         (zero_extend:HI (match_operand:QI 1 "memory_operand" "m")))]
2661   "!TARGET_ZARCH"
2662   "#"
2663   "&& reload_completed"
2664   [(set (match_dup 0) (const_int 0))
2665    (set (strict_low_part (match_dup 2)) (match_dup 1))]
2666   "operands[2] = gen_lowpart (QImode, operands[0]);")
2670 ; fixuns_truncdfdi2 and fix_truncdfsi2 instruction pattern(s).
2673 (define_expand "fixuns_truncdfdi2"
2674   [(set (match_operand:DI 0 "register_operand" "")
2675         (unsigned_fix:DI (match_operand:DF 1 "register_operand" "")))]
2676   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2678   rtx label1 = gen_label_rtx ();
2679   rtx label2 = gen_label_rtx ();
2680   rtx temp = gen_reg_rtx (DFmode);
2681   operands[1] = force_reg (DFmode, operands[1]);
2683   emit_insn (gen_cmpdf (operands[1],
2684         CONST_DOUBLE_FROM_REAL_VALUE (
2685           REAL_VALUE_ATOF ("9223372036854775808.0", DFmode), DFmode)));
2686   emit_jump_insn (gen_blt (label1));
2687   emit_insn (gen_subdf3 (temp, operands[1],
2688         CONST_DOUBLE_FROM_REAL_VALUE (
2689           REAL_VALUE_ATOF ("18446744073709551616.0", DFmode), DFmode)));
2690   emit_insn (gen_fix_truncdfdi2_ieee (operands[0], temp, GEN_INT(7)));
2691   emit_jump (label2);
2693   emit_label (label1);
2694   emit_insn (gen_fix_truncdfdi2_ieee (operands[0], operands[1], GEN_INT(5)));
2695   emit_label (label2);
2696   DONE;
2699 (define_expand "fix_truncdfdi2"
2700   [(set (match_operand:DI 0 "register_operand" "")
2701         (fix:DI (match_operand:DF 1 "nonimmediate_operand" "")))]
2702   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2704   operands[1] = force_reg (DFmode, operands[1]);
2705   emit_insn (gen_fix_truncdfdi2_ieee (operands[0], operands[1], GEN_INT(5)));
2706   DONE;
2709 (define_insn "fix_truncdfdi2_ieee"
2710   [(set (match_operand:DI 0 "register_operand" "=d")
2711         (fix:DI (match_operand:DF 1 "register_operand" "f")))
2712    (unspec:DI [(match_operand:DI 2 "immediate_operand" "K")] UNSPEC_ROUND)
2713    (clobber (reg:CC 33))]
2714   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2715   "cgdbr\t%0,%h2,%1"
2716   [(set_attr "op_type" "RRE")
2717    (set_attr "type"    "ftoi")])
2720 ; fixuns_truncdfsi2 and fix_truncdfsi2 instruction pattern(s).
2723 (define_expand "fixuns_truncdfsi2"
2724   [(set (match_operand:SI 0 "register_operand" "")
2725         (unsigned_fix:SI (match_operand:DF 1 "register_operand" "")))]
2726   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2728   rtx label1 = gen_label_rtx ();
2729   rtx label2 = gen_label_rtx ();
2730   rtx temp = gen_reg_rtx (DFmode);
2732   operands[1] = force_reg (DFmode,operands[1]);
2733   emit_insn (gen_cmpdf (operands[1],
2734         CONST_DOUBLE_FROM_REAL_VALUE (
2735           REAL_VALUE_ATOF ("2147483648.0", DFmode), DFmode)));
2736   emit_jump_insn (gen_blt (label1));
2737   emit_insn (gen_subdf3 (temp, operands[1],
2738         CONST_DOUBLE_FROM_REAL_VALUE (
2739           REAL_VALUE_ATOF ("4294967296.0", DFmode), DFmode)));
2740   emit_insn (gen_fix_truncdfsi2_ieee (operands[0], temp, GEN_INT (7)));
2741   emit_jump (label2);
2743   emit_label (label1);
2744   emit_insn (gen_fix_truncdfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2745   emit_label (label2);
2746   DONE;
2749 (define_expand "fix_truncdfsi2"
2750   [(set (match_operand:SI 0 "register_operand" "")
2751         (fix:SI (match_operand:DF 1 "nonimmediate_operand" "")))]
2752   "TARGET_HARD_FLOAT"
2754   if (TARGET_IBM_FLOAT)
2755     {
2756       /* This is the algorithm from POP chapter A.5.7.2.  */
2758       rtx temp   = assign_stack_local (BLKmode, 8, BITS_PER_WORD);
2759       rtx two31r = s390_gen_rtx_const_DI (0x4f000000, 0x08000000);
2760       rtx two32  = s390_gen_rtx_const_DI (0x4e000001, 0x00000000);
2762       operands[1] = force_reg (DFmode, operands[1]);
2763       emit_insn (gen_fix_truncdfsi2_ibm (operands[0], operands[1],
2764                                          two31r, two32, temp));
2765     }
2766   else
2767     {
2768       operands[1] = force_reg (DFmode, operands[1]);
2769       emit_insn (gen_fix_truncdfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2770     }
2772   DONE;
2775 (define_insn "fix_truncdfsi2_ieee"
2776   [(set (match_operand:SI 0 "register_operand" "=d")
2777         (fix:SI (match_operand:DF 1 "register_operand" "f")))
2778     (unspec:SI [(match_operand:SI 2 "immediate_operand" "K")] UNSPEC_ROUND)
2779     (clobber (reg:CC 33))]
2780   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2781   "cfdbr\t%0,%h2,%1"
2782    [(set_attr "op_type" "RRE")
2783     (set_attr "type"    "ftoi")])
2785 (define_insn "fix_truncdfsi2_ibm"
2786   [(set (match_operand:SI 0 "register_operand" "=d")
2787         (fix:SI (match_operand:DF 1 "nonimmediate_operand" "+f")))
2788    (use (match_operand:DI 2 "immediate_operand" "m"))
2789    (use (match_operand:DI 3 "immediate_operand" "m"))
2790    (use (match_operand:BLK 4 "memory_operand" "m"))
2791    (clobber (reg:CC 33))]
2792   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2794    output_asm_insn ("sd\t%1,%2", operands);
2795    output_asm_insn ("aw\t%1,%3", operands);
2796    output_asm_insn ("std\t%1,%4", operands);
2797    output_asm_insn ("xi\t%N4,128", operands);
2798    return "l\t%0,%N4";
2800   [(set_attr "length" "20")])
2803 ; fixuns_truncsfdi2 and fix_truncsfdi2 instruction pattern(s).
2806 (define_expand "fixuns_truncsfdi2"
2807   [(set (match_operand:DI 0 "register_operand" "")
2808         (unsigned_fix:DI (match_operand:SF 1 "register_operand" "")))]
2809   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2811   rtx label1 = gen_label_rtx ();
2812   rtx label2 = gen_label_rtx ();
2813   rtx temp = gen_reg_rtx (SFmode);
2815   operands[1] = force_reg (SFmode, operands[1]);
2816   emit_insn (gen_cmpsf (operands[1],
2817         CONST_DOUBLE_FROM_REAL_VALUE (
2818           REAL_VALUE_ATOF ("9223372036854775808.0", SFmode), SFmode)));
2819   emit_jump_insn (gen_blt (label1));
2821   emit_insn (gen_subsf3 (temp, operands[1],
2822         CONST_DOUBLE_FROM_REAL_VALUE (
2823           REAL_VALUE_ATOF ("18446744073709551616.0", SFmode), SFmode)));
2824   emit_insn (gen_fix_truncsfdi2_ieee (operands[0], temp, GEN_INT(7)));
2825   emit_jump (label2);
2827   emit_label (label1);
2828   emit_insn (gen_fix_truncsfdi2_ieee (operands[0], operands[1], GEN_INT(5)));
2829   emit_label (label2);
2830   DONE;
2833 (define_expand "fix_truncsfdi2"
2834   [(set (match_operand:DI 0 "register_operand" "")
2835         (fix:DI (match_operand:SF 1 "nonimmediate_operand" "")))]
2836   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2838   operands[1] = force_reg (SFmode, operands[1]);
2839   emit_insn (gen_fix_truncsfdi2_ieee (operands[0], operands[1], GEN_INT(5)));
2840   DONE;
2843 (define_insn "fix_truncsfdi2_ieee"
2844   [(set (match_operand:DI 0 "register_operand" "=d")
2845         (fix:DI (match_operand:SF 1 "register_operand"  "f")))
2846    (unspec:DI [(match_operand:DI 2 "immediate_operand" "K")] UNSPEC_ROUND)
2847    (clobber (reg:CC 33))]
2848   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2849   "cgebr\t%0,%h2,%1"
2850   [(set_attr "op_type" "RRE")
2851    (set_attr "type"    "ftoi")])
2854 ; fixuns_truncsfsi2 and fix_truncsfsi2 instruction pattern(s).
2857 (define_expand "fixuns_truncsfsi2"
2858   [(set (match_operand:SI 0 "register_operand" "")
2859         (unsigned_fix:SI (match_operand:SF 1 "register_operand" "")))]
2860   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2862   rtx label1 = gen_label_rtx ();
2863   rtx label2 = gen_label_rtx ();
2864   rtx temp = gen_reg_rtx (SFmode);
2866   operands[1] = force_reg (SFmode, operands[1]);
2867   emit_insn (gen_cmpsf (operands[1],
2868         CONST_DOUBLE_FROM_REAL_VALUE (
2869           REAL_VALUE_ATOF ("2147483648.0", SFmode), SFmode)));
2870   emit_jump_insn (gen_blt (label1));
2871   emit_insn (gen_subsf3 (temp, operands[1],
2872         CONST_DOUBLE_FROM_REAL_VALUE (
2873           REAL_VALUE_ATOF ("4294967296.0", SFmode), SFmode)));
2874   emit_insn (gen_fix_truncsfsi2_ieee (operands[0], temp, GEN_INT (7)));
2875   emit_jump (label2);
2877   emit_label (label1);
2878   emit_insn (gen_fix_truncsfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2879   emit_label (label2);
2880   DONE;
2883 (define_expand "fix_truncsfsi2"
2884   [(set (match_operand:SI 0 "register_operand" "")
2885         (fix:SI (match_operand:SF 1 "nonimmediate_operand" "")))]
2886   "TARGET_HARD_FLOAT"
2888   if (TARGET_IBM_FLOAT)
2889     {
2890       /* Convert to DFmode and then use the POP algorithm.  */
2891       rtx temp = gen_reg_rtx (DFmode);
2892       emit_insn (gen_extendsfdf2 (temp, operands[1]));
2893       emit_insn (gen_fix_truncdfsi2 (operands[0], temp));
2894     }
2895   else
2896     {
2897       operands[1] = force_reg (SFmode, operands[1]);
2898       emit_insn (gen_fix_truncsfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2899     }
2901   DONE;
2904 (define_insn "fix_truncsfsi2_ieee"
2905   [(set (match_operand:SI 0 "register_operand" "=d")
2906         (fix:SI (match_operand:SF 1 "register_operand" "f")))
2907     (unspec:SI [(match_operand:SI 2 "immediate_operand" "K")] UNSPEC_ROUND)
2908     (clobber (reg:CC 33))]
2909   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2910   "cfebr\t%0,%h2,%1"
2911   [(set_attr "op_type" "RRE")
2912    (set_attr "type"    "ftoi")])
2915 ; floatdi(df|sf)2 instruction pattern(s).
2918 (define_insn "floatdi<mode>2"
2919   [(set (match_operand:FPR 0 "register_operand" "=f")
2920         (float:FPR (match_operand:DI 1 "register_operand" "d")))]
2921   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2922   "c<de>gbr\t%0,%1"
2923   [(set_attr "op_type" "RRE")
2924    (set_attr "type"    "itof" )])
2927 ; floatsidf2 instruction pattern(s).
2930 (define_expand "floatsidf2"
2931   [(set (match_operand:DF 0 "register_operand" "")
2932         (float:DF (match_operand:SI 1 "register_operand" "")))]
2933   "TARGET_HARD_FLOAT"
2935   if (TARGET_IBM_FLOAT)
2936     {
2937       /* This is the algorithm from POP chapter A.5.7.1.  */
2939       rtx temp  = assign_stack_local (BLKmode, 8, BITS_PER_WORD);
2940       rtx two31 = s390_gen_rtx_const_DI (0x4e000000, 0x80000000);
2942       emit_insn (gen_floatsidf2_ibm (operands[0], operands[1], two31, temp));
2943       DONE;
2944     }
2947 (define_insn "floatsidf2_ieee"
2948   [(set (match_operand:DF 0 "register_operand" "=f")
2949         (float:DF (match_operand:SI 1 "register_operand" "d")))]
2950   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2951   "cdfbr\t%0,%1"
2952   [(set_attr "op_type" "RRE")
2953    (set_attr "type"   "itof" )])
2955 (define_insn "floatsidf2_ibm"
2956   [(set (match_operand:DF 0 "register_operand" "=f")
2957         (float:DF (match_operand:SI 1 "register_operand" "d")))
2958    (use (match_operand:DI 2 "immediate_operand" "m"))
2959    (use (match_operand:BLK 3 "memory_operand" "m"))
2960    (clobber (reg:CC 33))]
2961   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2963    output_asm_insn ("st\t%1,%N3", operands);
2964    output_asm_insn ("xi\t%N3,128", operands);
2965    output_asm_insn ("mvc\t%O3(4,%R3),%2", operands);
2966    output_asm_insn ("ld\t%0,%3", operands);
2967    return "sd\t%0,%2";
2969   [(set_attr "length" "20")])
2972 ; floatsisf2 instruction pattern(s).
2975 (define_expand "floatsisf2"
2976   [(set (match_operand:SF 0 "register_operand" "")
2977         (float:SF (match_operand:SI 1 "register_operand" "")))]
2978   "TARGET_HARD_FLOAT"
2980   if (TARGET_IBM_FLOAT)
2981     {
2982       /* Use the POP algorithm to convert to DFmode and then truncate.  */
2983       rtx temp = gen_reg_rtx (DFmode);
2984       emit_insn (gen_floatsidf2 (temp, operands[1]));
2985       emit_insn (gen_truncdfsf2 (operands[0], temp));
2986       DONE;
2987     }
2990 (define_insn "floatsisf2_ieee"
2991   [(set (match_operand:SF 0 "register_operand" "=f")
2992         (float:SF (match_operand:SI 1 "register_operand" "d")))]
2993   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2994   "cefbr\t%0,%1"
2995   [(set_attr "op_type" "RRE")
2996    (set_attr "type"    "itof" )])
2999 ; truncdfsf2 instruction pattern(s).
3002 (define_expand "truncdfsf2"
3003   [(set (match_operand:SF 0 "register_operand" "")
3004         (float_truncate:SF (match_operand:DF 1 "register_operand" "")))]
3005   "TARGET_HARD_FLOAT"
3006   "")
3008 (define_insn "truncdfsf2_ieee"
3009   [(set (match_operand:SF 0 "register_operand" "=f")
3010         (float_truncate:SF (match_operand:DF 1 "register_operand" "f")))]
3011   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3012   "ledbr\t%0,%1"
3013   [(set_attr "op_type"  "RRE")])
3015 (define_insn "truncdfsf2_ibm"
3016   [(set (match_operand:SF 0 "register_operand" "=f,f")
3017         (float_truncate:SF (match_operand:DF 1 "nonimmediate_operand" "f,R")))]
3018   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3019   "@
3020    ler\t%0,%1
3021    le\t%0,%1"
3022   [(set_attr "op_type"  "RR,RX")
3023    (set_attr "type"   "floadsf")])
3026 ; extendsfdf2 instruction pattern(s).
3029 (define_expand "extendsfdf2"
3030   [(set (match_operand:DF 0 "register_operand" "")
3031         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "")))]
3032   "TARGET_HARD_FLOAT"
3034   if (TARGET_IBM_FLOAT)
3035     {
3036       emit_insn (gen_extendsfdf2_ibm (operands[0], operands[1]));
3037       DONE;
3038     }
3041 (define_insn "extendsfdf2_ieee"
3042   [(set (match_operand:DF 0 "register_operand" "=f,f")
3043         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand"  "f,R")))]
3044   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3045   "@
3046    ldebr\t%0,%1
3047    ldeb\t%0,%1"
3048   [(set_attr "op_type"  "RRE,RXE")
3049    (set_attr "type"   "floadsf")])
3051 (define_insn "extendsfdf2_ibm"
3052   [(set (match_operand:DF 0 "register_operand" "=f,f")
3053         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "f,R")))
3054    (clobber (reg:CC 33))]
3055   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3056   "@
3057    sdr\t%0,%0\;ler\t%0,%1
3058    sdr\t%0,%0\;le\t%0,%1"
3059   [(set_attr "length"   "4,6")
3060    (set_attr "type"     "floadsf")])
3064 ;; ARITHMETIC OPERATIONS
3066 ;  arithmetic operations set the ConditionCode,
3067 ;  because of unpredictable Bits in Register for Halfword and Byte
3068 ;  the ConditionCode can be set wrong in operations for Halfword and Byte
3071 ;;- Add instructions.
3075 ; addti3 instruction pattern(s).
3078 (define_insn_and_split "addti3"
3079   [(set (match_operand:TI 0 "register_operand" "=&d")
3080         (plus:TI (match_operand:TI 1 "nonimmediate_operand" "%0")
3081                  (match_operand:TI 2 "general_operand" "do") ) )
3082    (clobber (reg:CC 33))]
3083   "TARGET_64BIT"
3084   "#"
3085   "&& reload_completed"
3086   [(parallel
3087     [(set (reg:CCL1 33)
3088           (compare:CCL1 (plus:DI (match_dup 7) (match_dup 8))
3089                         (match_dup 7)))
3090      (set (match_dup 6) (plus:DI (match_dup 7) (match_dup 8)))])
3091    (parallel
3092     [(set (match_dup 3) (plus:DI (plus:DI (match_dup 4) (match_dup 5))
3093                                  (ltu:DI (reg:CCL1 33) (const_int 0))))
3094      (clobber (reg:CC 33))])]
3095   "operands[3] = operand_subword (operands[0], 0, 0, TImode);
3096    operands[4] = operand_subword (operands[1], 0, 0, TImode);
3097    operands[5] = operand_subword (operands[2], 0, 0, TImode);
3098    operands[6] = operand_subword (operands[0], 1, 0, TImode);
3099    operands[7] = operand_subword (operands[1], 1, 0, TImode);
3100    operands[8] = operand_subword (operands[2], 1, 0, TImode);")
3103 ; adddi3 instruction pattern(s).
3106 (define_insn "*adddi3_sign"
3107   [(set (match_operand:DI 0 "register_operand" "=d,d")
3108         (plus:DI (sign_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3109                  (match_operand:DI 1 "register_operand" "0,0")))
3110    (clobber (reg:CC 33))]
3111   "TARGET_64BIT"
3112   "@
3113    agfr\t%0,%2
3114    agf\t%0,%2"
3115   [(set_attr "op_type"  "RRE,RXY")])
3117 (define_insn "*adddi3_zero_cc"
3118   [(set (reg 33)
3119         (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3120                           (match_operand:DI 1 "register_operand" "0,0"))
3121                  (const_int 0)))
3122    (set (match_operand:DI 0 "register_operand" "=d,d")
3123         (plus:DI (zero_extend:DI (match_dup 2)) (match_dup 1)))]
3124   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3125   "@
3126    algfr\t%0,%2
3127    algf\t%0,%2"
3128   [(set_attr "op_type"  "RRE,RXY")])
3130 (define_insn "*adddi3_zero_cconly"
3131   [(set (reg 33)
3132         (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3133                           (match_operand:DI 1 "register_operand" "0,0"))
3134                  (const_int 0)))
3135    (clobber (match_scratch:DI 0 "=d,d"))]
3136   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3137   "@
3138    algfr\t%0,%2
3139    algf\t%0,%2"
3140   [(set_attr "op_type"  "RRE,RXY")])
3142 (define_insn "*adddi3_zero"
3143   [(set (match_operand:DI 0 "register_operand" "=d,d")
3144         (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3145                  (match_operand:DI 1 "register_operand" "0,0")))
3146    (clobber (reg:CC 33))]
3147   "TARGET_64BIT"
3148   "@
3149    algfr\t%0,%2
3150    algf\t%0,%2"
3151   [(set_attr "op_type"  "RRE,RXY")])
3153 (define_insn "*adddi3_imm_cc"
3154   [(set (reg 33)
3155         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "0")
3156                           (match_operand:DI 2 "const_int_operand" "K"))
3157                  (const_int 0)))
3158    (set (match_operand:DI 0 "register_operand" "=d")
3159         (plus:DI (match_dup 1) (match_dup 2)))]
3160   "TARGET_64BIT
3161    && s390_match_ccmode (insn, CCAmode)
3162    && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'K', \"K\")"
3163   "aghi\t%0,%h2"
3164   [(set_attr "op_type"  "RI")])
3166 (define_insn "*adddi3_carry1_cc"
3167   [(set (reg 33)
3168         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3169                           (match_operand:DI 2 "general_operand" "d,m"))
3170                  (match_dup 1)))
3171    (set (match_operand:DI 0 "register_operand" "=d,d")
3172         (plus:DI (match_dup 1) (match_dup 2)))]
3173   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3174   "@
3175    algr\t%0,%2
3176    alg\t%0,%2"
3177   [(set_attr "op_type"  "RRE,RXY")])
3179 (define_insn "*adddi3_carry1_cconly"
3180   [(set (reg 33)
3181         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3182                           (match_operand:DI 2 "general_operand" "d,m"))
3183                  (match_dup 1)))
3184    (clobber (match_scratch:DI 0 "=d,d"))]
3185   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3186   "@
3187    algr\t%0,%2
3188    alg\t%0,%2"
3189   [(set_attr "op_type"  "RRE,RXY")])
3191 (define_insn "*adddi3_carry2_cc"
3192   [(set (reg 33)
3193         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3194                           (match_operand:DI 2 "general_operand" "d,m"))
3195                  (match_dup 2)))
3196    (set (match_operand:DI 0 "register_operand" "=d,d")
3197         (plus:DI (match_dup 1) (match_dup 2)))]
3198   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3199   "@
3200    algr\t%0,%2
3201    alg\t%0,%2"
3202   [(set_attr "op_type"  "RRE,RXY")])
3204 (define_insn "*adddi3_carry2_cconly"
3205   [(set (reg 33)
3206         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3207                           (match_operand:DI 2 "general_operand" "d,m"))
3208                  (match_dup 2)))
3209    (clobber (match_scratch:DI 0 "=d,d"))]
3210   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3211   "@
3212    algr\t%0,%2
3213    alg\t%0,%2"
3214   [(set_attr "op_type"  "RRE,RXY")])
3216 (define_insn "*adddi3_cc"
3217   [(set (reg 33)
3218         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3219                           (match_operand:DI 2 "general_operand" "d,m"))
3220                  (const_int 0)))
3221    (set (match_operand:DI 0 "register_operand" "=d,d")
3222         (plus:DI (match_dup 1) (match_dup 2)))]
3223   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3224   "@
3225    algr\t%0,%2
3226    alg\t%0,%2"
3227   [(set_attr "op_type"  "RRE,RXY")])
3229 (define_insn "*adddi3_cconly"
3230   [(set (reg 33)
3231         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3232                           (match_operand:DI 2 "general_operand" "d,m"))
3233                  (const_int 0)))
3234    (clobber (match_scratch:DI 0 "=d,d"))]
3235   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3236   "@
3237    algr\t%0,%2
3238    alg\t%0,%2"
3239   [(set_attr "op_type"  "RRE,RXY")])
3241 (define_insn "*adddi3_cconly2"
3242   [(set (reg 33)
3243         (compare (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3244                  (neg:SI (match_operand:DI 2 "general_operand" "d,m"))))
3245    (clobber (match_scratch:DI 0 "=d,d"))]
3246   "s390_match_ccmode(insn, CCLmode) && TARGET_64BIT"
3247   "@
3248    algr\t%0,%2
3249    alg\t%0,%2"
3250   [(set_attr "op_type"  "RRE,RXY")])
3252 (define_insn "*adddi3_64"
3253   [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3254         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0")
3255                  (match_operand:DI 2 "general_operand" "d,K,m") ) )
3256    (clobber (reg:CC 33))]
3257   "TARGET_64BIT"
3258   "@
3259    agr\t%0,%2
3260    aghi\t%0,%h2
3261    ag\t%0,%2"
3262   [(set_attr "op_type"  "RRE,RI,RXY")])
3264 (define_insn_and_split "*adddi3_31z"
3265   [(set (match_operand:DI 0 "register_operand" "=&d")
3266         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
3267                  (match_operand:DI 2 "general_operand" "do") ) )
3268    (clobber (reg:CC 33))]
3269   "!TARGET_64BIT && TARGET_CPU_ZARCH"
3270   "#"
3271   "&& reload_completed"
3272   [(parallel
3273     [(set (reg:CCL1 33)
3274           (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
3275                         (match_dup 7)))
3276      (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
3277    (parallel
3278     [(set (match_dup 3) (plus:SI (plus:SI (match_dup 4) (match_dup 5))
3279                                  (ltu:SI (reg:CCL1 33) (const_int 0))))
3280      (clobber (reg:CC 33))])]
3281   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3282    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3283    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3284    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3285    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3286    operands[8] = operand_subword (operands[2], 1, 0, DImode);")
3288 (define_insn_and_split "*adddi3_31"
3289   [(set (match_operand:DI 0 "register_operand" "=&d")
3290         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
3291                  (match_operand:DI 2 "general_operand" "do") ) )
3292    (clobber (reg:CC 33))]
3293   "!TARGET_CPU_ZARCH"
3294   "#"
3295   "&& reload_completed"
3296   [(parallel
3297     [(set (match_dup 3) (plus:SI (match_dup 4) (match_dup 5)))
3298      (clobber (reg:CC 33))])
3299    (parallel
3300     [(set (reg:CCL1 33)
3301           (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
3302                         (match_dup 7)))
3303      (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
3304    (set (pc)
3305         (if_then_else (ltu (reg:CCL1 33) (const_int 0))
3306                       (pc)
3307                       (label_ref (match_dup 9))))
3308    (parallel
3309     [(set (match_dup 3) (plus:SI (match_dup 3) (const_int 1)))
3310      (clobber (reg:CC 33))])
3311    (match_dup 9)]
3312   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3313    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3314    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3315    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3316    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3317    operands[8] = operand_subword (operands[2], 1, 0, DImode);
3318    operands[9] = gen_label_rtx ();")
3320 (define_expand "adddi3"
3321   [(parallel
3322     [(set (match_operand:DI 0 "register_operand" "")
3323           (plus:DI (match_operand:DI 1 "nonimmediate_operand" "")
3324                    (match_operand:DI 2 "general_operand" "")))
3325      (clobber (reg:CC 33))])]
3326   ""
3327   "")
3330 ; addsi3 instruction pattern(s).
3333 (define_insn "*addsi3_imm_cc"
3334   [(set (reg 33)
3335         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "0")
3336                           (match_operand:SI 2 "const_int_operand" "K"))
3337                  (const_int 0)))
3338    (set (match_operand:SI 0 "register_operand" "=d")
3339         (plus:SI (match_dup 1) (match_dup 2)))]
3340   "s390_match_ccmode (insn, CCAmode)
3341    && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'K', \"K\")"
3342   "ahi\t%0,%h2"
3343   [(set_attr "op_type"  "RI")])
3345 (define_insn "*addsi3_carry1_cc"
3346   [(set (reg 33)
3347         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3348                           (match_operand:SI 2 "general_operand" "d,R,T"))
3349                  (match_dup 1)))
3350    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3351         (plus:SI (match_dup 1) (match_dup 2)))]
3352   "s390_match_ccmode (insn, CCL1mode)"
3353   "@
3354    alr\t%0,%2
3355    al\t%0,%2
3356    aly\t%0,%2"
3357   [(set_attr "op_type"  "RR,RX,RXY")])
3359 (define_insn "*addsi3_carry1_cconly"
3360   [(set (reg 33)
3361         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3362                           (match_operand:SI 2 "general_operand" "d,R,T"))
3363                  (match_dup 1)))
3364    (clobber (match_scratch:SI 0 "=d,d,d"))]
3365   "s390_match_ccmode (insn, CCL1mode)"
3366   "@
3367    alr\t%0,%2
3368    al\t%0,%2
3369    aly\t%0,%2"
3370   [(set_attr "op_type"  "RR,RX,RXY")])
3372 (define_insn "*addsi3_carry2_cc"
3373   [(set (reg 33)
3374         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3375                           (match_operand:SI 2 "general_operand" "d,R,T"))
3376                  (match_dup 2)))
3377    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3378         (plus:SI (match_dup 1) (match_dup 2)))]
3379   "s390_match_ccmode (insn, CCL1mode)"
3380   "@
3381    alr\t%0,%2
3382    al\t%0,%2
3383    aly\t%0,%2"
3384   [(set_attr "op_type"  "RR,RX,RXY")])
3386 (define_insn "*addsi3_carry2_cconly"
3387   [(set (reg 33)
3388         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3389                           (match_operand:SI 2 "general_operand" "d,R,T"))
3390                  (match_dup 2)))
3391    (clobber (match_scratch:SI 0 "=d,d,d"))]
3392   "s390_match_ccmode (insn, CCL1mode)"
3393   "@
3394    alr\t%0,%2
3395    al\t%0,%2
3396    aly\t%0,%2"
3397   [(set_attr "op_type"  "RR,RX,RXY")])
3399 (define_insn "*addsi3_cc"
3400   [(set (reg 33)
3401         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3402                           (match_operand:SI 2 "general_operand" "d,R,T"))
3403                  (const_int 0)))
3404    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3405         (plus:SI (match_dup 1) (match_dup 2)))]
3406   "s390_match_ccmode (insn, CCLmode)"
3407   "@
3408    alr\t%0,%2
3409    al\t%0,%2
3410    aly\t%0,%2"
3411   [(set_attr "op_type"  "RR,RX,RXY")])
3413 (define_insn "*addsi3_cconly"
3414   [(set (reg 33)
3415         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3416                           (match_operand:SI 2 "general_operand" "d,R,T"))
3417                  (const_int 0)))
3418    (clobber (match_scratch:SI 0 "=d,d,d"))]
3419   "s390_match_ccmode (insn, CCLmode)"
3420   "@
3421    alr\t%0,%2
3422    al\t%0,%2
3423    aly\t%0,%2"
3424   [(set_attr "op_type"  "RR,RX,RXY")])
3426 (define_insn "*addsi3_cconly2"
3427   [(set (reg 33)
3428         (compare (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3429                  (neg:SI (match_operand:SI 2 "general_operand" "d,R,T"))))
3430    (clobber (match_scratch:SI 0 "=d,d,d"))]
3431   "s390_match_ccmode (insn, CCLmode)"
3432   "@
3433    alr\t%0,%2
3434    al\t%0,%2
3435    aly\t%0,%2"
3436   [(set_attr "op_type"  "RR,RX,RXY")])
3438 (define_insn "*addsi3_sign"
3439   [(set (match_operand:SI 0 "register_operand" "=d,d")
3440         (plus:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))
3441                  (match_operand:SI 1 "register_operand" "0,0")))
3442    (clobber (reg:CC 33))]
3443   ""
3444   "@
3445    ah\t%0,%2
3446    ahy\t%0,%2"
3447   [(set_attr "op_type"  "RX,RXY")])
3449 (define_insn "addsi3"
3450   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
3451         (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
3452                  (match_operand:SI 2 "general_operand" "d,K,R,T")))
3453    (clobber (reg:CC 33))]
3454   ""
3455   "@
3456    ar\t%0,%2
3457    ahi\t%0,%h2
3458    a\t%0,%2
3459    ay\t%0,%2"
3460   [(set_attr "op_type"  "RR,RI,RX,RXY")])
3463 ; add(df|sf)3 instruction pattern(s).
3466 (define_expand "add<mode>3"
3467   [(parallel
3468     [(set (match_operand:FPR 0 "register_operand" "=f,f")
3469           (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3470                     (match_operand:FPR 2 "general_operand" "f,R")))
3471      (clobber (reg:CC 33))])]
3472   "TARGET_HARD_FLOAT"
3473   "")
3475 (define_insn "*add<mode>3"
3476   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3477         (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3478                   (match_operand:FPR 2 "general_operand" "f,R")))
3479    (clobber (reg:CC 33))]
3480   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3481   "@
3482    a<de>br\t%0,%2
3483    a<de>b\t%0,%2"
3484   [(set_attr "op_type"  "RRE,RXE")
3485    (set_attr "type"     "fsimp<mode>")])
3487 (define_insn "*add<mode>3_cc"
3488   [(set (reg 33)
3489         (compare (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3490                            (match_operand:FPR 2 "general_operand" "f,R"))
3491                  (match_operand:FPR 3 "const0_operand" "")))
3492    (set (match_operand:FPR 0 "register_operand" "=f,f")
3493         (plus:FPR (match_dup 1) (match_dup 2)))]
3494   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3495   "@
3496    a<de>br\t%0,%2
3497    a<de>b\t%0,%2"
3498   [(set_attr "op_type"  "RRE,RXE")
3499    (set_attr "type"     "fsimp<mode>")])
3501 (define_insn "*add<mode>3_cconly"
3502   [(set (reg 33)
3503         (compare (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3504                            (match_operand:FPR 2 "general_operand" "f,R"))
3505                  (match_operand:FPR 3 "const0_operand" "")))
3506    (clobber (match_scratch:FPR 0 "=f,f"))]
3507   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3508   "@
3509    a<de>br\t%0,%2
3510    a<de>b\t%0,%2"
3511   [(set_attr "op_type"  "RRE,RXE")
3512    (set_attr "type"     "fsimp<mode>")])
3514 (define_insn "*add<mode>3_ibm"
3515   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3516         (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3517                   (match_operand:FPR 2 "general_operand" "f,R")))
3518    (clobber (reg:CC 33))]
3519   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3520   "@
3521    a<de>r\t%0,%2
3522    a<de>\t%0,%2"
3523   [(set_attr "op_type"  "RR,RX")
3524    (set_attr "type"     "fsimp<mode>")])
3528 ;;- Subtract instructions.
3532 ; subti3 instruction pattern(s).
3535 (define_insn_and_split "subti3"
3536   [(set (match_operand:TI 0 "register_operand" "=&d")
3537         (minus:TI (match_operand:TI 1 "register_operand" "0")
3538                   (match_operand:TI 2 "general_operand" "do") ) )
3539    (clobber (reg:CC 33))]
3540   "TARGET_64BIT"
3541   "#"
3542   "&& reload_completed"
3543   [(parallel
3544     [(set (reg:CCL2 33)
3545           (compare:CCL2 (minus:DI (match_dup 7) (match_dup 8))
3546                         (match_dup 7)))
3547      (set (match_dup 6) (minus:DI (match_dup 7) (match_dup 8)))])
3548    (parallel
3549     [(set (match_dup 3) (minus:DI (minus:DI (match_dup 4) (match_dup 5))
3550                                   (gtu:DI (reg:CCL2 33) (const_int 0))))
3551      (clobber (reg:CC 33))])]
3552   "operands[3] = operand_subword (operands[0], 0, 0, TImode);
3553    operands[4] = operand_subword (operands[1], 0, 0, TImode);
3554    operands[5] = operand_subword (operands[2], 0, 0, TImode);
3555    operands[6] = operand_subword (operands[0], 1, 0, TImode);
3556    operands[7] = operand_subword (operands[1], 1, 0, TImode);
3557    operands[8] = operand_subword (operands[2], 1, 0, TImode);")
3560 ; subdi3 instruction pattern(s).
3563 (define_insn "*subdi3_sign"
3564   [(set (match_operand:DI 0 "register_operand" "=d,d")
3565         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3566                   (sign_extend:DI (match_operand:SI 2 "general_operand" "d,m"))))
3567    (clobber (reg:CC 33))]
3568   "TARGET_64BIT"
3569   "@
3570    sgfr\t%0,%2
3571    sgf\t%0,%2"
3572   [(set_attr "op_type"  "RRE,RXY")])
3574 (define_insn "*subdi3_zero_cc"
3575   [(set (reg 33)
3576         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3577                            (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m")))
3578                  (const_int 0)))
3579    (set (match_operand:DI 0 "register_operand" "=d,d")
3580         (minus:DI (match_dup 1) (zero_extend:DI (match_dup 2))))]
3581   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3582   "@
3583    slgfr\t%0,%2
3584    slgf\t%0,%2"
3585   [(set_attr "op_type"  "RRE,RXY")])
3587 (define_insn "*subdi3_zero_cconly"
3588   [(set (reg 33)
3589         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3590                            (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m")))
3591                  (const_int 0)))
3592    (clobber (match_scratch:DI 0 "=d,d"))]
3593   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3594   "@
3595    slgfr\t%0,%2
3596    slgf\t%0,%2"
3597   [(set_attr "op_type"  "RRE,RXY")])
3599 (define_insn "*subdi3_zero"
3600   [(set (match_operand:DI 0 "register_operand" "=d,d")
3601         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3602                   (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))))
3603    (clobber (reg:CC 33))]
3604   "TARGET_64BIT"
3605   "@
3606    slgfr\t%0,%2
3607    slgf\t%0,%2"
3608   [(set_attr "op_type"  "RRE,RXY")])
3610 (define_insn "*subdi3_borrow_cc"
3611   [(set (reg 33)
3612         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3613                            (match_operand:DI 2 "general_operand" "d,m"))
3614                  (match_dup 1)))
3615    (set (match_operand:DI 0 "register_operand" "=d,d")
3616         (minus:DI (match_dup 1) (match_dup 2)))]
3617   "s390_match_ccmode (insn, CCL2mode) && TARGET_64BIT"
3618   "@
3619    slgr\t%0,%2
3620    slg\t%0,%2"
3621   [(set_attr "op_type"  "RRE,RXY")])
3623 (define_insn "*subdi3_borrow_cconly"
3624   [(set (reg 33)
3625         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3626                            (match_operand:DI 2 "general_operand" "d,m"))
3627                  (match_dup 1)))
3628    (clobber (match_scratch:DI 0 "=d,d"))]
3629   "s390_match_ccmode (insn, CCL2mode) && TARGET_64BIT"
3630   "@
3631    slgr\t%0,%2
3632    slg\t%0,%2"
3633   [(set_attr "op_type"  "RRE,RXY")])
3635 (define_insn "*subdi3_cc"
3636   [(set (reg 33)
3637         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3638                            (match_operand:DI 2 "general_operand" "d,m"))
3639                  (const_int 0)))
3640    (set (match_operand:DI 0 "register_operand" "=d,d")
3641         (minus:DI (match_dup 1) (match_dup 2)))]
3642   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3643   "@
3644    slgr\t%0,%2
3645    slg\t%0,%2"
3646   [(set_attr "op_type"  "RRE,RXY")])
3648 (define_insn "*subdi3_cc2"
3649   [(set (reg 33)
3650         (compare (match_operand:DI 1 "register_operand" "0,0")
3651                  (match_operand:DI 2 "general_operand" "d,m")))
3652    (set (match_operand:DI 0 "register_operand" "=d,d")
3653         (minus:DI (match_dup 1) (match_dup 2)))]
3654   "s390_match_ccmode (insn, CCL3mode) && TARGET_64BIT"
3655   "@
3656    slgr\t%0,%2
3657    slg\t%0,%2"
3658   [(set_attr "op_type"  "RRE,RXY")])
3660 (define_insn "*subdi3_cconly"
3661   [(set (reg 33)
3662         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3663                            (match_operand:DI 2 "general_operand" "d,m"))
3664                  (const_int 0)))
3665    (clobber (match_scratch:DI 0 "=d,d"))]
3666   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3667   "@
3668    slgr\t%0,%2
3669    slg\t%0,%2"
3670   [(set_attr "op_type"  "RRE,RXY")])
3672 (define_insn "*subdi3_cconly2"
3673   [(set (reg 33)
3674         (compare (match_operand:DI 1 "register_operand" "0,0")
3675                  (match_operand:DI 2 "general_operand" "d,m")))
3676    (clobber (match_scratch:DI 0 "=d,d"))]
3677   "s390_match_ccmode (insn, CCL3mode) && TARGET_64BIT"
3678   "@
3679    slgr\t%0,%2
3680    slg\t%0,%2"
3681   [(set_attr "op_type"  "RRE,RXY")])
3683 (define_insn "*subdi3_64"
3684   [(set (match_operand:DI 0 "register_operand" "=d,d")
3685         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3686                   (match_operand:DI 2 "general_operand" "d,m") ) )
3687    (clobber (reg:CC 33))]
3688   "TARGET_64BIT"
3689   "@
3690    sgr\t%0,%2
3691    sg\t%0,%2"
3692   [(set_attr "op_type"  "RRE,RRE")])
3694 (define_insn_and_split "*subdi3_31z"
3695   [(set (match_operand:DI 0 "register_operand" "=&d")
3696         (minus:DI (match_operand:DI 1 "register_operand" "0")
3697                   (match_operand:DI 2 "general_operand" "do") ) )
3698    (clobber (reg:CC 33))]
3699   "!TARGET_64BIT && TARGET_CPU_ZARCH"
3700   "#"
3701   "&& reload_completed"
3702   [(parallel
3703     [(set (reg:CCL2 33)
3704           (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
3705                         (match_dup 7)))
3706      (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
3707    (parallel
3708     [(set (match_dup 3) (minus:SI (minus:SI (match_dup 4) (match_dup 5))
3709                                   (gtu:SI (reg:CCL2 33) (const_int 0))))
3710      (clobber (reg:CC 33))])]
3711   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3712    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3713    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3714    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3715    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3716    operands[8] = operand_subword (operands[2], 1, 0, DImode);")
3718 (define_insn_and_split "*subdi3_31"
3719   [(set (match_operand:DI 0 "register_operand" "=&d")
3720         (minus:DI (match_operand:DI 1 "register_operand" "0")
3721                   (match_operand:DI 2 "general_operand" "do") ) )
3722    (clobber (reg:CC 33))]
3723   "!TARGET_CPU_ZARCH"
3724   "#"
3725   "&& reload_completed"
3726   [(parallel
3727     [(set (match_dup 3) (minus:SI (match_dup 4) (match_dup 5)))
3728      (clobber (reg:CC 33))])
3729    (parallel
3730     [(set (reg:CCL2 33)
3731           (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
3732                         (match_dup 7)))
3733      (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
3734    (set (pc)
3735         (if_then_else (gtu (reg:CCL2 33) (const_int 0))
3736                       (pc)
3737                       (label_ref (match_dup 9))))
3738    (parallel
3739     [(set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))
3740      (clobber (reg:CC 33))])
3741    (match_dup 9)]
3742   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3743    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3744    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3745    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3746    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3747    operands[8] = operand_subword (operands[2], 1, 0, DImode);
3748    operands[9] = gen_label_rtx ();")
3750 (define_expand "subdi3"
3751   [(parallel
3752     [(set (match_operand:DI 0 "register_operand" "")
3753           (minus:DI (match_operand:DI 1 "register_operand" "")
3754                     (match_operand:DI 2 "general_operand" "")))
3755      (clobber (reg:CC 33))])]
3756   ""
3757   "")
3760 ; subsi3 instruction pattern(s).
3763 (define_insn "*subsi3_borrow_cc"
3764   [(set (reg 33)
3765         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3766                            (match_operand:SI 2 "general_operand" "d,R,T"))
3767                  (match_dup 1)))
3768    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3769         (minus:SI (match_dup 1) (match_dup 2)))]
3770   "s390_match_ccmode (insn, CCL2mode)"
3771   "@
3772    slr\t%0,%2
3773    sl\t%0,%2
3774    sly\t%0,%2"
3775   [(set_attr "op_type"  "RR,RX,RXY")])
3777 (define_insn "*subsi3_borrow_cconly"
3778   [(set (reg 33)
3779         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3780                            (match_operand:SI 2 "general_operand" "d,R,T"))
3781                  (match_dup 1)))
3782    (clobber (match_scratch:SI 0 "=d,d,d"))]
3783   "s390_match_ccmode (insn, CCL2mode)"
3784   "@
3785    slr\t%0,%2
3786    sl\t%0,%2
3787    sly\t%0,%2"
3788   [(set_attr "op_type"  "RR,RX,RXY")])
3790 (define_insn "*subsi3_cc"
3791   [(set (reg 33)
3792         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3793                            (match_operand:SI 2 "general_operand" "d,R,T"))
3794                  (const_int 0)))
3795    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3796         (minus:SI (match_dup 1) (match_dup 2)))]
3797   "s390_match_ccmode (insn, CCLmode)"
3798   "@
3799    slr\t%0,%2
3800    sl\t%0,%2
3801    sly\t%0,%2"
3802   [(set_attr "op_type"  "RR,RX,RXY")])
3804 (define_insn "*subsi3_cc2"
3805   [(set (reg 33)
3806         (compare (match_operand:SI 1 "register_operand" "0,0,0")
3807                  (match_operand:SI 2 "general_operand" "d,R,T")))
3808    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3809         (minus:SI (match_dup 1) (match_dup 2)))]
3810   "s390_match_ccmode (insn, CCL3mode)"
3811   "@
3812    slr\t%0,%2
3813    sl\t%0,%2
3814    sly\t%0,%2"
3815   [(set_attr "op_type"  "RR,RX,RXY")])
3817 (define_insn "*subsi3_cconly"
3818   [(set (reg 33)
3819         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3820                            (match_operand:SI 2 "general_operand" "d,R,T"))
3821                  (const_int 0)))
3822    (clobber (match_scratch:SI 0 "=d,d,d"))]
3823   "s390_match_ccmode (insn, CCLmode)"
3824   "@
3825    slr\t%0,%2
3826    sl\t%0,%2
3827    sly\t%0,%2"
3828   [(set_attr "op_type"  "RR,RX,RXY")])
3830 (define_insn "*subsi3_cconly2"
3831   [(set (reg 33)
3832         (compare (match_operand:SI 1 "register_operand" "0,0,0")
3833                  (match_operand:SI 2 "general_operand" "d,R,T")))
3834    (clobber (match_scratch:SI 0 "=d,d,d"))]
3835   "s390_match_ccmode (insn, CCL3mode)"
3836   "@
3837    slr\t%0,%2
3838    sl\t%0,%2
3839    sly\t%0,%2"
3840   [(set_attr "op_type"  "RR,RX,RXY")])
3842 (define_insn "*subsi3_sign"
3843   [(set (match_operand:SI 0 "register_operand" "=d,d")
3844         (minus:SI (match_operand:SI 1 "register_operand" "0,0")
3845                   (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))))
3846    (clobber (reg:CC 33))]
3847   ""
3848   "@
3849    sh\t%0,%2
3850    shy\t%0,%2"
3851   [(set_attr "op_type"  "RX,RXY")])
3853 (define_insn "subsi3"
3854   [(set (match_operand:SI 0 "register_operand" "=d,d,d")
3855         (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3856                   (match_operand:SI 2 "general_operand" "d,R,T")))
3857    (clobber (reg:CC 33))]
3858   ""
3859   "@
3860    sr\t%0,%2
3861    s\t%0,%2
3862    sy\t%0,%2"
3863   [(set_attr "op_type"  "RR,RX,RXY")])
3867 ; sub(df|sf)3 instruction pattern(s).
3870 (define_expand "sub<mode>3"
3871   [(parallel
3872     [(set (match_operand:FPR 0 "register_operand" "=f,f")
3873           (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3874                      (match_operand:FPR 2 "general_operand" "f,R")))
3875      (clobber (reg:CC 33))])]
3876   "TARGET_HARD_FLOAT"
3877   "")
3879 (define_insn "*sub<mode>3"
3880   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3881         (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3882                    (match_operand:FPR 2 "general_operand" "f,R")))
3883    (clobber (reg:CC 33))]
3884   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3885   "@
3886    s<de>br\t%0,%2
3887    s<de>b\t%0,%2"
3888   [(set_attr "op_type"  "RRE,RXE")
3889    (set_attr "type"     "fsimp<mode>")])
3891 (define_insn "*sub<mode>3_cc"
3892   [(set (reg 33)
3893         (compare (minus:FPR (match_operand:FPR 1 "nonimmediate_operand" "0,0")
3894                             (match_operand:FPR 2 "general_operand" "f,R"))
3895                  (match_operand:FPR 3 "const0_operand" "")))
3896    (set (match_operand:FPR 0 "register_operand" "=f,f")
3897         (minus:FPR (match_dup 1) (match_dup 2)))]
3898   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3899   "@
3900    s<de>br\t%0,%2
3901    s<de>b\t%0,%2"
3902   [(set_attr "op_type"  "RRE,RXE")
3903    (set_attr "type"     "fsimp<mode>")])
3905 (define_insn "*sub<mode>3_cconly"
3906   [(set (reg 33)
3907         (compare (minus:FPR (match_operand:FPR 1 "nonimmediate_operand" "0,0")
3908                             (match_operand:FPR 2 "general_operand" "f,R"))
3909                  (match_operand:FPR 3 "const0_operand" "")))
3910    (clobber (match_scratch:FPR 0 "=f,f"))]
3911   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3912   "@
3913    s<de>br\t%0,%2
3914    s<de>b\t%0,%2"
3915   [(set_attr "op_type"  "RRE,RXE")
3916    (set_attr "type"     "fsimp<mode>")])
3918 (define_insn "*sub<mode>3_ibm"
3919   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3920         (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3921                    (match_operand:FPR 2 "general_operand" "f,R")))
3922    (clobber (reg:CC 33))]
3923   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3924   "@
3925    s<de>r\t%0,%2
3926    s<de>\t%0,%2"
3927   [(set_attr "op_type"  "RR,RX")
3928    (set_attr "type"     "fsimp<mode>")])
3932 ;;- Conditional add/subtract instructions.
3936 ; add(di|si)cc instruction pattern(s).
3939 (define_insn "*add<mode>3_alc_cc"
3940   [(set (reg 33)
3941         (compare
3942           (plus:GPR (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,0")
3943                               (match_operand:GPR 2 "general_operand" "d,m"))
3944                     (match_operand:GPR 3 "s390_alc_comparison" ""))
3945           (const_int 0)))
3946    (set (match_operand:GPR 0 "register_operand" "=d,d")
3947         (plus:GPR (plus:GPR (match_dup 1) (match_dup 2)) (match_dup 3)))]
3948   "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
3949   "@
3950    alc<g>r\t%0,%2
3951    alc<g>\t%0,%2"
3952   [(set_attr "op_type"  "RRE,RXY")])
3954 (define_insn "*add<mode>3_alc"
3955   [(set (match_operand:GPR 0 "register_operand" "=d,d")
3956         (plus:GPR (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,0")
3957                             (match_operand:GPR 2 "general_operand" "d,m"))
3958                   (match_operand:GPR 3 "s390_alc_comparison" "")))
3959    (clobber (reg:CC 33))]
3960   "TARGET_CPU_ZARCH"
3961   "@
3962    alc<g>r\t%0,%2
3963    alc<g>\t%0,%2"
3964   [(set_attr "op_type"  "RRE,RXY")])
3966 (define_insn "*sub<mode>3_slb_cc"
3967   [(set (reg 33)
3968         (compare
3969           (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
3970                                 (match_operand:GPR 2 "general_operand" "d,m"))
3971                      (match_operand:GPR 3 "s390_slb_comparison" ""))
3972           (const_int 0)))
3973    (set (match_operand:GPR 0 "register_operand" "=d,d")
3974         (minus:GPR (minus:GPR (match_dup 1) (match_dup 2)) (match_dup 3)))]
3975   "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
3976   "@
3977    slb<g>r\t%0,%2
3978    slb<g>\t%0,%2"
3979   [(set_attr "op_type"  "RRE,RXY")])
3981 (define_insn "*sub<mode>3_slb"
3982   [(set (match_operand:GPR 0 "register_operand" "=d,d")
3983         (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
3984                               (match_operand:GPR 2 "general_operand" "d,m"))
3985                    (match_operand:GPR 3 "s390_slb_comparison" "")))
3986    (clobber (reg:CC 33))]
3987   "TARGET_CPU_ZARCH"
3988   "@
3989    slb<g>r\t%0,%2
3990    slb<g>\t%0,%2"
3991   [(set_attr "op_type"  "RRE,RXY")])
3993 (define_expand "add<mode>cc"
3994   [(match_operand:GPR 0 "register_operand" "")
3995    (match_operand 1 "comparison_operator" "")
3996    (match_operand:GPR 2 "register_operand" "")
3997    (match_operand:GPR 3 "const_int_operand" "")]
3998   "TARGET_CPU_ZARCH"
3999   "if (!s390_expand_addcc (GET_CODE (operands[1]), 
4000                            s390_compare_op0, s390_compare_op1, 
4001                            operands[0], operands[2], 
4002                            operands[3])) FAIL; DONE;")
4005 ; scond instruction pattern(s).
4008 (define_insn_and_split "*scond<mode>"
4009   [(set (match_operand:GPR 0 "register_operand" "=&d")
4010         (match_operand:GPR 1 "s390_alc_comparison" ""))
4011    (clobber (reg:CC 33))]
4012   "TARGET_CPU_ZARCH"
4013   "#"
4014   "&& reload_completed"
4015   [(set (match_dup 0) (const_int 0))
4016    (parallel
4017     [(set (match_dup 0) (plus:GPR (plus:GPR (match_dup 0) (match_dup 0))
4018                                   (match_dup 1)))
4019      (clobber (reg:CC 33))])]
4020   "")
4022 (define_insn_and_split "*scond<mode>_neg"
4023   [(set (match_operand:GPR 0 "register_operand" "=&d")
4024         (match_operand:GPR 1 "s390_slb_comparison" ""))
4025    (clobber (reg:CC 33))]
4026   "TARGET_CPU_ZARCH"
4027   "#"
4028   "&& reload_completed"
4029   [(set (match_dup 0) (const_int 0))
4030    (parallel
4031     [(set (match_dup 0) (minus:GPR (minus:GPR (match_dup 0) (match_dup 0))
4032                                    (match_dup 1)))
4033      (clobber (reg:CC 33))])
4034    (parallel
4035     [(set (match_dup 0) (neg:GPR (match_dup 0)))
4036      (clobber (reg:CC 33))])]
4037   "")
4040 (define_expand "s<code>"
4041   [(set (match_operand:SI 0 "register_operand" "")
4042         (SCOND (match_dup 0)
4043                (match_dup 0)))]
4044   "TARGET_CPU_ZARCH"
4045   "if (!s390_expand_addcc (<CODE>, s390_compare_op0, s390_compare_op1,
4046                            operands[0], const0_rtx, const1_rtx)) FAIL; DONE;")
4050 ;;- Multiply instructions.
4054 ; muldi3 instruction pattern(s).
4057 (define_insn "*muldi3_sign"
4058   [(set (match_operand:DI 0 "register_operand" "=d,d")
4059         (mult:DI (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "d,m"))
4060                  (match_operand:DI 1 "register_operand" "0,0")))]
4061   "TARGET_64BIT"
4062   "@
4063    msgfr\t%0,%2
4064    msgf\t%0,%2"
4065   [(set_attr "op_type"  "RRE,RXY")
4066    (set_attr "type"     "imuldi")])
4068 (define_insn "muldi3"
4069   [(set (match_operand:DI 0 "register_operand" "=d,d,d")
4070         (mult:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0")
4071                  (match_operand:DI 2 "general_operand" "d,K,m")))]
4072   "TARGET_64BIT"
4073   "@
4074    msgr\t%0,%2
4075    mghi\t%0,%h2
4076    msg\t%0,%2"
4077   [(set_attr "op_type"  "RRE,RI,RXY")
4078    (set_attr "type"     "imuldi")])
4081 ; mulsi3 instruction pattern(s).
4084 (define_insn "*mulsi3_sign"
4085   [(set (match_operand:SI 0 "register_operand" "=d")
4086         (mult:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R"))
4087                  (match_operand:SI 1 "register_operand" "0")))]
4088   ""
4089   "mh\t%0,%2"
4090   [(set_attr "op_type"  "RX")
4091    (set_attr "type"     "imulhi")])
4093 (define_insn "mulsi3"
4094   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
4095         (mult:SI  (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
4096                   (match_operand:SI 2 "general_operand" "d,K,R,T")))]
4097   ""
4098   "@
4099    msr\t%0,%2
4100    mhi\t%0,%h2
4101    ms\t%0,%2
4102    msy\t%0,%2"
4103   [(set_attr "op_type"  "RRE,RI,RX,RXY")
4104    (set_attr "type"     "imulsi,imulhi,imulsi,imulsi")])
4107 ; mulsidi3 instruction pattern(s).
4110 (define_insn "mulsidi3"
4111   [(set (match_operand:DI 0 "register_operand" "=d,d")
4112         (mult:DI (sign_extend:DI
4113                    (match_operand:SI 1 "register_operand" "%0,0"))
4114                  (sign_extend:DI
4115                    (match_operand:SI 2 "nonimmediate_operand" "d,R"))))]
4116   "!TARGET_64BIT"
4117   "@
4118    mr\t%0,%2
4119    m\t%0,%2"
4120   [(set_attr "op_type"  "RR,RX")
4121    (set_attr "type"     "imulsi")])
4124 ; umulsidi3 instruction pattern(s).
4127 (define_insn "umulsidi3"
4128   [(set (match_operand:DI 0 "register_operand" "=d,d")
4129         (mult:DI (zero_extend:DI
4130                    (match_operand:SI 1 "register_operand" "%0,0"))
4131                  (zero_extend:DI
4132                    (match_operand:SI 2 "nonimmediate_operand" "d,m"))))]
4133   "!TARGET_64BIT && TARGET_CPU_ZARCH"
4134   "@
4135    mlr\t%0,%2
4136    ml\t%0,%2"
4137   [(set_attr "op_type"  "RRE,RXY")
4138    (set_attr "type"     "imulsi")])
4141 ; mul(df|sf)3 instruction pattern(s).
4144 (define_expand "mul<mode>3"
4145   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4146         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4147                   (match_operand:FPR 2 "general_operand" "f,R")))]
4148   "TARGET_HARD_FLOAT"
4149   "")
4151 (define_insn "*mul<mode>3"
4152   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4153         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4154                   (match_operand:FPR 2 "general_operand" "f,R")))]
4155   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
4156   "@
4157    m<dee>br\t%0,%2
4158    m<dee>b\t%0,%2"
4159   [(set_attr "op_type"  "RRE,RXE")
4160    (set_attr "type"     "fmul<mode>")])
4162 (define_insn "*mul<mode>3_ibm"
4163   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4164         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4165                   (match_operand:FPR 2 "general_operand" "f,R")))]
4166   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
4167   "@
4168    m<de>r\t%0,%2
4169    m<de>\t%0,%2"
4170   [(set_attr "op_type"  "RR,RX")
4171    (set_attr "type"     "fmul<mode>")])
4173 (define_insn "*fmadd<mode>"
4174   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4175         (plus:FPR (mult:FPR (match_operand:FPR 1 "register_operand" "%f,f")
4176                            (match_operand:FPR 2 "nonimmediate_operand"  "f,R"))
4177                  (match_operand:FPR 3 "register_operand" "0,0")))]
4178   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT && TARGET_FUSED_MADD"
4179   "@
4180    ma<de>br\t%0,%1,%2
4181    ma<de>b\t%0,%1,%2"
4182   [(set_attr "op_type"  "RRE,RXE")
4183    (set_attr "type"     "fmul<mode>")])
4185 (define_insn "*fmsub<mode>"
4186   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4187         (minus:FPR (mult:FPR (match_operand:FPR 1 "register_operand" "f,f")
4188                             (match_operand:FPR 2 "nonimmediate_operand"  "f,R"))
4189                  (match_operand:FPR 3 "register_operand" "0,0")))]
4190   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT && TARGET_FUSED_MADD"
4191   "@
4192    ms<de>br\t%0,%1,%2
4193    ms<de>b\t%0,%1,%2"
4194   [(set_attr "op_type"  "RRE,RXE")
4195    (set_attr "type"     "fmul<mode>")])
4198 ;;- Divide and modulo instructions.
4202 ; divmoddi4 instruction pattern(s).
4205 (define_expand "divmoddi4"
4206   [(parallel [(set (match_operand:DI 0 "general_operand" "")
4207                    (div:DI (match_operand:DI 1 "register_operand" "")
4208                            (match_operand:DI 2 "general_operand" "")))
4209               (set (match_operand:DI 3 "general_operand" "")
4210                    (mod:DI (match_dup 1) (match_dup 2)))])
4211    (clobber (match_dup 4))]
4212   "TARGET_64BIT"
4214   rtx insn, div_equal, mod_equal;
4216   div_equal = gen_rtx_DIV (DImode, operands[1], operands[2]);
4217   mod_equal = gen_rtx_MOD (DImode, operands[1], operands[2]);
4219   operands[4] = gen_reg_rtx(TImode);
4220   emit_insn (gen_divmodtidi3 (operands[4], operands[1], operands[2]));
4222   insn = emit_move_insn (operands[0], gen_lowpart (DImode, operands[4]));
4223   REG_NOTES (insn) =
4224         gen_rtx_EXPR_LIST (REG_EQUAL, div_equal, REG_NOTES (insn));
4226   insn = emit_move_insn (operands[3], gen_highpart (DImode, operands[4]));
4227   REG_NOTES (insn) =
4228         gen_rtx_EXPR_LIST (REG_EQUAL, mod_equal, REG_NOTES (insn));
4230   DONE;
4233 (define_insn "divmodtidi3"
4234   [(set (match_operand:TI 0 "register_operand" "=d,d")
4235         (ior:TI
4236           (ashift:TI
4237             (zero_extend:TI
4238               (mod:DI (match_operand:DI 1 "register_operand" "0,0")
4239                       (match_operand:DI 2 "general_operand" "d,m")))
4240             (const_int 64))
4241           (zero_extend:TI (div:DI (match_dup 1) (match_dup 2)))))]
4242   "TARGET_64BIT"
4243   "@
4244    dsgr\t%0,%2
4245    dsg\t%0,%2"
4246   [(set_attr "op_type"  "RRE,RXY")
4247    (set_attr "type"     "idiv")])
4249 (define_insn "divmodtisi3"
4250   [(set (match_operand:TI 0 "register_operand" "=d,d")
4251         (ior:TI
4252           (ashift:TI
4253             (zero_extend:TI
4254               (mod:DI (match_operand:DI 1 "register_operand" "0,0")
4255                       (sign_extend:DI
4256                         (match_operand:SI 2 "nonimmediate_operand" "d,m"))))
4257             (const_int 64))
4258           (zero_extend:TI
4259             (div:DI (match_dup 1) (sign_extend:DI (match_dup 2))))))]
4260   "TARGET_64BIT"
4261   "@
4262    dsgfr\t%0,%2
4263    dsgf\t%0,%2"
4264   [(set_attr "op_type"  "RRE,RXY")
4265    (set_attr "type"     "idiv")])
4268 ; udivmoddi4 instruction pattern(s).
4271 (define_expand "udivmoddi4"
4272   [(parallel [(set (match_operand:DI 0 "general_operand" "")
4273                    (udiv:DI (match_operand:DI 1 "general_operand" "")
4274                             (match_operand:DI 2 "nonimmediate_operand" "")))
4275               (set (match_operand:DI 3 "general_operand" "")
4276                    (umod:DI (match_dup 1) (match_dup 2)))])
4277    (clobber (match_dup 4))]
4278   "TARGET_64BIT"
4280   rtx insn, div_equal, mod_equal, equal;
4282   div_equal = gen_rtx_UDIV (DImode, operands[1], operands[2]);
4283   mod_equal = gen_rtx_UMOD (DImode, operands[1], operands[2]);
4284   equal = gen_rtx_IOR (TImode,
4285                        gen_rtx_ASHIFT (TImode,
4286                                        gen_rtx_ZERO_EXTEND (TImode, mod_equal),
4287                                        GEN_INT (64)),
4288                        gen_rtx_ZERO_EXTEND (TImode, div_equal));
4290   operands[4] = gen_reg_rtx(TImode);
4291   emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[4]));
4292   emit_move_insn (gen_lowpart (DImode, operands[4]), operands[1]);
4293   emit_move_insn (gen_highpart (DImode, operands[4]), const0_rtx);
4294   insn = emit_insn (gen_udivmodtidi3 (operands[4], operands[4], operands[2]));
4295   REG_NOTES (insn) =
4296         gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4298   insn = emit_move_insn (operands[0], gen_lowpart (DImode, operands[4]));
4299   REG_NOTES (insn) =
4300         gen_rtx_EXPR_LIST (REG_EQUAL, div_equal, REG_NOTES (insn));
4302   insn = emit_move_insn (operands[3], gen_highpart (DImode, operands[4]));
4303   REG_NOTES (insn) =
4304         gen_rtx_EXPR_LIST (REG_EQUAL, mod_equal, REG_NOTES (insn));
4306   DONE;
4309 (define_insn "udivmodtidi3"
4310   [(set (match_operand:TI 0 "register_operand" "=d,d")
4311         (ior:TI
4312           (ashift:TI
4313             (zero_extend:TI
4314               (truncate:DI
4315                 (umod:TI (match_operand:TI 1 "register_operand" "0,0")
4316                          (zero_extend:TI
4317                            (match_operand:DI 2 "nonimmediate_operand" "d,m")))))
4318             (const_int 64))
4319           (zero_extend:TI
4320             (truncate:DI
4321               (udiv:TI (match_dup 1) (zero_extend:TI (match_dup 2)))))))]
4322   "TARGET_64BIT"
4323   "@
4324    dlgr\t%0,%2
4325    dlg\t%0,%2"
4326   [(set_attr "op_type"  "RRE,RXY")
4327    (set_attr "type"     "idiv")])
4330 ; divmodsi4 instruction pattern(s).
4333 (define_expand "divmodsi4"
4334   [(parallel [(set (match_operand:SI 0 "general_operand" "")
4335                    (div:SI (match_operand:SI 1 "general_operand" "")
4336                            (match_operand:SI 2 "nonimmediate_operand" "")))
4337               (set (match_operand:SI 3 "general_operand" "")
4338                    (mod:SI (match_dup 1) (match_dup 2)))])
4339    (clobber (match_dup 4))]
4340   "!TARGET_64BIT"
4342   rtx insn, div_equal, mod_equal, equal;
4344   div_equal = gen_rtx_DIV (SImode, operands[1], operands[2]);
4345   mod_equal = gen_rtx_MOD (SImode, operands[1], operands[2]);
4346   equal = gen_rtx_IOR (DImode,
4347                        gen_rtx_ASHIFT (DImode,
4348                                        gen_rtx_ZERO_EXTEND (DImode, mod_equal),
4349                                        GEN_INT (32)),
4350                        gen_rtx_ZERO_EXTEND (DImode, div_equal));
4352   operands[4] = gen_reg_rtx(DImode);
4353   emit_insn (gen_extendsidi2 (operands[4], operands[1]));
4354   insn = emit_insn (gen_divmoddisi3 (operands[4], operands[4], operands[2]));
4355   REG_NOTES (insn) =
4356         gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4358   insn = emit_move_insn (operands[0], gen_lowpart (SImode, operands[4]));
4359   REG_NOTES (insn) =
4360         gen_rtx_EXPR_LIST (REG_EQUAL, div_equal, REG_NOTES (insn));
4362   insn = emit_move_insn (operands[3], gen_highpart (SImode, operands[4]));
4363   REG_NOTES (insn) =
4364         gen_rtx_EXPR_LIST (REG_EQUAL, mod_equal, REG_NOTES (insn));
4366   DONE;
4369 (define_insn "divmoddisi3"
4370   [(set (match_operand:DI 0 "register_operand" "=d,d")
4371         (ior:DI
4372           (ashift:DI
4373             (zero_extend:DI
4374               (truncate:SI
4375                 (mod:DI (match_operand:DI 1 "register_operand" "0,0")
4376                         (sign_extend:DI
4377                           (match_operand:SI 2 "nonimmediate_operand" "d,R")))))
4378             (const_int 32))
4379           (zero_extend:DI
4380             (truncate:SI
4381               (div:DI (match_dup 1) (sign_extend:DI (match_dup 2)))))))]
4382   "!TARGET_64BIT"
4383   "@
4384    dr\t%0,%2
4385    d\t%0,%2"
4386   [(set_attr "op_type"  "RR,RX")
4387    (set_attr "type"     "idiv")])
4390 ; udivsi3 and umodsi3 instruction pattern(s).
4393 (define_expand "udivmodsi4"
4394   [(parallel [(set (match_operand:SI 0 "general_operand" "")
4395                    (udiv:SI (match_operand:SI 1 "general_operand" "")
4396                             (match_operand:SI 2 "nonimmediate_operand" "")))
4397               (set (match_operand:SI 3 "general_operand" "")
4398                    (umod:SI (match_dup 1) (match_dup 2)))])
4399    (clobber (match_dup 4))]
4400   "!TARGET_64BIT && TARGET_CPU_ZARCH"
4402   rtx insn, div_equal, mod_equal, equal;
4404   div_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
4405   mod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
4406   equal = gen_rtx_IOR (DImode,
4407                        gen_rtx_ASHIFT (DImode,
4408                                        gen_rtx_ZERO_EXTEND (DImode, mod_equal),
4409                                        GEN_INT (32)),
4410                        gen_rtx_ZERO_EXTEND (DImode, div_equal));
4412   operands[4] = gen_reg_rtx(DImode);
4413   emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[4]));
4414   emit_move_insn (gen_lowpart (SImode, operands[4]), operands[1]);
4415   emit_move_insn (gen_highpart (SImode, operands[4]), const0_rtx);
4416   insn = emit_insn (gen_udivmoddisi3 (operands[4], operands[4], operands[2]));
4417   REG_NOTES (insn) =
4418         gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4420   insn = emit_move_insn (operands[0], gen_lowpart (SImode, operands[4]));
4421   REG_NOTES (insn) =
4422         gen_rtx_EXPR_LIST (REG_EQUAL, div_equal, REG_NOTES (insn));
4424   insn = emit_move_insn (operands[3], gen_highpart (SImode, operands[4]));
4425   REG_NOTES (insn) =
4426         gen_rtx_EXPR_LIST (REG_EQUAL, mod_equal, REG_NOTES (insn));
4428   DONE;
4431 (define_insn "udivmoddisi3"
4432   [(set (match_operand:DI 0 "register_operand" "=d,d")
4433         (ior:DI
4434           (ashift:DI
4435             (zero_extend:DI
4436               (truncate:SI
4437                 (umod:DI (match_operand:DI 1 "register_operand" "0,0")
4438                          (zero_extend:DI
4439                            (match_operand:SI 2 "nonimmediate_operand" "d,m")))))
4440             (const_int 32))
4441           (zero_extend:DI
4442             (truncate:SI
4443               (udiv:DI (match_dup 1) (zero_extend:DI (match_dup 2)))))))]
4444   "!TARGET_64BIT && TARGET_CPU_ZARCH"
4445   "@
4446    dlr\t%0,%2
4447    dl\t%0,%2"
4448   [(set_attr "op_type"  "RRE,RXY")
4449    (set_attr "type"     "idiv")])
4451 (define_expand "udivsi3"
4452   [(set (match_operand:SI 0 "register_operand" "=d")
4453         (udiv:SI (match_operand:SI 1 "general_operand" "")
4454                  (match_operand:SI 2 "general_operand" "")))
4455    (clobber (match_dup 3))]
4456   "!TARGET_64BIT && !TARGET_CPU_ZARCH"
4458   rtx insn, udiv_equal, umod_equal, equal;
4460   udiv_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
4461   umod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
4462   equal = gen_rtx_IOR (DImode,
4463                        gen_rtx_ASHIFT (DImode,
4464                                        gen_rtx_ZERO_EXTEND (DImode, umod_equal),
4465                                        GEN_INT (32)),
4466                        gen_rtx_ZERO_EXTEND (DImode, udiv_equal));
4468   operands[3] = gen_reg_rtx (DImode);
4470   if (CONSTANT_P (operands[2]))
4471     {
4472       if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 0)
4473         {
4474           rtx label1 = gen_label_rtx ();
4476           operands[1] = make_safe_from (operands[1], operands[0]);
4477           emit_move_insn (operands[0], const0_rtx);
4478           emit_insn (gen_cmpsi (operands[1], operands[2]));
4479           emit_jump_insn (gen_bltu (label1));
4480           emit_move_insn (operands[0], const1_rtx);
4481           emit_label (label1);
4482         }
4483       else
4484         {
4485           operands[2] = force_reg (SImode, operands[2]);
4486           operands[2] = make_safe_from (operands[2], operands[0]);
4488           emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
4489           insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
4490                                              operands[2]));
4491           REG_NOTES (insn) =
4492             gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4494           insn = emit_move_insn (operands[0],
4495                                  gen_lowpart (SImode, operands[3]));
4496           REG_NOTES (insn) =
4497             gen_rtx_EXPR_LIST (REG_EQUAL,
4498                                udiv_equal, REG_NOTES (insn));
4499         }
4500     }
4501   else
4502     {
4503       rtx label1 = gen_label_rtx ();
4504       rtx label2 = gen_label_rtx ();
4505       rtx label3 = gen_label_rtx ();
4507       operands[1] = force_reg (SImode, operands[1]);
4508       operands[1] = make_safe_from (operands[1], operands[0]);
4509       operands[2] = force_reg (SImode, operands[2]);
4510       operands[2] = make_safe_from (operands[2], operands[0]);
4512       emit_move_insn (operands[0], const0_rtx);
4513       emit_insn (gen_cmpsi (operands[2], operands[1]));
4514       emit_jump_insn (gen_bgtu (label3));
4515       emit_insn (gen_cmpsi (operands[2], const0_rtx));
4516       emit_jump_insn (gen_blt (label2));
4517       emit_insn (gen_cmpsi (operands[2], const1_rtx));
4518       emit_jump_insn (gen_beq (label1));
4519       emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
4520       insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
4521                                          operands[2]));
4522       REG_NOTES (insn) =
4523       gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4525       insn = emit_move_insn (operands[0],
4526                              gen_lowpart (SImode, operands[3]));
4527       REG_NOTES (insn) =
4528       gen_rtx_EXPR_LIST (REG_EQUAL,
4529                                udiv_equal, REG_NOTES (insn));
4530       emit_jump (label3);
4531       emit_label (label1);
4532       emit_move_insn (operands[0], operands[1]);
4533       emit_jump (label3);
4534       emit_label (label2);
4535       emit_move_insn (operands[0], const1_rtx);
4536       emit_label (label3);
4537     }
4538   emit_move_insn (operands[0], operands[0]);
4539   DONE;
4542 (define_expand "umodsi3"
4543   [(set (match_operand:SI 0 "register_operand" "=d")
4544         (umod:SI (match_operand:SI 1 "nonimmediate_operand" "")
4545                  (match_operand:SI 2 "nonimmediate_operand" "")))
4546    (clobber (match_dup 3))]
4547   "!TARGET_64BIT && !TARGET_CPU_ZARCH"
4549   rtx insn, udiv_equal, umod_equal, equal;
4551   udiv_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
4552   umod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
4553   equal = gen_rtx_IOR (DImode,
4554                        gen_rtx_ASHIFT (DImode,
4555                                        gen_rtx_ZERO_EXTEND (DImode, umod_equal),
4556                                        GEN_INT (32)),
4557                        gen_rtx_ZERO_EXTEND (DImode, udiv_equal));
4559   operands[3] = gen_reg_rtx (DImode);
4561   if (CONSTANT_P (operands[2]))
4562     {
4563       if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) <= 0)
4564         {
4565           rtx label1 = gen_label_rtx ();
4567           operands[1] = make_safe_from (operands[1], operands[0]);
4568           emit_move_insn (operands[0], operands[1]);
4569           emit_insn (gen_cmpsi (operands[0], operands[2]));
4570           emit_jump_insn (gen_bltu (label1));
4571           emit_insn (gen_abssi2 (operands[0], operands[2]));
4572           emit_insn (gen_addsi3 (operands[0], operands[0], operands[1]));
4573           emit_label (label1);
4574         }
4575       else
4576         {
4577           operands[2] = force_reg (SImode, operands[2]);
4578           operands[2] = make_safe_from (operands[2], operands[0]);
4580           emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
4581           insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
4582                                              operands[2]));
4583           REG_NOTES (insn) =
4584             gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4586           insn = emit_move_insn (operands[0],
4587                                  gen_highpart (SImode, operands[3]));
4588           REG_NOTES (insn) =
4589             gen_rtx_EXPR_LIST (REG_EQUAL,
4590                                umod_equal, REG_NOTES (insn));
4591         }
4592     }
4593   else
4594     {
4595       rtx label1 = gen_label_rtx ();
4596       rtx label2 = gen_label_rtx ();
4597       rtx label3 = gen_label_rtx ();
4599       operands[1] = force_reg (SImode, operands[1]);
4600       operands[1] = make_safe_from (operands[1], operands[0]);
4601       operands[2] = force_reg (SImode, operands[2]);
4602       operands[2] = make_safe_from (operands[2], operands[0]);
4604       emit_move_insn(operands[0], operands[1]);
4605       emit_insn (gen_cmpsi (operands[2], operands[1]));
4606       emit_jump_insn (gen_bgtu (label3));
4607       emit_insn (gen_cmpsi (operands[2], const0_rtx));
4608       emit_jump_insn (gen_blt (label2));
4609       emit_insn (gen_cmpsi (operands[2], const1_rtx));
4610       emit_jump_insn (gen_beq (label1));
4611       emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
4612       insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
4613                                          operands[2]));
4614       REG_NOTES (insn) =
4615       gen_rtx_EXPR_LIST (REG_EQUAL, equal, REG_NOTES (insn));
4617       insn = emit_move_insn (operands[0],
4618                              gen_highpart (SImode, operands[3]));
4619       REG_NOTES (insn) =
4620       gen_rtx_EXPR_LIST (REG_EQUAL,
4621                          umod_equal, REG_NOTES (insn));
4622       emit_jump (label3);
4623       emit_label (label1);
4624       emit_move_insn (operands[0], const0_rtx);
4625       emit_jump (label3);
4626       emit_label (label2);
4627       emit_insn (gen_subsi3 (operands[0], operands[0], operands[2]));
4628       emit_label (label3);
4629     }
4630   DONE;
4634 ; div(df|sf)3 instruction pattern(s).
4637 (define_expand "div<mode>3"
4638   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4639         (div:FPR (match_operand:FPR 1 "register_operand" "0,0")
4640                  (match_operand:FPR 2 "general_operand" "f,R")))]
4641   "TARGET_HARD_FLOAT"
4642   "")
4644 (define_insn "*div<mode>3"
4645   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4646         (div:FPR (match_operand:FPR 1 "register_operand" "0,0")
4647                  (match_operand:FPR 2 "general_operand" "f,R")))]
4648   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
4649   "@
4650    d<de>br\t%0,%2
4651    d<de>b\t%0,%2"
4652   [(set_attr "op_type"  "RRE,RXE")
4653    (set_attr "type"     "fdiv<mode>")])
4655 (define_insn "*div<mode>3_ibm"
4656   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4657         (div:FPR (match_operand:FPR 1 "register_operand" "0,0")
4658                  (match_operand:FPR 2 "general_operand" "f,R")))]
4659   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
4660   "@
4661    d<de>r\t%0,%2
4662    d<de>\t%0,%2"
4663   [(set_attr "op_type"  "RR,RX")
4664    (set_attr "type"     "fdiv<mode>")])
4668 ;;- And instructions.
4672 ; anddi3 instruction pattern(s).
4675 (define_insn "*anddi3_cc"
4676   [(set (reg 33)
4677         (compare (and:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
4678                          (match_operand:DI 2 "general_operand" "d,m"))
4679                  (const_int 0)))
4680    (set (match_operand:DI 0 "register_operand" "=d,d")
4681         (and:DI (match_dup 1) (match_dup 2)))]
4682   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
4683   "@
4684    ngr\t%0,%2
4685    ng\t%0,%2"
4686   [(set_attr "op_type"  "RRE,RXY")])
4688 (define_insn "*anddi3_cconly"
4689   [(set (reg 33)
4690         (compare (and:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
4691                          (match_operand:DI 2 "general_operand" "d,m"))
4692                  (const_int 0)))
4693    (clobber (match_scratch:DI 0 "=d,d"))]
4694   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT
4695    /* Do not steal TM patterns.  */
4696    && s390_single_part (operands[2], DImode, HImode, 0) < 0"
4697   "@
4698    ngr\t%0,%2
4699    ng\t%0,%2"
4700   [(set_attr "op_type"  "RRE,RXY")])
4702 (define_insn "*anddi3"
4703   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,d,d,d,d,d,AQ,Q")
4704         (and:DI (match_operand:DI 1 "nonimmediate_operand"
4705                                     "%d,o,0,0,0,0,0,0,0,0")
4706                 (match_operand:DI 2 "general_operand"
4707                                     "M,M,N0HDF,N1HDF,N2HDF,N3HDF,d,m,NxQDF,Q")))
4708    (clobber (reg:CC 33))]
4709   "TARGET_64BIT && s390_logical_operator_ok_p (operands)"
4710   "@
4711    #
4712    #
4713    nihh\t%0,%j2
4714    nihl\t%0,%j2
4715    nilh\t%0,%j2
4716    nill\t%0,%j2
4717    ngr\t%0,%2
4718    ng\t%0,%2
4719    #
4720    #"
4721   [(set_attr "op_type" "RRE,RXE,RI,RI,RI,RI,RRE,RXY,SI,SS")])
4723 (define_split
4724   [(set (match_operand:DI 0 "s_operand" "")
4725         (and:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
4726    (clobber (reg:CC 33))]
4727   "reload_completed"
4728   [(parallel
4729     [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
4730      (clobber (reg:CC 33))])]
4731   "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
4733 (define_expand "anddi3"
4734   [(set (match_operand:DI 0 "nonimmediate_operand" "")
4735         (and:DI (match_operand:DI 1 "nonimmediate_operand" "")
4736                 (match_operand:DI 2 "general_operand" "")))
4737    (clobber (reg:CC 33))]
4738   "TARGET_64BIT"
4739   "s390_expand_logical_operator (AND, DImode, operands); DONE;")
4742 ; andsi3 instruction pattern(s).
4745 (define_insn "*andsi3_cc"
4746   [(set (reg 33)
4747         (compare (and:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
4748                          (match_operand:SI 2 "general_operand" "d,R,T"))
4749                  (const_int 0)))
4750    (set (match_operand:SI 0 "register_operand" "=d,d,d")
4751         (and:SI (match_dup 1) (match_dup 2)))]
4752   "s390_match_ccmode(insn, CCTmode)"
4753   "@
4754    nr\t%0,%2
4755    n\t%0,%2
4756    ny\t%0,%2"
4757   [(set_attr "op_type"  "RR,RX,RXY")])
4759 (define_insn "*andsi3_cconly"
4760   [(set (reg 33)
4761         (compare (and:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
4762                          (match_operand:SI 2 "general_operand" "d,R,T"))
4763                  (const_int 0)))
4764    (clobber (match_scratch:SI 0 "=d,d,d"))]
4765   "s390_match_ccmode(insn, CCTmode)
4766    /* Do not steal TM patterns.  */
4767    && s390_single_part (operands[2], SImode, HImode, 0) < 0"
4768   "@
4769    nr\t%0,%2
4770    n\t%0,%2
4771    ny\t%0,%2"
4772   [(set_attr "op_type"  "RR,RX,RXY")])
4774 (define_insn "*andsi3_zarch"
4775   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,d,d,d,d,AQ,Q")
4776         (and:SI (match_operand:SI 1 "nonimmediate_operand"
4777                                     "%d,o,0,0,0,0,0,0,0")
4778                 (match_operand:SI 2 "general_operand"
4779                                     "M,M,N0HSF,N1HSF,d,R,T,NxQSF,Q")))
4780    (clobber (reg:CC 33))]
4781   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4782   "@
4783    #
4784    #
4785    nilh\t%0,%j2
4786    nill\t%0,%j2
4787    nr\t%0,%2
4788    n\t%0,%2
4789    ny\t%0,%2
4790    #
4791    #"
4792   [(set_attr "op_type"  "RRE,RXE,RI,RI,RR,RX,RXY,SI,SS")])
4794 (define_insn "*andsi3_esa"
4795   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,AQ,Q")
4796         (and:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
4797                 (match_operand:SI 2 "general_operand" "d,R,NxQSF,Q")))
4798    (clobber (reg:CC 33))]
4799   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4800   "@
4801    nr\t%0,%2
4802    n\t%0,%2
4803    #
4804    #"
4805   [(set_attr "op_type"  "RR,RX,SI,SS")])
4807 (define_split
4808   [(set (match_operand:SI 0 "s_operand" "")
4809         (and:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
4810    (clobber (reg:CC 33))]
4811   "reload_completed"
4812   [(parallel
4813     [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
4814      (clobber (reg:CC 33))])]
4815   "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
4817 (define_expand "andsi3"
4818   [(set (match_operand:SI 0 "nonimmediate_operand" "")
4819         (and:SI (match_operand:SI 1 "nonimmediate_operand" "")
4820                 (match_operand:SI 2 "general_operand" "")))
4821    (clobber (reg:CC 33))]
4822   ""
4823   "s390_expand_logical_operator (AND, SImode, operands); DONE;")
4826 ; andhi3 instruction pattern(s).
4829 (define_insn "*andhi3_zarch"
4830   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,AQ,Q")
4831         (and:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0,0")
4832                 (match_operand:HI 2 "general_operand" "d,n,NxQHF,Q")))
4833    (clobber (reg:CC 33))]
4834   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4835   "@
4836    nr\t%0,%2
4837    nill\t%0,%x2
4838    #
4839    #"
4840   [(set_attr "op_type"  "RR,RI,SI,SS")])
4842 (define_insn "*andhi3_esa"
4843   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,AQ,Q")
4844         (and:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0")
4845                 (match_operand:HI 2 "general_operand" "d,NxQHF,Q")))
4846    (clobber (reg:CC 33))]
4847   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4848   "@
4849    nr\t%0,%2
4850    #
4851    #"
4852   [(set_attr "op_type"  "RR,SI,SS")])
4854 (define_split
4855   [(set (match_operand:HI 0 "s_operand" "")
4856         (and:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
4857    (clobber (reg:CC 33))]
4858   "reload_completed"
4859   [(parallel
4860     [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
4861      (clobber (reg:CC 33))])]
4862   "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
4864 (define_expand "andhi3"
4865   [(set (match_operand:HI 0 "nonimmediate_operand" "")
4866         (and:HI (match_operand:HI 1 "nonimmediate_operand" "")
4867                 (match_operand:HI 2 "general_operand" "")))
4868    (clobber (reg:CC 33))]
4869   ""
4870   "s390_expand_logical_operator (AND, HImode, operands); DONE;")
4873 ; andqi3 instruction pattern(s).
4876 (define_insn "*andqi3_zarch"
4877   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,Q,S,Q")
4878         (and:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0,0,0")
4879                 (match_operand:QI 2 "general_operand" "d,n,n,n,Q")))
4880    (clobber (reg:CC 33))]
4881   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4882   "@
4883    nr\t%0,%2
4884    nill\t%0,%b2
4885    ni\t%S0,%b2
4886    niy\t%S0,%b2
4887    #"
4888   [(set_attr "op_type"  "RR,RI,SI,SIY,SS")])
4890 (define_insn "*andqi3_esa"
4891   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,Q,Q")
4892         (and:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0")
4893                 (match_operand:QI 2 "general_operand" "d,n,Q")))
4894    (clobber (reg:CC 33))]
4895   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
4896   "@
4897    nr\t%0,%2
4898    ni\t%S0,%b2
4899    #"
4900   [(set_attr "op_type"  "RR,SI,SS")])
4902 (define_expand "andqi3"
4903   [(set (match_operand:QI 0 "nonimmediate_operand" "")
4904         (and:QI (match_operand:QI 1 "nonimmediate_operand" "")
4905                 (match_operand:QI 2 "general_operand" "")))
4906    (clobber (reg:CC 33))]
4907   ""
4908   "s390_expand_logical_operator (AND, QImode, operands); DONE;")
4911 ; Block and (NC) patterns.
4914 (define_insn "*nc"
4915   [(set (match_operand:BLK 0 "memory_operand" "=Q")
4916         (and:BLK (match_dup 0)
4917                  (match_operand:BLK 1 "memory_operand" "Q")))
4918    (use (match_operand 2 "const_int_operand" "n"))
4919    (clobber (reg:CC 33))]
4920   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
4921   "nc\t%O0(%2,%R0),%S1"
4922   [(set_attr "op_type" "SS")])
4924 (define_split
4925   [(set (match_operand 0 "memory_operand" "")
4926         (and (match_dup 0)
4927              (match_operand 1 "memory_operand" "")))
4928    (clobber (reg:CC 33))]
4929   "reload_completed
4930    && GET_MODE (operands[0]) == GET_MODE (operands[1])
4931    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
4932   [(parallel
4933     [(set (match_dup 0) (and:BLK (match_dup 0) (match_dup 1)))
4934      (use (match_dup 2))
4935      (clobber (reg:CC 33))])]
4937   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
4938   operands[0] = adjust_address (operands[0], BLKmode, 0);
4939   operands[1] = adjust_address (operands[1], BLKmode, 0);
4942 (define_peephole2
4943   [(parallel
4944     [(set (match_operand:BLK 0 "memory_operand" "")
4945           (and:BLK (match_dup 0)
4946                    (match_operand:BLK 1 "memory_operand" "")))
4947      (use (match_operand 2 "const_int_operand" ""))
4948      (clobber (reg:CC 33))])
4949    (parallel
4950     [(set (match_operand:BLK 3 "memory_operand" "")
4951           (and:BLK (match_dup 3)
4952                    (match_operand:BLK 4 "memory_operand" "")))
4953      (use (match_operand 5 "const_int_operand" ""))
4954      (clobber (reg:CC 33))])]
4955   "s390_offset_p (operands[0], operands[3], operands[2])
4956    && s390_offset_p (operands[1], operands[4], operands[2])
4957    && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
4958   [(parallel
4959     [(set (match_dup 6) (and:BLK (match_dup 6) (match_dup 7)))
4960      (use (match_dup 8))
4961      (clobber (reg:CC 33))])]
4962   "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
4963    operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
4964    operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
4968 ;;- Bit set (inclusive or) instructions.
4972 ; iordi3 instruction pattern(s).
4975 (define_insn "*iordi3_cc"
4976   [(set (reg 33)
4977         (compare (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
4978                          (match_operand:DI 2 "general_operand" "d,m"))
4979                  (const_int 0)))
4980    (set (match_operand:DI 0 "register_operand" "=d,d")
4981         (ior:DI (match_dup 1) (match_dup 2)))]
4982   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
4983   "@
4984    ogr\t%0,%2
4985    og\t%0,%2"
4986   [(set_attr "op_type"  "RRE,RXY")])
4988 (define_insn "*iordi3_cconly"
4989   [(set (reg 33)
4990         (compare (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
4991                          (match_operand:DI 2 "general_operand" "d,m"))
4992                  (const_int 0)))
4993    (clobber (match_scratch:DI 0 "=d,d"))]
4994   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
4995   "@
4996    ogr\t%0,%2
4997    og\t%0,%2"
4998   [(set_attr "op_type"  "RRE,RXY")])
5000 (define_insn "*iordi3"
5001   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,d,d,d,AQ,Q")
5002         (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0,0,0,0,0,0")
5003                 (match_operand:DI 2 "general_operand"
5004                                     "N0HD0,N1HD0,N2HD0,N3HD0,d,m,NxQD0,Q")))
5005    (clobber (reg:CC 33))]
5006   "TARGET_64BIT && s390_logical_operator_ok_p (operands)"
5007   "@
5008    oihh\t%0,%i2
5009    oihl\t%0,%i2
5010    oilh\t%0,%i2
5011    oill\t%0,%i2
5012    ogr\t%0,%2
5013    og\t%0,%2
5014    #
5015    #"
5016   [(set_attr "op_type"  "RI,RI,RI,RI,RRE,RXY,SI,SS")])
5018 (define_split
5019   [(set (match_operand:DI 0 "s_operand" "")
5020         (ior:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
5021    (clobber (reg:CC 33))]
5022   "reload_completed"
5023   [(parallel
5024     [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
5025      (clobber (reg:CC 33))])]
5026   "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
5028 (define_expand "iordi3"
5029   [(set (match_operand:DI 0 "nonimmediate_operand" "")
5030         (ior:DI (match_operand:DI 1 "nonimmediate_operand" "")
5031                 (match_operand:DI 2 "general_operand" "")))
5032    (clobber (reg:CC 33))]
5033   "TARGET_64BIT"
5034   "s390_expand_logical_operator (IOR, DImode, operands); DONE;")
5037 ; iorsi3 instruction pattern(s).
5040 (define_insn "*iorsi3_cc"
5041   [(set (reg 33)
5042         (compare (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
5043                          (match_operand:SI 2 "general_operand" "d,R,T"))
5044                  (const_int 0)))
5045    (set (match_operand:SI 0 "register_operand" "=d,d,d")
5046         (ior:SI (match_dup 1) (match_dup 2)))]
5047   "s390_match_ccmode(insn, CCTmode)"
5048   "@
5049    or\t%0,%2
5050    o\t%0,%2
5051    oy\t%0,%2"
5052   [(set_attr "op_type"  "RR,RX,RXY")])
5054 (define_insn "*iorsi3_cconly"
5055   [(set (reg 33)
5056         (compare (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
5057                          (match_operand:SI 2 "general_operand" "d,R,T"))
5058                  (const_int 0)))
5059    (clobber (match_scratch:SI 0 "=d,d,d"))]
5060   "s390_match_ccmode(insn, CCTmode)"
5061   "@
5062    or\t%0,%2
5063    o\t%0,%2
5064    oy\t%0,%2"
5065   [(set_attr "op_type"  "RR,RX,RXY")])
5067 (define_insn "*iorsi3_zarch"
5068   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,d,d,AQ,Q")
5069         (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0,0,0,0")
5070                 (match_operand:SI 2 "general_operand" "N0HS0,N1HS0,d,R,T,NxQS0,Q")))
5071    (clobber (reg:CC 33))]
5072   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5073   "@
5074    oilh\t%0,%i2
5075    oill\t%0,%i2
5076    or\t%0,%2
5077    o\t%0,%2
5078    oy\t%0,%2
5079    #
5080    #"
5081   [(set_attr "op_type"  "RI,RI,RR,RX,RXY,SI,SS")])
5083 (define_insn "*iorsi3_esa"
5084   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,AQ,Q")
5085         (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
5086                 (match_operand:SI 2 "general_operand" "d,R,NxQS0,Q")))
5087    (clobber (reg:CC 33))]
5088   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5089   "@
5090    or\t%0,%2
5091    o\t%0,%2
5092    #
5093    #"
5094   [(set_attr "op_type"  "RR,RX,SI,SS")])
5096 (define_split
5097   [(set (match_operand:SI 0 "s_operand" "")
5098         (ior:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
5099    (clobber (reg:CC 33))]
5100   "reload_completed"
5101   [(parallel
5102     [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
5103      (clobber (reg:CC 33))])]
5104   "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
5106 (define_expand "iorsi3"
5107   [(set (match_operand:SI 0 "nonimmediate_operand" "")
5108         (ior:SI (match_operand:SI 1 "nonimmediate_operand" "")
5109                 (match_operand:SI 2 "general_operand" "")))
5110    (clobber (reg:CC 33))]
5111   ""
5112   "s390_expand_logical_operator (IOR, SImode, operands); DONE;")
5115 ; iorhi3 instruction pattern(s).
5118 (define_insn "*iorhi3_zarch"
5119   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,AQ,Q")
5120         (ior:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0,0")
5121                 (match_operand:HI 2 "general_operand" "d,n,NxQH0,Q")))
5122    (clobber (reg:CC 33))]
5123   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5124   "@
5125    or\t%0,%2
5126    oill\t%0,%x2
5127    #
5128    #"
5129   [(set_attr "op_type"  "RR,RI,SI,SS")])
5131 (define_insn "*iorhi3_esa"
5132   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,AQ,Q")
5133         (ior:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0")
5134                 (match_operand:HI 2 "general_operand" "d,NxQH0,Q")))
5135    (clobber (reg:CC 33))]
5136   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5137   "@
5138    or\t%0,%2
5139    #
5140    #"
5141   [(set_attr "op_type"  "RR,SI,SS")])
5143 (define_split
5144   [(set (match_operand:HI 0 "s_operand" "")
5145         (ior:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
5146    (clobber (reg:CC 33))]
5147   "reload_completed"
5148   [(parallel
5149     [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
5150      (clobber (reg:CC 33))])]
5151   "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
5153 (define_expand "iorhi3"
5154   [(set (match_operand:HI 0 "nonimmediate_operand" "")
5155         (ior:HI (match_operand:HI 1 "nonimmediate_operand" "")
5156                 (match_operand:HI 2 "general_operand" "")))
5157    (clobber (reg:CC 33))]
5158   ""
5159   "s390_expand_logical_operator (IOR, HImode, operands); DONE;")
5162 ; iorqi3 instruction pattern(s).
5165 (define_insn "*iorqi3_zarch"
5166   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,Q,S,Q")
5167         (ior:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0,0,0")
5168                 (match_operand:QI 2 "general_operand" "d,n,n,n,Q")))
5169    (clobber (reg:CC 33))]
5170   "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5171   "@
5172    or\t%0,%2
5173    oill\t%0,%b2
5174    oi\t%S0,%b2
5175    oiy\t%S0,%b2
5176    #"
5177   [(set_attr "op_type"  "RR,RI,SI,SIY,SS")])
5179 (define_insn "*iorqi3_esa"
5180   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,Q,Q")
5181         (ior:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0")
5182                 (match_operand:QI 2 "general_operand" "d,n,Q")))
5183    (clobber (reg:CC 33))]
5184   "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
5185   "@
5186    or\t%0,%2
5187    oi\t%S0,%b2
5188    #"
5189   [(set_attr "op_type"  "RR,SI,SS")])
5191 (define_expand "iorqi3"
5192   [(set (match_operand:QI 0 "nonimmediate_operand" "")
5193         (ior:QI (match_operand:QI 1 "nonimmediate_operand" "")
5194                 (match_operand:QI 2 "general_operand" "")))
5195    (clobber (reg:CC 33))]
5196   ""
5197   "s390_expand_logical_operator (IOR, QImode, operands); DONE;")
5200 ; Block inclusive or (OC) patterns.
5203 (define_insn "*oc"
5204   [(set (match_operand:BLK 0 "memory_operand" "=Q")
5205         (ior:BLK (match_dup 0)
5206                  (match_operand:BLK 1 "memory_operand" "Q")))
5207    (use (match_operand 2 "const_int_operand" "n"))
5208    (clobber (reg:CC 33))]
5209   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
5210   "oc\t%O0(%2,%R0),%S1"
5211   [(set_attr "op_type" "SS")])
5213 (define_split
5214   [(set (match_operand 0 "memory_operand" "")
5215         (ior (match_dup 0)
5216              (match_operand 1 "memory_operand" "")))
5217    (clobber (reg:CC 33))]
5218   "reload_completed
5219    && GET_MODE (operands[0]) == GET_MODE (operands[1])
5220    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
5221   [(parallel
5222     [(set (match_dup 0) (ior:BLK (match_dup 0) (match_dup 1)))
5223      (use (match_dup 2))
5224      (clobber (reg:CC 33))])]
5226   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
5227   operands[0] = adjust_address (operands[0], BLKmode, 0);
5228   operands[1] = adjust_address (operands[1], BLKmode, 0);
5231 (define_peephole2
5232   [(parallel
5233     [(set (match_operand:BLK 0 "memory_operand" "")
5234           (ior:BLK (match_dup 0)
5235                    (match_operand:BLK 1 "memory_operand" "")))
5236      (use (match_operand 2 "const_int_operand" ""))
5237      (clobber (reg:CC 33))])
5238    (parallel
5239     [(set (match_operand:BLK 3 "memory_operand" "")
5240           (ior:BLK (match_dup 3)
5241                    (match_operand:BLK 4 "memory_operand" "")))
5242      (use (match_operand 5 "const_int_operand" ""))
5243      (clobber (reg:CC 33))])]
5244   "s390_offset_p (operands[0], operands[3], operands[2])
5245    && s390_offset_p (operands[1], operands[4], operands[2])
5246    && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
5247   [(parallel
5248     [(set (match_dup 6) (ior:BLK (match_dup 6) (match_dup 7)))
5249      (use (match_dup 8))
5250      (clobber (reg:CC 33))])]
5251   "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
5252    operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
5253    operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
5257 ;;- Xor instructions.
5261 ; xordi3 instruction pattern(s).
5264 (define_insn "*xordi3_cc"
5265   [(set (reg 33)
5266         (compare (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
5267                          (match_operand:DI 2 "general_operand" "d,m"))
5268                  (const_int 0)))
5269    (set (match_operand:DI 0 "register_operand" "=d,d")
5270         (xor:DI (match_dup 1) (match_dup 2)))]
5271   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
5272   "@
5273    xgr\t%0,%2
5274    xg\t%0,%2"
5275   [(set_attr "op_type"  "RRE,RXY")])
5277 (define_insn "*xordi3_cconly"
5278   [(set (reg 33)
5279         (compare (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
5280                          (match_operand:DI 2 "general_operand" "d,m"))
5281                  (const_int 0)))
5282    (clobber (match_scratch:DI 0 "=d,d"))]
5283   "s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
5284   "@
5285    xgr\t%0,%2
5286    xr\t%0,%2"
5287   [(set_attr "op_type"  "RRE,RXY")])
5289 (define_insn "*xordi3"
5290   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,AQ,Q")
5291         (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0,0")
5292                 (match_operand:DI 2 "general_operand" "d,m,NxQD0,Q")))
5293    (clobber (reg:CC 33))]
5294   "TARGET_64BIT && s390_logical_operator_ok_p (operands)"
5295   "@
5296    xgr\t%0,%2
5297    xg\t%0,%2
5298    #
5299    #"
5300   [(set_attr "op_type"  "RRE,RXY,SI,SS")])
5302 (define_split
5303   [(set (match_operand:DI 0 "s_operand" "")
5304         (xor:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
5305    (clobber (reg:CC 33))]
5306   "reload_completed"
5307   [(parallel
5308     [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
5309      (clobber (reg:CC 33))])]
5310   "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
5312 (define_expand "xordi3"
5313   [(set (match_operand:DI 0 "nonimmediate_operand" "")
5314         (xor:DI (match_operand:DI 1 "nonimmediate_operand" "")
5315                 (match_operand:DI 2 "general_operand" "")))
5316    (clobber (reg:CC 33))]
5317   "TARGET_64BIT"
5318   "s390_expand_logical_operator (XOR, DImode, operands); DONE;")
5321 ; xorsi3 instruction pattern(s).
5324 (define_insn "*xorsi3_cc"
5325   [(set (reg 33)
5326         (compare (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
5327                          (match_operand:SI 2 "general_operand" "d,R,T"))
5328                  (const_int 0)))
5329    (set (match_operand:SI 0 "register_operand" "=d,d,d")
5330         (xor:SI (match_dup 1) (match_dup 2)))]
5331   "s390_match_ccmode(insn, CCTmode)"
5332   "@
5333    xr\t%0,%2
5334    x\t%0,%2
5335    xy\t%0,%2"
5336   [(set_attr "op_type"  "RR,RX,RXY")])
5338 (define_insn "*xorsi3_cconly"
5339   [(set (reg 33)
5340         (compare (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
5341                          (match_operand:SI 2 "general_operand" "d,R,T"))
5342                  (const_int 0)))
5343    (clobber (match_scratch:SI 0 "=d,d,d"))]
5344   "s390_match_ccmode(insn, CCTmode)"
5345   "@
5346    xr\t%0,%2
5347    x\t%0,%2
5348    xy\t%0,%2"
5349   [(set_attr "op_type"  "RR,RX,RXY")])
5351 (define_insn "*xorsi3"
5352   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,AQ,Q")
5353         (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0,0")
5354                 (match_operand:SI 2 "general_operand" "d,R,T,NxQS0,Q")))
5355    (clobber (reg:CC 33))]
5356   "s390_logical_operator_ok_p (operands)"
5357   "@
5358    xr\t%0,%2
5359    x\t%0,%2
5360    xy\t%0,%2
5361    #
5362    #"
5363   [(set_attr "op_type"  "RR,RX,RXY,SI,SS")])
5365 (define_split
5366   [(set (match_operand:SI 0 "s_operand" "")
5367         (xor:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
5368    (clobber (reg:CC 33))]
5369   "reload_completed"
5370   [(parallel
5371     [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
5372      (clobber (reg:CC 33))])]
5373   "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
5375 (define_expand "xorsi3"
5376   [(set (match_operand:SI 0 "nonimmediate_operand" "")
5377         (xor:SI (match_operand:SI 1 "nonimmediate_operand" "")
5378                 (match_operand:SI 2 "general_operand" "")))
5379    (clobber (reg:CC 33))]
5380   ""
5381   "s390_expand_logical_operator (XOR, SImode, operands); DONE;")
5384 ; xorhi3 instruction pattern(s).
5387 (define_insn "*xorhi3"
5388   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,AQ,Q")
5389         (xor:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0")
5390                 (match_operand:HI 2 "general_operand" "d,NxQH0,Q")))
5391    (clobber (reg:CC 33))]
5392   "s390_logical_operator_ok_p (operands)"
5393   "@
5394    xr\t%0,%2
5395    #
5396    #"
5397   [(set_attr "op_type"  "RR,SI,SS")])
5399 (define_split
5400   [(set (match_operand:HI 0 "s_operand" "")
5401         (xor:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
5402    (clobber (reg:CC 33))]
5403   "reload_completed"
5404   [(parallel
5405     [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
5406      (clobber (reg:CC 33))])]
5407   "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
5409 (define_expand "xorhi3"
5410   [(set (match_operand:HI 0 "nonimmediate_operand" "")
5411         (xor:HI (match_operand:HI 1 "nonimmediate_operand" "")
5412                 (match_operand:HI 2 "general_operand" "")))
5413    (clobber (reg:CC 33))]
5414   ""
5415   "s390_expand_logical_operator (XOR, HImode, operands); DONE;")
5418 ; xorqi3 instruction pattern(s).
5421 (define_insn "*xorqi3"
5422   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,Q,S,Q")
5423         (xor:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0,0")
5424                 (match_operand:QI 2 "general_operand" "d,n,n,Q")))
5425    (clobber (reg:CC 33))]
5426   "s390_logical_operator_ok_p (operands)"
5427   "@
5428    xr\t%0,%2
5429    xi\t%S0,%b2
5430    xiy\t%S0,%b2
5431    #"
5432   [(set_attr "op_type"  "RR,SI,SIY,SS")])
5434 (define_expand "xorqi3"
5435   [(set (match_operand:QI 0 "nonimmediate_operand" "")
5436         (xor:QI (match_operand:QI 1 "nonimmediate_operand" "")
5437                 (match_operand:QI 2 "general_operand" "")))
5438    (clobber (reg:CC 33))]
5439   ""
5440   "s390_expand_logical_operator (XOR, QImode, operands); DONE;")
5443 ; Block exclusive or (XC) patterns.
5446 (define_insn "*xc"
5447   [(set (match_operand:BLK 0 "memory_operand" "=Q")
5448         (xor:BLK (match_dup 0)
5449                  (match_operand:BLK 1 "memory_operand" "Q")))
5450    (use (match_operand 2 "const_int_operand" "n"))
5451    (clobber (reg:CC 33))]
5452   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
5453   "xc\t%O0(%2,%R0),%S1"
5454   [(set_attr "op_type" "SS")])
5456 (define_split
5457   [(set (match_operand 0 "memory_operand" "")
5458         (xor (match_dup 0)
5459              (match_operand 1 "memory_operand" "")))
5460    (clobber (reg:CC 33))]
5461   "reload_completed
5462    && GET_MODE (operands[0]) == GET_MODE (operands[1])
5463    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
5464   [(parallel
5465     [(set (match_dup 0) (xor:BLK (match_dup 0) (match_dup 1)))
5466      (use (match_dup 2))
5467      (clobber (reg:CC 33))])]
5469   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
5470   operands[0] = adjust_address (operands[0], BLKmode, 0);
5471   operands[1] = adjust_address (operands[1], BLKmode, 0);
5474 (define_peephole2
5475   [(parallel
5476     [(set (match_operand:BLK 0 "memory_operand" "")
5477           (xor:BLK (match_dup 0)
5478                    (match_operand:BLK 1 "memory_operand" "")))
5479      (use (match_operand 2 "const_int_operand" ""))
5480      (clobber (reg:CC 33))])
5481    (parallel
5482     [(set (match_operand:BLK 3 "memory_operand" "")
5483           (xor:BLK (match_dup 3)
5484                    (match_operand:BLK 4 "memory_operand" "")))
5485      (use (match_operand 5 "const_int_operand" ""))
5486      (clobber (reg:CC 33))])]
5487   "s390_offset_p (operands[0], operands[3], operands[2])
5488    && s390_offset_p (operands[1], operands[4], operands[2])
5489    && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
5490   [(parallel
5491     [(set (match_dup 6) (xor:BLK (match_dup 6) (match_dup 7)))
5492      (use (match_dup 8))
5493      (clobber (reg:CC 33))])]
5494   "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
5495    operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
5496    operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
5499 ; Block xor (XC) patterns with src == dest.
5502 (define_insn "*xc_zero"
5503   [(set (match_operand:BLK 0 "memory_operand" "=Q")
5504         (const_int 0))
5505    (use (match_operand 1 "const_int_operand" "n"))
5506    (clobber (reg:CC 33))]
5507   "INTVAL (operands[1]) >= 1 && INTVAL (operands[1]) <= 256"
5508   "xc\t%O0(%1,%R0),%S0"
5509   [(set_attr "op_type" "SS")])
5511 (define_peephole2
5512   [(parallel
5513     [(set (match_operand:BLK 0 "memory_operand" "")
5514           (const_int 0))
5515      (use (match_operand 1 "const_int_operand" ""))
5516      (clobber (reg:CC 33))])
5517    (parallel
5518     [(set (match_operand:BLK 2 "memory_operand" "")
5519           (const_int 0))
5520      (use (match_operand 3 "const_int_operand" ""))
5521      (clobber (reg:CC 33))])]
5522   "s390_offset_p (operands[0], operands[2], operands[1])
5523    && INTVAL (operands[1]) + INTVAL (operands[3]) <= 256"
5524   [(parallel
5525     [(set (match_dup 4) (const_int 0))
5526      (use (match_dup 5))
5527      (clobber (reg:CC 33))])]
5528   "operands[4] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
5529    operands[5] = GEN_INT (INTVAL (operands[1]) + INTVAL (operands[3]));")
5533 ;;- Negate instructions.
5537 ; neg(di|si)2 instruction pattern(s).
5540 (define_expand "neg<mode>2"
5541   [(parallel
5542     [(set (match_operand:DSI 0 "register_operand" "=d")
5543           (neg:DSI (match_operand:DSI 1 "register_operand" "d")))
5544      (clobber (reg:CC 33))])]
5545   ""
5546   "")
5548 (define_insn "*negdi2_sign_cc"
5549   [(set (reg 33)
5550         (compare (neg:DI (ashiftrt:DI (ashift:DI (subreg:DI
5551                            (match_operand:SI 1 "register_operand" "d") 0)
5552                            (const_int 32)) (const_int 32)))
5553                  (const_int 0)))
5554    (set (match_operand:DI 0 "register_operand" "=d")
5555         (neg:DI (sign_extend:DI (match_dup 1))))]
5556   "TARGET_64BIT && s390_match_ccmode (insn, CCAmode)"
5557   "lcgfr\t%0,%1"
5558   [(set_attr "op_type"  "RRE")])
5559   
5560 (define_insn "*negdi2_sign"
5561   [(set (match_operand:DI 0 "register_operand" "=d")
5562         (neg:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "d"))))
5563    (clobber (reg:CC 33))]
5564   "TARGET_64BIT"
5565   "lcgfr\t%0,%1"
5566   [(set_attr "op_type"  "RRE")])
5568 (define_insn "*neg<mode>2_cc"
5569   [(set (reg 33)
5570         (compare (neg:GPR (match_operand:GPR 1 "register_operand" "d"))
5571                  (const_int 0)))
5572    (set (match_operand:GPR 0 "register_operand" "=d")
5573         (neg:GPR (match_dup 1)))]
5574   "s390_match_ccmode (insn, CCAmode)"
5575   "lc<g>r\t%0,%1"
5576   [(set_attr "op_type"  "RR<E>")])
5577   
5578 (define_insn "*neg<mode>2_cconly"
5579   [(set (reg 33)
5580         (compare (neg:GPR (match_operand:GPR 1 "register_operand" "d"))
5581                  (const_int 0)))
5582    (clobber (match_scratch:GPR 0 "=d"))]
5583   "s390_match_ccmode (insn, CCAmode)"
5584   "lc<g>r\t%0,%1"
5585   [(set_attr "op_type"  "RR<E>")])
5586   
5587 (define_insn "*neg<mode>2"
5588   [(set (match_operand:GPR 0 "register_operand" "=d")
5589         (neg:GPR (match_operand:GPR 1 "register_operand" "d")))
5590    (clobber (reg:CC 33))]
5591   ""
5592   "lc<g>r\t%0,%1"
5593   [(set_attr "op_type"  "RR<E>")])
5595 (define_insn_and_split "*negdi2_31"
5596   [(set (match_operand:DI 0 "register_operand" "=d")
5597         (neg:DI (match_operand:DI 1 "register_operand" "d")))
5598    (clobber (reg:CC 33))]
5599   "!TARGET_64BIT"
5600   "#"
5601   "&& reload_completed"
5602   [(parallel
5603     [(set (match_dup 2) (neg:SI (match_dup 3)))
5604      (clobber (reg:CC 33))])
5605    (parallel
5606     [(set (reg:CCAP 33)
5607           (compare:CCAP (neg:SI (match_dup 5)) (const_int 0)))
5608      (set (match_dup 4) (neg:SI (match_dup 5)))])
5609    (set (pc)
5610         (if_then_else (ne (reg:CCAP 33) (const_int 0))
5611                       (pc)
5612                       (label_ref (match_dup 6))))
5613    (parallel
5614     [(set (match_dup 2) (plus:SI (match_dup 2) (const_int -1)))
5615      (clobber (reg:CC 33))])
5616    (match_dup 6)]
5617   "operands[2] = operand_subword (operands[0], 0, 0, DImode);
5618    operands[3] = operand_subword (operands[1], 0, 0, DImode);
5619    operands[4] = operand_subword (operands[0], 1, 0, DImode);
5620    operands[5] = operand_subword (operands[1], 1, 0, DImode);
5621    operands[6] = gen_label_rtx ();")
5624 ; neg(df|sf)2 instruction pattern(s).
5627 (define_expand "neg<mode>2"
5628   [(parallel
5629     [(set (match_operand:FPR 0 "register_operand" "=f")
5630           (neg:FPR (match_operand:FPR 1 "register_operand" "f")))
5631      (clobber (reg:CC 33))])]
5632   "TARGET_HARD_FLOAT"
5633   "")
5635 (define_insn "*neg<mode>2_cc"
5636   [(set (reg 33)
5637         (compare (neg:FPR (match_operand:FPR 1 "register_operand" "f"))
5638                  (match_operand:FPR 2 "const0_operand" "")))
5639    (set (match_operand:FPR 0 "register_operand" "=f")
5640         (neg:FPR (match_dup 1)))]
5641   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5642   "lc<de>br\t%0,%1"
5643   [(set_attr "op_type"  "RRE")
5644    (set_attr "type"     "fsimp<mode>")])
5645   
5646 (define_insn "*neg<mode>2_cconly"
5647   [(set (reg 33)
5648         (compare (neg:FPR (match_operand:FPR 1 "register_operand" "f"))
5649                  (match_operand:FPR 2 "const0_operand" "")))
5650    (clobber (match_scratch:FPR 0 "=f"))]
5651   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5652   "lc<de>br\t%0,%1"
5653   [(set_attr "op_type"  "RRE")
5654    (set_attr "type"     "fsimp<mode>")])
5655   
5656 (define_insn "*neg<mode>2"
5657   [(set (match_operand:FPR 0 "register_operand" "=f")
5658         (neg:FPR (match_operand:FPR 1 "register_operand" "f")))
5659    (clobber (reg:CC 33))]
5660   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5661   "lc<de>br\t%0,%1"
5662   [(set_attr "op_type"  "RRE")
5663    (set_attr "type"     "fsimp<mode>")])
5665 (define_insn "*neg<mode>2_ibm"
5666   [(set (match_operand:FPR 0 "register_operand" "=f")
5667         (neg:FPR (match_operand:FPR 1 "register_operand" "f")))
5668    (clobber (reg:CC 33))]
5669   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
5670   "lc<de>r\t%0,%1"
5671   [(set_attr "op_type"  "RR")
5672    (set_attr "type"     "fsimp<mode>")])
5676 ;;- Absolute value instructions.
5680 ; abs(di|si)2 instruction pattern(s).
5683 (define_insn "*absdi2_sign_cc"
5684   [(set (reg 33)
5685         (compare (abs:DI (ashiftrt:DI (ashift:DI (subreg:DI
5686                            (match_operand:SI 1 "register_operand" "d") 0)
5687                            (const_int 32)) (const_int 32)))
5688                  (const_int 0)))
5689    (set (match_operand:DI 0 "register_operand" "=d")
5690         (abs:DI (sign_extend:DI (match_dup 1))))]
5691   "TARGET_64BIT && s390_match_ccmode (insn, CCAmode)"
5692   "lpgfr\t%0,%1"
5693   [(set_attr "op_type"  "RRE")])
5695 (define_insn "*absdi2_sign"
5696   [(set (match_operand:DI 0 "register_operand" "=d")
5697         (abs:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "d"))))
5698    (clobber (reg:CC 33))]
5699   "TARGET_64BIT"
5700   "lpgfr\t%0,%1"
5701   [(set_attr "op_type"  "RRE")])
5703 (define_insn "*abs<mode>2_cc"
5704   [(set (reg 33)
5705         (compare (abs:GPR (match_operand:DI 1 "register_operand" "d"))
5706                  (const_int 0)))
5707    (set (match_operand:GPR 0 "register_operand" "=d")
5708         (abs:GPR (match_dup 1)))]
5709   "s390_match_ccmode (insn, CCAmode)"
5710   "lp<g>r\t%0,%1"
5711   [(set_attr "op_type"  "RR<E>")])
5712   
5713 (define_insn "*abs<mode>2_cconly"
5714   [(set (reg 33)
5715         (compare (abs:GPR (match_operand:GPR 1 "register_operand" "d"))
5716                  (const_int 0)))
5717    (clobber (match_scratch:GPR 0 "=d"))]
5718   "s390_match_ccmode (insn, CCAmode)"
5719   "lp<g>r\t%0,%1"
5720   [(set_attr "op_type"  "RR<E>")])
5721   
5722 (define_insn "abs<mode>2"
5723   [(set (match_operand:GPR 0 "register_operand" "=d")
5724         (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
5725    (clobber (reg:CC 33))]
5726   ""
5727   "lp<g>r\t%0,%1"
5728   [(set_attr "op_type"  "RR<E>")])
5731 ; abs(df|sf)2 instruction pattern(s).
5734 (define_expand "abs<mode>2"
5735   [(parallel
5736     [(set (match_operand:FPR 0 "register_operand" "=f")
5737           (abs:FPR (match_operand:FPR 1 "register_operand" "f")))
5738      (clobber (reg:CC 33))])]
5739   "TARGET_HARD_FLOAT"
5740   "")
5742 (define_insn "*abs<mode>2_cc"
5743   [(set (reg 33)
5744         (compare (abs:FPR (match_operand:FPR 1 "register_operand" "f"))
5745                  (match_operand:FPR 2 "const0_operand" "")))
5746    (set (match_operand:FPR 0 "register_operand" "=f")
5747         (abs:FPR (match_dup 1)))]
5748   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5749   "lp<de>br\t%0,%1"
5750   [(set_attr "op_type"  "RRE")
5751    (set_attr "type"     "fsimp<mode>")])
5752   
5753 (define_insn "*abs<mode>2_cconly"
5754   [(set (reg 33)
5755         (compare (abs:FPR (match_operand:FPR 1 "register_operand" "f"))
5756                  (match_operand:FPR 2 "const0_operand" "")))
5757    (clobber (match_scratch:FPR 0 "=f"))]
5758   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5759   "lp<de>br\t%0,%1"
5760   [(set_attr "op_type"  "RRE")
5761    (set_attr "type"     "fsimp<mode>")])
5762   
5763 (define_insn "*abs<mode>2"
5764   [(set (match_operand:FPR 0 "register_operand" "=f")
5765         (abs:FPR (match_operand:FPR 1 "register_operand" "f")))
5766    (clobber (reg:CC 33))]
5767   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5768   "lp<de>br\t%0,%1"
5769   [(set_attr "op_type"  "RRE")
5770    (set_attr "type"     "fsimp<mode>")])
5772 (define_insn "*abs<mode>2_ibm"
5773   [(set (match_operand:FPR 0 "register_operand" "=f")
5774         (abs:FPR (match_operand:FPR 1 "register_operand" "f")))
5775    (clobber (reg:CC 33))]
5776   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
5777   "lp<de>r\t%0,%1"
5778   [(set_attr "op_type"  "RR")
5779    (set_attr "type"     "fsimp<mode>")])
5782 ;;- Negated absolute value instructions
5786 ; Integer
5789 (define_insn "*negabsdi2_sign_cc"
5790   [(set (reg 33)
5791         (compare (neg:DI (abs:DI (ashiftrt:DI (ashift:DI (subreg:DI
5792                            (match_operand:SI 1 "register_operand" "d") 0)
5793                            (const_int 32)) (const_int 32))))
5794                  (const_int 0)))
5795    (set (match_operand:DI 0 "register_operand" "=d")
5796         (neg:DI (abs:DI (sign_extend:DI (match_dup 1)))))]
5797   "TARGET_64BIT && s390_match_ccmode (insn, CCAmode)"
5798   "lngfr\t%0,%1"
5799   [(set_attr "op_type"  "RRE")])
5801 (define_insn "*negabsdi2_sign"
5802   [(set (match_operand:DI 0 "register_operand" "=d")
5803         (neg:DI (abs:DI (sign_extend:DI
5804                           (match_operand:SI 1 "register_operand" "d")))))
5805    (clobber (reg:CC 33))]
5806   "TARGET_64BIT"
5807   "lngfr\t%0,%1"
5808   [(set_attr "op_type" "RRE")])
5810 (define_insn "*negabs<mode>2_cc"
5811   [(set (reg 33)
5812         (compare (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
5813                  (const_int 0)))
5814    (set (match_operand:GPR 0 "register_operand" "=d")
5815         (neg:GPR (abs:GPR (match_dup 1))))]
5816   "s390_match_ccmode (insn, CCAmode)"
5817   "ln<g>r\t%0,%1"
5818   [(set_attr "op_type"  "RR<E>")])
5819   
5820 (define_insn "*negabs<mode>2_cconly"
5821   [(set (reg 33)
5822         (compare (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
5823                  (const_int 0)))
5824    (clobber (match_scratch:GPR 0 "=d"))]
5825   "s390_match_ccmode (insn, CCAmode)"
5826   "ln<g>r\t%0,%1"
5827   [(set_attr "op_type"  "RR<E>")])
5828   
5829 (define_insn "*negabs<mode>2"
5830   [(set (match_operand:GPR 0 "register_operand" "=d")
5831         (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d"))))
5832    (clobber (reg:CC 33))]
5833   ""
5834   "ln<g>r\t%0,%1"
5835   [(set_attr "op_type" "RR<E>")])
5838 ; Floating point
5841 (define_insn "*negabs<mode>2_cc"
5842   [(set (reg 33)
5843         (compare (neg:FPR (abs:FPR (match_operand:FPR 1 "register_operand" "f")))
5844                  (match_operand:FPR 2 "const0_operand" "")))
5845    (set (match_operand:FPR 0 "register_operand" "=f")
5846         (neg:FPR (abs:FPR (match_dup 1))))]
5847   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5848   "ln<de>br\t%0,%1"
5849   [(set_attr "op_type"  "RRE")
5850    (set_attr "type"     "fsimp<mode>")])
5851   
5852 (define_insn "*negabs<mode>2_cconly"
5853   [(set (reg 33)
5854         (compare (neg:FPR (abs:FPR (match_operand:FPR 1 "register_operand" "f")))
5855                  (match_operand:FPR 2 "const0_operand" "")))
5856    (clobber (match_scratch:FPR 0 "=f"))]
5857   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5858   "ln<de>br\t%0,%1"
5859   [(set_attr "op_type"  "RRE")
5860    (set_attr "type"     "fsimp<mode>")])
5861   
5862 (define_insn "*negabs<mode>2"
5863   [(set (match_operand:FPR 0 "register_operand" "=f")
5864         (neg:FPR (abs:FPR (match_operand:FPR 1 "register_operand" "f"))))
5865    (clobber (reg:CC 33))]
5866   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5867   "ln<de>br\t%0,%1"
5868   [(set_attr "op_type"  "RRE")
5869    (set_attr "type"     "fsimp<mode>")])
5872 ;;- Square root instructions.
5876 ; sqrt(df|sf)2 instruction pattern(s).
5879 (define_insn "sqrt<mode>2"
5880   [(set (match_operand:FPR 0 "register_operand" "=f,f")
5881         (sqrt:FPR (match_operand:FPR 1 "general_operand" "f,R")))]
5882   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
5883   "@
5884    sq<de>br\t%0,%1
5885    sq<de>b\t%0,%1"
5886   [(set_attr "op_type" "RRE,RXE")
5887    (set_attr "type" "fsqrt<mode>")])
5891 ;;- One complement instructions.
5895 ; one_cmpl(di|si|hi|qi)2 instruction pattern(s).
5898 (define_expand "one_cmpl<mode>2"
5899   [(parallel
5900     [(set (match_operand:INT 0 "register_operand" "")
5901           (xor:INT (match_operand:INT 1 "register_operand" "")
5902                    (const_int -1)))
5903      (clobber (reg:CC 33))])]
5904   ""
5905   "")
5909 ;;- Rotate instructions.
5913 ; rotl(di|si)3 instruction pattern(s).
5916 (define_insn "rotl<mode>3"
5917   [(set (match_operand:GPR 0 "register_operand" "=d")
5918         (rotate:GPR (match_operand:GPR 1 "register_operand" "d")
5919                     (match_operand:SI 2 "shift_count_operand" "Y")))]
5920   "TARGET_CPU_ZARCH"
5921   "rll<g>\t%0,%1,%Y2"
5922   [(set_attr "op_type"  "RSE")
5923    (set_attr "atype"    "reg")])
5927 ;;- Shift instructions.
5931 ; (ashl|lshr)di3 instruction pattern(s).
5934 (define_expand "<shift>di3"
5935   [(set (match_operand:DI 0 "register_operand" "")
5936         (SHIFT:DI (match_operand:DI 1 "register_operand" "")
5937                   (match_operand:SI 2 "shift_count_operand" "")))]
5938   ""
5939   "")
5941 (define_insn "*<shift>di3_31"
5942   [(set (match_operand:DI 0 "register_operand" "=d")
5943         (SHIFT:DI (match_operand:DI 1 "register_operand" "0")
5944                   (match_operand:SI 2 "shift_count_operand" "Y")))]
5945   "!TARGET_64BIT"
5946   "s<lr>dl\t%0,%Y2"
5947   [(set_attr "op_type"  "RS")
5948    (set_attr "atype"    "reg")])
5950 (define_insn "*<shift>di3_64"
5951   [(set (match_operand:DI 0 "register_operand" "=d")
5952         (SHIFT:DI (match_operand:DI 1 "register_operand" "d")
5953                   (match_operand:SI 2 "shift_count_operand" "Y")))]
5954   "TARGET_64BIT"
5955   "s<lr>lg\t%0,%1,%Y2"
5956   [(set_attr "op_type"  "RSE")
5957    (set_attr "atype"    "reg")])
5960 ; ashrdi3 instruction pattern(s).
5963 (define_expand "ashrdi3"
5964   [(parallel
5965     [(set (match_operand:DI 0 "register_operand" "")
5966           (ashiftrt:DI (match_operand:DI 1 "register_operand" "")
5967                        (match_operand:SI 2 "shift_count_operand" "")))
5968      (clobber (reg:CC 33))])]
5969   ""
5970   "")
5972 (define_insn "*ashrdi3_cc_31"
5973   [(set (reg 33)
5974         (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
5975                               (match_operand:SI 2 "shift_count_operand" "Y"))
5976                  (const_int 0)))
5977    (set (match_operand:DI 0 "register_operand" "=d")
5978         (ashiftrt:DI (match_dup 1) (match_dup 2)))]
5979   "!TARGET_64BIT && s390_match_ccmode(insn, CCSmode)"
5980   "srda\t%0,%Y2"
5981   [(set_attr "op_type"  "RS")
5982    (set_attr "atype"    "reg")])
5984 (define_insn "*ashrdi3_cconly_31"
5985   [(set (reg 33)
5986         (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
5987                               (match_operand:SI 2 "shift_count_operand" "Y"))
5988                  (const_int 0)))
5989    (clobber (match_scratch:DI 0 "=d"))]
5990   "!TARGET_64BIT && s390_match_ccmode(insn, CCSmode)"
5991   "srda\t%0,%Y2"
5992   [(set_attr "op_type"  "RS")
5993    (set_attr "atype"    "reg")])
5995 (define_insn "*ashrdi3_31"
5996   [(set (match_operand:DI 0 "register_operand" "=d")
5997         (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
5998                      (match_operand:SI 2 "shift_count_operand" "Y")))
5999    (clobber (reg:CC 33))]
6000   "!TARGET_64BIT"
6001   "srda\t%0,%Y2"
6002   [(set_attr "op_type"  "RS")
6003    (set_attr "atype"    "reg")])
6005 (define_insn "*ashrdi3_cc_64"
6006   [(set (reg 33)
6007         (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "d")
6008                               (match_operand:SI 2 "shift_count_operand" "Y"))
6009                  (const_int 0)))
6010    (set (match_operand:DI 0 "register_operand" "=d")
6011         (ashiftrt:DI (match_dup 1) (match_dup 2)))]
6012   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
6013   "srag\t%0,%1,%Y2"
6014   [(set_attr "op_type"  "RSE")
6015    (set_attr "atype"    "reg")])
6017 (define_insn "*ashrdi3_cconly_64"
6018   [(set (reg 33)
6019         (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "d")
6020                               (match_operand:SI 2 "shift_count_operand" "Y"))
6021                  (const_int 0)))
6022    (clobber (match_scratch:DI 0 "=d"))]
6023   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
6024   "srag\t%0,%1,%Y2"
6025   [(set_attr "op_type"  "RSE")
6026    (set_attr "atype"    "reg")])
6028 (define_insn "*ashrdi3_64"
6029   [(set (match_operand:DI 0 "register_operand" "=d")
6030         (ashiftrt:DI (match_operand:DI 1 "register_operand" "d")
6031                      (match_operand:SI 2 "shift_count_operand" "Y")))
6032    (clobber (reg:CC 33))]
6033   "TARGET_64BIT"
6034   "srag\t%0,%1,%Y2"
6035   [(set_attr "op_type"  "RSE")
6036    (set_attr "atype"    "reg")])
6040 ; (ashl|lshr)si3 instruction pattern(s).
6043 (define_insn "<shift>si3"
6044   [(set (match_operand:SI 0 "register_operand" "=d")
6045         (SHIFT:SI (match_operand:SI 1 "register_operand" "0")
6046                   (match_operand:SI 2 "shift_count_operand" "Y")))]
6047   ""
6048   "s<lr>l\t%0,%Y2"
6049   [(set_attr "op_type"  "RS")
6050    (set_attr "atype"    "reg")])
6053 ; ashrsi3 instruction pattern(s).
6056 (define_insn "*ashrsi3_cc"
6057   [(set (reg 33)
6058         (compare (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
6059                               (match_operand:SI 2 "shift_count_operand" "Y"))
6060                  (const_int 0)))
6061    (set (match_operand:SI 0 "register_operand" "=d")
6062         (ashiftrt:SI (match_dup 1) (match_dup 2)))]
6063   "s390_match_ccmode(insn, CCSmode)"
6064   "sra\t%0,%Y2"
6065   [(set_attr "op_type"  "RS")
6066    (set_attr "atype"    "reg")])
6069 (define_insn "*ashrsi3_cconly"
6070   [(set (reg 33)
6071         (compare (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
6072                               (match_operand:SI 2 "shift_count_operand" "Y"))
6073                  (const_int 0)))
6074    (clobber (match_scratch:SI 0 "=d"))]
6075   "s390_match_ccmode(insn, CCSmode)"
6076   "sra\t%0,%Y2"
6077   [(set_attr "op_type"  "RS")
6078    (set_attr "atype"    "reg")])
6080 (define_insn "ashrsi3"
6081   [(set (match_operand:SI 0 "register_operand" "=d")
6082         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0")
6083                      (match_operand:SI 2 "shift_count_operand" "Y")))
6084    (clobber (reg:CC 33))]
6085   ""
6086   "sra\t%0,%Y2"
6087   [(set_attr "op_type"  "RS")
6088    (set_attr "atype"    "reg")])
6092 ;; Branch instruction patterns.
6095 (define_expand "b<code>"
6096   [(set (pc)
6097         (if_then_else (COMPARE (match_operand 0 "" "")
6098                                (const_int 0))
6099                       (match_dup 0)
6100                       (pc)))]
6101   ""
6102   "s390_emit_jump (operands[0],
6103     s390_emit_compare (<CODE>, s390_compare_op0, s390_compare_op1)); DONE;")
6107 ;;- Conditional jump instructions.
6110 (define_insn "*cjump_64"
6111   [(set (pc)
6112         (if_then_else
6113           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6114           (label_ref (match_operand 0 "" ""))
6115           (pc)))]
6116   "TARGET_CPU_ZARCH"
6118   if (get_attr_length (insn) == 4)
6119     return "j%C1\t%l0";
6120   else
6121     return "jg%C1\t%l0";
6123   [(set_attr "op_type" "RI")
6124    (set_attr "type"    "branch")
6125    (set (attr "length")
6126         (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6127                       (const_int 4) (const_int 6)))])
6129 (define_insn "*cjump_31"
6130   [(set (pc)
6131         (if_then_else
6132           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6133           (label_ref (match_operand 0 "" ""))
6134           (pc)))]
6135   "!TARGET_CPU_ZARCH"
6137   if (get_attr_length (insn) == 4)
6138     return "j%C1\t%l0";
6139   else
6140     abort ();
6142   [(set_attr "op_type" "RI")
6143    (set_attr "type"    "branch")
6144    (set (attr "length")
6145         (if_then_else (eq (symbol_ref "flag_pic") (const_int 0))
6146           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6147                         (const_int 4) (const_int 6))
6148           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6149                         (const_int 4) (const_int 8))))])
6151 (define_insn "*cjump_long"
6152   [(set (pc)
6153         (if_then_else
6154           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6155           (match_operand 0 "address_operand" "U")
6156           (pc)))]
6157   ""
6159   if (get_attr_op_type (insn) == OP_TYPE_RR)
6160     return "b%C1r\t%0";
6161   else
6162     return "b%C1\t%a0";
6164   [(set (attr "op_type")
6165         (if_then_else (match_operand 0 "register_operand" "")
6166                       (const_string "RR") (const_string "RX")))
6167    (set_attr "type"  "branch")
6168    (set_attr "atype" "agen")])
6172 ;;- Negated conditional jump instructions.
6175 (define_insn "*icjump_64"
6176   [(set (pc)
6177         (if_then_else
6178           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6179           (pc)
6180           (label_ref (match_operand 0 "" ""))))]
6181   "TARGET_CPU_ZARCH"
6183   if (get_attr_length (insn) == 4)
6184     return "j%D1\t%l0";
6185   else
6186     return "jg%D1\t%l0";
6188   [(set_attr "op_type" "RI")
6189    (set_attr "type"    "branch")
6190    (set (attr "length")
6191         (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6192                       (const_int 4) (const_int 6)))])
6194 (define_insn "*icjump_31"
6195   [(set (pc)
6196         (if_then_else
6197           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6198           (pc)
6199           (label_ref (match_operand 0 "" ""))))]
6200   "!TARGET_CPU_ZARCH"
6202   if (get_attr_length (insn) == 4)
6203     return "j%D1\t%l0";
6204   else
6205     abort ();
6207   [(set_attr "op_type" "RI")
6208    (set_attr "type"    "branch")
6209    (set (attr "length")
6210         (if_then_else (eq (symbol_ref "flag_pic") (const_int 0))
6211           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6212                         (const_int 4) (const_int 6))
6213           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6214                         (const_int 4) (const_int 8))))])
6216 (define_insn "*icjump_long"
6217   [(set (pc)
6218         (if_then_else
6219           (match_operator 1 "s390_comparison" [(reg 33) (const_int 0)])
6220           (pc)
6221           (match_operand 0 "address_operand" "U")))]
6222   ""
6224   if (get_attr_op_type (insn) == OP_TYPE_RR)
6225     return "b%D1r\t%0";
6226   else
6227     return "b%D1\t%a0";
6229   [(set (attr "op_type")
6230         (if_then_else (match_operand 0 "register_operand" "")
6231                       (const_string "RR") (const_string "RX")))
6232    (set_attr "type"  "branch")
6233    (set_attr "atype" "agen")])
6236 ;;- Trap instructions.
6239 (define_insn "trap"
6240   [(trap_if (const_int 1) (const_int 0))]
6241   ""
6242   "j\t.+2"
6243   [(set_attr "op_type" "RI")
6244    (set_attr "type"  "branch")])
6246 (define_expand "conditional_trap"
6247   [(trap_if (match_operand 0 "comparison_operator" "")
6248             (match_operand 1 "general_operand" ""))]
6249   ""
6251   if (operands[1] != const0_rtx) FAIL;
6252   operands[0] = s390_emit_compare (GET_CODE (operands[0]), 
6253                                    s390_compare_op0, s390_compare_op1);
6256 (define_insn "*trap"
6257   [(trap_if (match_operator 0 "s390_comparison" [(reg 33) (const_int 0)])
6258             (const_int 0))]
6259   ""
6260   "j%C0\t.+2";
6261   [(set_attr "op_type" "RI")
6262    (set_attr "type"  "branch")])
6265 ;;- Loop instructions.
6267 ;;  This is all complicated by the fact that since this is a jump insn
6268 ;;  we must handle our own output reloads.
6270 (define_expand "doloop_end"
6271   [(use (match_operand 0 "" ""))        ; loop pseudo
6272    (use (match_operand 1 "" ""))        ; iterations; zero if unknown
6273    (use (match_operand 2 "" ""))        ; max iterations
6274    (use (match_operand 3 "" ""))        ; loop level
6275    (use (match_operand 4 "" ""))]       ; label
6276   ""
6278   if (GET_MODE (operands[0]) == SImode && !TARGET_CPU_ZARCH)
6279     emit_jump_insn (gen_doloop_si31 (operands[4], operands[0], operands[0]));
6280   else if (GET_MODE (operands[0]) == SImode && TARGET_CPU_ZARCH)
6281     emit_jump_insn (gen_doloop_si64 (operands[4], operands[0], operands[0]));
6282   else if (GET_MODE (operands[0]) == DImode && TARGET_64BIT)
6283     emit_jump_insn (gen_doloop_di (operands[4], operands[0], operands[0]));
6284   else
6285     FAIL;
6287   DONE;
6290 (define_insn_and_split "doloop_si64"
6291   [(set (pc)
6292         (if_then_else
6293           (ne (match_operand:SI 1 "register_operand" "d,d")
6294               (const_int 1))
6295           (label_ref (match_operand 0 "" ""))
6296           (pc)))
6297    (set (match_operand:SI 2 "nonimmediate_operand" "=1,?*m*d")
6298         (plus:SI (match_dup 1) (const_int -1)))
6299    (clobber (match_scratch:SI 3 "=X,&1"))
6300    (clobber (reg:CC 33))]
6301   "TARGET_CPU_ZARCH"
6303   if (which_alternative != 0)
6304     return "#";
6305   else if (get_attr_length (insn) == 4)
6306     return "brct\t%1,%l0";
6307   else
6308     return "ahi\t%1,-1\;jgne\t%l0";
6310   "&& reload_completed
6311    && (! REG_P (operands[2])
6312        || ! rtx_equal_p (operands[1], operands[2]))"
6313   [(parallel [(set (reg:CCAN 33)
6314                    (compare:CCAN (plus:SI (match_dup 3) (const_int -1))
6315                                  (const_int 0)))
6316               (set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))])
6317    (set (match_dup 2) (match_dup 3))
6318    (set (pc) (if_then_else (ne (reg:CCAN 33) (const_int 0))
6319                            (label_ref (match_dup 0))
6320                            (pc)))]
6321   ""
6322   [(set_attr "op_type"  "RI")
6323    (set_attr "type"  "branch")
6324    (set (attr "length")
6325         (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6326                       (const_int 4) (const_int 10)))])
6328 (define_insn_and_split "doloop_si31"
6329   [(set (pc)
6330         (if_then_else
6331           (ne (match_operand:SI 1 "register_operand" "d,d")
6332               (const_int 1))
6333           (label_ref (match_operand 0 "" ""))
6334           (pc)))
6335    (set (match_operand:SI 2 "nonimmediate_operand" "=1,?*m*d")
6336         (plus:SI (match_dup 1) (const_int -1)))
6337    (clobber (match_scratch:SI 3 "=X,&1"))
6338    (clobber (reg:CC 33))]
6339   "!TARGET_CPU_ZARCH"
6341   if (which_alternative != 0)
6342     return "#";
6343   else if (get_attr_length (insn) == 4)
6344     return "brct\t%1,%l0";
6345   else
6346     abort ();
6348   "&& reload_completed
6349    && (! REG_P (operands[2])
6350        || ! rtx_equal_p (operands[1], operands[2]))"
6351   [(parallel [(set (reg:CCAN 33)
6352                    (compare:CCAN (plus:SI (match_dup 3) (const_int -1))
6353                                  (const_int 0)))
6354               (set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))])
6355    (set (match_dup 2) (match_dup 3))
6356    (set (pc) (if_then_else (ne (reg:CCAN 33) (const_int 0))
6357                            (label_ref (match_dup 0))
6358                            (pc)))]
6359   ""
6360   [(set_attr "op_type"  "RI")
6361    (set_attr "type"  "branch")
6362    (set (attr "length")
6363         (if_then_else (eq (symbol_ref "flag_pic") (const_int 0))
6364           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6365                         (const_int 4) (const_int 6))
6366           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6367                         (const_int 4) (const_int 8))))])
6369 (define_insn "*doloop_si_long"
6370   [(set (pc)
6371         (if_then_else
6372           (ne (match_operand:SI 1 "register_operand" "d,d")
6373               (const_int 1))
6374           (match_operand 0 "address_operand" "U,U")
6375           (pc)))
6376    (set (match_operand:SI 2 "register_operand" "=1,?*m*d")
6377         (plus:SI (match_dup 1) (const_int -1)))
6378    (clobber (match_scratch:SI 3 "=X,&1"))
6379    (clobber (reg:CC 33))]
6380   "!TARGET_CPU_ZARCH"
6382   if (get_attr_op_type (insn) == OP_TYPE_RR)
6383     return "bctr\t%1,%0";
6384   else
6385     return "bct\t%1,%a0";
6387   [(set (attr "op_type")
6388         (if_then_else (match_operand 0 "register_operand" "")
6389                       (const_string "RR") (const_string "RX")))
6390    (set_attr "type"  "branch")
6391    (set_attr "atype" "agen")])
6393 (define_insn_and_split "doloop_di"
6394   [(set (pc)
6395         (if_then_else
6396           (ne (match_operand:DI 1 "register_operand" "d,d")
6397               (const_int 1))
6398           (label_ref (match_operand 0 "" ""))
6399           (pc)))
6400    (set (match_operand:DI 2 "nonimmediate_operand" "=1,?*m*d")
6401         (plus:DI (match_dup 1) (const_int -1)))
6402    (clobber (match_scratch:DI 3 "=X,&1"))
6403    (clobber (reg:CC 33))]
6404   "TARGET_64BIT"
6406   if (which_alternative != 0)
6407     return "#";
6408   else if (get_attr_length (insn) == 4)
6409     return "brctg\t%1,%l0";
6410   else
6411     return "aghi\t%1,-1\;jgne\t%l0";
6413   "&& reload_completed
6414    && (! REG_P (operands[2])
6415        || ! rtx_equal_p (operands[1], operands[2]))"
6416   [(parallel [(set (reg:CCAN 33)
6417                    (compare:CCAN (plus:DI (match_dup 3) (const_int -1))
6418                                  (const_int 0)))
6419               (set (match_dup 3) (plus:DI (match_dup 3) (const_int -1)))])
6420    (set (match_dup 2) (match_dup 3))
6421    (set (pc) (if_then_else (ne (reg:CCAN 33) (const_int 0))
6422                            (label_ref (match_dup 0))
6423                            (pc)))]
6424   ""
6425   [(set_attr "op_type"  "RI")
6426    (set_attr "type"  "branch")
6427    (set (attr "length")
6428         (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6429                       (const_int 4) (const_int 10)))])
6432 ;;- Unconditional jump instructions.
6436 ; jump instruction pattern(s).
6439 (define_expand "jump"
6440   [(match_operand 0 "" "")]
6441   ""
6442   "s390_emit_jump (operands[0], NULL_RTX); DONE;")
6444 (define_insn "*jump64"
6445   [(set (pc) (label_ref (match_operand 0 "" "")))]
6446   "TARGET_CPU_ZARCH"
6448   if (get_attr_length (insn) == 4)
6449     return "j\t%l0";
6450   else
6451     return "jg\t%l0";
6453   [(set_attr "op_type" "RI")
6454    (set_attr "type"  "branch")
6455    (set (attr "length")
6456         (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6457                       (const_int 4) (const_int 6)))])
6459 (define_insn "*jump31"
6460   [(set (pc) (label_ref (match_operand 0 "" "")))]
6461   "!TARGET_CPU_ZARCH"
6463   if (get_attr_length (insn) == 4)
6464     return "j\t%l0";
6465   else
6466     abort ();
6468   [(set_attr "op_type" "RI")
6469    (set_attr "type"  "branch")
6470    (set (attr "length")
6471         (if_then_else (eq (symbol_ref "flag_pic") (const_int 0))
6472           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6473                         (const_int 4) (const_int 6))
6474           (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
6475                         (const_int 4) (const_int 8))))])
6478 ; indirect-jump instruction pattern(s).
6481 (define_insn "indirect_jump"
6482  [(set (pc) (match_operand 0 "address_operand" "U"))]
6483   ""
6485   if (get_attr_op_type (insn) == OP_TYPE_RR)
6486     return "br\t%0";
6487   else
6488     return "b\t%a0";
6490   [(set (attr "op_type")
6491         (if_then_else (match_operand 0 "register_operand" "")
6492                       (const_string "RR") (const_string "RX")))
6493    (set_attr "type"  "branch")
6494    (set_attr "atype" "agen")])
6497 ; casesi instruction pattern(s).
6500 (define_insn "casesi_jump"
6501  [(set (pc) (match_operand 0 "address_operand" "U"))
6502    (use (label_ref (match_operand 1 "" "")))]
6503   ""
6505   if (get_attr_op_type (insn) == OP_TYPE_RR)
6506     return "br\t%0";
6507   else
6508     return "b\t%a0";
6510   [(set (attr "op_type")
6511         (if_then_else (match_operand 0 "register_operand" "")
6512                       (const_string "RR") (const_string "RX")))
6513    (set_attr "type"  "branch")
6514    (set_attr "atype" "agen")])
6516 (define_expand "casesi"
6517   [(match_operand:SI 0 "general_operand" "")
6518    (match_operand:SI 1 "general_operand" "")
6519    (match_operand:SI 2 "general_operand" "")
6520    (label_ref (match_operand 3 "" ""))
6521    (label_ref (match_operand 4 "" ""))]
6522   ""
6524    rtx index  = gen_reg_rtx (SImode);
6525    rtx base   = gen_reg_rtx (Pmode);
6526    rtx target = gen_reg_rtx (Pmode);
6528    emit_move_insn (index, operands[0]);
6529    emit_insn (gen_subsi3 (index, index, operands[1]));
6530    emit_cmp_and_jump_insns (index, operands[2], GTU, NULL_RTX, SImode, 1,
6531                             operands[4]);
6533    if (Pmode != SImode)
6534      index = convert_to_mode (Pmode, index, 1);
6535    if (GET_CODE (index) != REG)
6536      index = copy_to_mode_reg (Pmode, index);
6538    if (TARGET_64BIT)
6539        emit_insn (gen_ashldi3 (index, index, GEN_INT (3)));
6540    else
6541        emit_insn (gen_ashlsi3 (index, index, const2_rtx));
6543    emit_move_insn (base, gen_rtx_LABEL_REF (Pmode, operands[3]));
6545    index = gen_const_mem (Pmode, gen_rtx_PLUS (Pmode, base, index));
6546    emit_move_insn (target, index);
6548    if (flag_pic)
6549      target = gen_rtx_PLUS (Pmode, base, target);
6550    emit_jump_insn (gen_casesi_jump (target, operands[3]));
6552    DONE;
6557 ;;- Jump to subroutine.
6562 ; untyped call instruction pattern(s).
6565 ;; Call subroutine returning any type.
6566 (define_expand "untyped_call"
6567   [(parallel [(call (match_operand 0 "" "")
6568                     (const_int 0))
6569               (match_operand 1 "" "")
6570               (match_operand 2 "" "")])]
6571   ""
6573   int i;
6575   emit_call_insn (gen_call (operands[0], const0_rtx, const0_rtx));
6577   for (i = 0; i < XVECLEN (operands[2], 0); i++)
6578     {
6579       rtx set = XVECEXP (operands[2], 0, i);
6580       emit_move_insn (SET_DEST (set), SET_SRC (set));
6581     }
6583   /* The optimizer does not know that the call sets the function value
6584      registers we stored in the result block.  We avoid problems by
6585      claiming that all hard registers are used and clobbered at this
6586      point.  */
6587   emit_insn (gen_blockage ());
6589   DONE;
6592 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
6593 ;; all of memory.  This blocks insns from being moved across this point.
6595 (define_insn "blockage"
6596   [(unspec_volatile [(const_int 0)] UNSPECV_BLOCKAGE)]
6597   ""
6598   ""
6599   [(set_attr "type"    "none")
6600    (set_attr "length"  "0")])
6603 ; sibcall patterns
6606 (define_expand "sibcall"
6607   [(call (match_operand 0 "" "")
6608          (match_operand 1 "" ""))]
6609   ""
6611   s390_emit_call (XEXP (operands[0], 0), NULL_RTX, NULL_RTX, NULL_RTX);
6612   DONE;
6615 (define_insn "*sibcall_br"
6616   [(call (mem:QI (reg 1))
6617          (match_operand 0 "const_int_operand" "n"))]
6618   "SIBLING_CALL_P (insn)
6619    && GET_MODE (XEXP (XEXP (PATTERN (insn), 0), 0)) == Pmode"
6620   "br\t%%r1"
6621   [(set_attr "op_type" "RR")
6622    (set_attr "type"  "branch")
6623    (set_attr "atype" "agen")])
6625 (define_insn "*sibcall_brc"
6626   [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
6627          (match_operand 1 "const_int_operand" "n"))]
6628   "SIBLING_CALL_P (insn) && TARGET_SMALL_EXEC"
6629   "j\t%0"
6630   [(set_attr "op_type" "RI")
6631    (set_attr "type"    "branch")])
6633 (define_insn "*sibcall_brcl"
6634   [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
6635          (match_operand 1 "const_int_operand" "n"))]
6636   "SIBLING_CALL_P (insn) && TARGET_CPU_ZARCH"
6637   "jg\t%0"
6638   [(set_attr "op_type" "RIL")
6639    (set_attr "type"    "branch")])
6642 ; sibcall_value patterns
6645 (define_expand "sibcall_value"
6646   [(set (match_operand 0 "" "")
6647         (call (match_operand 1 "" "")
6648               (match_operand 2 "" "")))]
6649   ""
6651   s390_emit_call (XEXP (operands[1], 0), NULL_RTX, operands[0], NULL_RTX);
6652   DONE;
6655 (define_insn "*sibcall_value_br"
6656   [(set (match_operand 0 "" "")
6657         (call (mem:QI (reg 1))
6658               (match_operand 1 "const_int_operand" "n")))]
6659   "SIBLING_CALL_P (insn)
6660    && GET_MODE (XEXP (XEXP (XEXP (PATTERN (insn), 1), 0), 0)) == Pmode"
6661   "br\t%%r1"
6662   [(set_attr "op_type" "RR")
6663    (set_attr "type"  "branch")
6664    (set_attr "atype" "agen")])
6666 (define_insn "*sibcall_value_brc"
6667   [(set (match_operand 0 "" "")
6668         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6669               (match_operand 2 "const_int_operand" "n")))]
6670   "SIBLING_CALL_P (insn) && TARGET_SMALL_EXEC"
6671   "j\t%1"
6672   [(set_attr "op_type" "RI")
6673    (set_attr "type"    "branch")])
6675 (define_insn "*sibcall_value_brcl"
6676   [(set (match_operand 0 "" "")
6677         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6678               (match_operand 2 "const_int_operand" "n")))]
6679   "SIBLING_CALL_P (insn) && TARGET_CPU_ZARCH"
6680   "jg\t%1"
6681   [(set_attr "op_type" "RIL")
6682    (set_attr "type"    "branch")])
6686 ; call instruction pattern(s).
6689 (define_expand "call"
6690   [(call (match_operand 0 "" "")
6691          (match_operand 1 "" ""))
6692    (use (match_operand 2 "" ""))]
6693   ""
6695   s390_emit_call (XEXP (operands[0], 0), NULL_RTX, NULL_RTX,
6696                   gen_rtx_REG (Pmode, RETURN_REGNUM));
6697   DONE;
6700 (define_insn "*bras"
6701   [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
6702          (match_operand 1 "const_int_operand" "n"))
6703    (clobber (match_operand 2 "register_operand" "=r"))]
6704   "!SIBLING_CALL_P (insn)
6705    && TARGET_SMALL_EXEC
6706    && GET_MODE (operands[2]) == Pmode"
6707   "bras\t%2,%0"
6708   [(set_attr "op_type" "RI")
6709    (set_attr "type"    "jsr")])
6711 (define_insn "*brasl"
6712   [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
6713          (match_operand 1 "const_int_operand" "n"))
6714    (clobber (match_operand 2 "register_operand" "=r"))]
6715   "!SIBLING_CALL_P (insn)
6716    && TARGET_CPU_ZARCH
6717    && GET_MODE (operands[2]) == Pmode"
6718   "brasl\t%2,%0"
6719   [(set_attr "op_type" "RIL")
6720    (set_attr "type"    "jsr")])
6722 (define_insn "*basr"
6723   [(call (mem:QI (match_operand 0 "address_operand" "U"))
6724          (match_operand 1 "const_int_operand" "n"))
6725    (clobber (match_operand 2 "register_operand" "=r"))]
6726   "!SIBLING_CALL_P (insn) && GET_MODE (operands[2]) == Pmode"
6728   if (get_attr_op_type (insn) == OP_TYPE_RR)
6729     return "basr\t%2,%0";
6730   else
6731     return "bas\t%2,%a0";
6733   [(set (attr "op_type")
6734         (if_then_else (match_operand 0 "register_operand" "")
6735                       (const_string "RR") (const_string "RX")))
6736    (set_attr "type"  "jsr")
6737    (set_attr "atype" "agen")])
6740 ; call_value instruction pattern(s).
6743 (define_expand "call_value"
6744   [(set (match_operand 0 "" "")
6745         (call (match_operand 1 "" "")
6746               (match_operand 2 "" "")))
6747    (use (match_operand 3 "" ""))]
6748   ""
6750   s390_emit_call (XEXP (operands[1], 0), NULL_RTX, operands[0],
6751                   gen_rtx_REG (Pmode, RETURN_REGNUM));
6752   DONE;
6755 (define_insn "*bras_r"
6756   [(set (match_operand 0 "" "")
6757         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6758               (match_operand:SI 2 "const_int_operand" "n")))
6759    (clobber (match_operand 3 "register_operand" "=r"))]
6760   "!SIBLING_CALL_P (insn)
6761    && TARGET_SMALL_EXEC
6762    && GET_MODE (operands[3]) == Pmode"
6763   "bras\t%3,%1"
6764   [(set_attr "op_type" "RI")
6765    (set_attr "type"    "jsr")])
6767 (define_insn "*brasl_r"
6768   [(set (match_operand 0 "" "")
6769         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6770               (match_operand 2 "const_int_operand" "n")))
6771    (clobber (match_operand 3 "register_operand" "=r"))]
6772   "!SIBLING_CALL_P (insn)
6773    && TARGET_CPU_ZARCH
6774    && GET_MODE (operands[3]) == Pmode"
6775   "brasl\t%3,%1"
6776   [(set_attr "op_type" "RIL")
6777    (set_attr "type"    "jsr")])
6779 (define_insn "*basr_r"
6780   [(set (match_operand 0 "" "")
6781         (call (mem:QI (match_operand 1 "address_operand" "U"))
6782               (match_operand 2 "const_int_operand" "n")))
6783    (clobber (match_operand 3 "register_operand" "=r"))]
6784   "!SIBLING_CALL_P (insn) && GET_MODE (operands[3]) == Pmode"
6786   if (get_attr_op_type (insn) == OP_TYPE_RR)
6787     return "basr\t%3,%1";
6788   else
6789     return "bas\t%3,%a1";
6791   [(set (attr "op_type")
6792         (if_then_else (match_operand 1 "register_operand" "")
6793                       (const_string "RR") (const_string "RX")))
6794    (set_attr "type"  "jsr")
6795    (set_attr "atype" "agen")])
6798 ;;- Thread-local storage support.
6801 (define_expand "get_tp_64"
6802   [(set (match_operand:DI 0 "nonimmediate_operand" "") (reg:DI 36))]
6803   "TARGET_64BIT"
6804   "")
6806 (define_expand "get_tp_31"
6807   [(set (match_operand:SI 0 "nonimmediate_operand" "") (reg:SI 36))]
6808   "!TARGET_64BIT"
6809   "")
6811 (define_expand "set_tp_64"
6812   [(set (reg:DI 36) (match_operand:DI 0 "nonimmediate_operand" ""))
6813    (set (reg:DI 36) (unspec_volatile:DI [(reg:DI 36)] UNSPECV_SET_TP))]
6814   "TARGET_64BIT"
6815   "")
6817 (define_expand "set_tp_31"
6818   [(set (reg:SI 36) (match_operand:SI 0 "nonimmediate_operand" ""))
6819    (set (reg:SI 36) (unspec_volatile:SI [(reg:SI 36)] UNSPECV_SET_TP))]
6820   "!TARGET_64BIT"
6821   "")
6823 (define_insn "*set_tp"
6824   [(set (reg 36) (unspec_volatile [(reg 36)] UNSPECV_SET_TP))]
6825   ""
6826   ""
6827   [(set_attr "type" "none")
6828    (set_attr "length" "0")])
6830 (define_insn "*tls_load_64"
6831   [(set (match_operand:DI 0 "register_operand" "=d")
6832         (unspec:DI [(match_operand:DI 1 "memory_operand" "m")
6833                     (match_operand:DI 2 "" "")]
6834                    UNSPEC_TLS_LOAD))]
6835   "TARGET_64BIT"
6836   "lg\t%0,%1%J2"
6837   [(set_attr "op_type" "RXE")])
6839 (define_insn "*tls_load_31"
6840   [(set (match_operand:SI 0 "register_operand" "=d,d")
6841         (unspec:SI [(match_operand:SI 1 "memory_operand" "R,T")
6842                     (match_operand:SI 2 "" "")]
6843                    UNSPEC_TLS_LOAD))]
6844   "!TARGET_64BIT"
6845   "@
6846    l\t%0,%1%J2
6847    ly\t%0,%1%J2"
6848   [(set_attr "op_type" "RX,RXY")])
6850 (define_insn "*bras_tls"
6851   [(set (match_operand 0 "" "")
6852         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6853               (match_operand 2 "const_int_operand" "n")))
6854    (clobber (match_operand 3 "register_operand" "=r"))
6855    (use (match_operand 4 "" ""))]
6856   "!SIBLING_CALL_P (insn)
6857    && TARGET_SMALL_EXEC
6858    && GET_MODE (operands[3]) == Pmode"
6859   "bras\t%3,%1%J4"
6860   [(set_attr "op_type" "RI")
6861    (set_attr "type"    "jsr")])
6863 (define_insn "*brasl_tls"
6864   [(set (match_operand 0 "" "")
6865         (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
6866               (match_operand 2 "const_int_operand" "n")))
6867    (clobber (match_operand 3 "register_operand" "=r"))
6868    (use (match_operand 4 "" ""))]
6869   "!SIBLING_CALL_P (insn)
6870    && TARGET_CPU_ZARCH
6871    && GET_MODE (operands[3]) == Pmode"
6872   "brasl\t%3,%1%J4"
6873   [(set_attr "op_type" "RIL")
6874    (set_attr "type"    "jsr")])
6876 (define_insn "*basr_tls"
6877   [(set (match_operand 0 "" "")
6878         (call (mem:QI (match_operand 1 "address_operand" "U"))
6879               (match_operand 2 "const_int_operand" "n")))
6880    (clobber (match_operand 3 "register_operand" "=r"))
6881    (use (match_operand 4 "" ""))]
6882   "!SIBLING_CALL_P (insn) && GET_MODE (operands[3]) == Pmode"
6884   if (get_attr_op_type (insn) == OP_TYPE_RR)
6885     return "basr\t%3,%1%J4";
6886   else
6887     return "bas\t%3,%a1%J4";
6889   [(set (attr "op_type")
6890         (if_then_else (match_operand 1 "register_operand" "")
6891                       (const_string "RR") (const_string "RX")))
6892    (set_attr "type"  "jsr")
6893    (set_attr "atype" "agen")])
6896 ;;- Miscellaneous instructions.
6900 ; allocate stack instruction pattern(s).
6903 (define_expand "allocate_stack"
6904   [(match_operand 0 "general_operand" "")
6905    (match_operand 1 "general_operand" "")]
6906  "TARGET_BACKCHAIN"
6908   rtx temp = gen_reg_rtx (Pmode);
6910   emit_move_insn (temp, s390_back_chain_rtx ());
6911   anti_adjust_stack (operands[1]);
6912   emit_move_insn (s390_back_chain_rtx (), temp);
6914   emit_move_insn (operands[0], virtual_stack_dynamic_rtx);
6915   DONE;
6920 ; setjmp instruction pattern.
6923 (define_expand "builtin_setjmp_receiver"
6924   [(match_operand 0 "" "")]
6925   "flag_pic"
6927   emit_insn (s390_load_got ());
6928   emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
6929   DONE;
6932 ;; These patterns say how to save and restore the stack pointer.  We need not
6933 ;; save the stack pointer at function level since we are careful to
6934 ;; preserve the backchain.  At block level, we have to restore the backchain
6935 ;; when we restore the stack pointer.
6937 ;; For nonlocal gotos, we must save both the stack pointer and its
6938 ;; backchain and restore both.  Note that in the nonlocal case, the
6939 ;; save area is a memory location.
6941 (define_expand "save_stack_function"
6942   [(match_operand 0 "general_operand" "")
6943    (match_operand 1 "general_operand" "")]
6944   ""
6945   "DONE;")
6947 (define_expand "restore_stack_function"
6948   [(match_operand 0 "general_operand" "")
6949    (match_operand 1 "general_operand" "")]
6950   ""
6951   "DONE;")
6953 (define_expand "restore_stack_block"
6954   [(match_operand 0 "register_operand" "")
6955    (match_operand 1 "register_operand" "")]
6956   "TARGET_BACKCHAIN"
6958   rtx temp = gen_reg_rtx (Pmode);
6960   emit_move_insn (temp, s390_back_chain_rtx ());
6961   emit_move_insn (operands[0], operands[1]);
6962   emit_move_insn (s390_back_chain_rtx (), temp);
6964   DONE;
6967 (define_expand "save_stack_nonlocal"
6968   [(match_operand 0 "memory_operand" "")
6969    (match_operand 1 "register_operand" "")]
6970   ""
6972   enum machine_mode mode = TARGET_64BIT ? OImode : TImode;
6973   rtx base = gen_rtx_REG (Pmode, BASE_REGNUM);
6975   /* Copy the backchain to the first word, sp to the second and the
6976      literal pool base to the third.  */
6978   if (TARGET_BACKCHAIN)
6979     {
6980       rtx temp = force_reg (Pmode, s390_back_chain_rtx ());
6981       emit_move_insn (operand_subword (operands[0], 0, 0, mode), temp);
6982     }
6984   emit_move_insn (operand_subword (operands[0], 1, 0, mode), operands[1]);
6985   emit_move_insn (operand_subword (operands[0], 2, 0, mode), base);
6987   DONE;
6990 (define_expand "restore_stack_nonlocal"
6991   [(match_operand 0 "register_operand" "")
6992    (match_operand 1 "memory_operand" "")]
6993   ""
6995   enum machine_mode mode = TARGET_64BIT ? OImode : TImode;
6996   rtx base = gen_rtx_REG (Pmode, BASE_REGNUM);
6997   rtx temp = NULL_RTX;
6999   /* Restore the backchain from the first word, sp from the second and the
7000      literal pool base from the third.  */
7002   if (TARGET_BACKCHAIN)
7003     temp = force_reg (Pmode, operand_subword (operands[1], 0, 0, mode));
7004     
7005   emit_move_insn (base, operand_subword (operands[1], 2, 0, mode));
7006   emit_move_insn (operands[0], operand_subword (operands[1], 1, 0, mode));
7008   if (temp)
7009     emit_move_insn (s390_back_chain_rtx (), temp);
7011   emit_insn (gen_rtx_USE (VOIDmode, base));
7012   DONE;
7017 ; nop instruction pattern(s).
7020 (define_insn "nop"
7021   [(const_int 0)]
7022   ""
7023   "lr\t0,0"
7024   [(set_attr "op_type" "RR")])
7028 ; Special literal pool access instruction pattern(s).
7031 (define_insn "*pool_entry"
7032   [(unspec_volatile [(match_operand 0 "consttable_operand" "X")]
7033                     UNSPECV_POOL_ENTRY)]
7034   ""
7036   enum machine_mode mode = GET_MODE (PATTERN (insn));
7037   unsigned int align = GET_MODE_BITSIZE (mode);
7038   s390_output_pool_entry (operands[0], mode, align);
7039   return "";
7041   [(set (attr "length")
7042         (symbol_ref "GET_MODE_SIZE (GET_MODE (PATTERN (insn)))"))])
7044 (define_insn "pool_align"
7045   [(unspec_volatile [(match_operand 0 "const_int_operand" "n")]
7046                     UNSPECV_POOL_ALIGN)]
7047   ""
7048   ".align\t%0"
7049   [(set (attr "length") (symbol_ref "INTVAL (operands[0])"))])
7051 (define_insn "pool_section_start"
7052   [(unspec_volatile [(const_int 1)] UNSPECV_POOL_SECTION)]
7053   ""
7054   ".section\t.rodata"
7055   [(set_attr "length" "0")])
7057 (define_insn "pool_section_end"
7058   [(unspec_volatile [(const_int 0)] UNSPECV_POOL_SECTION)]
7059   ""
7060   ".previous"
7061   [(set_attr "length" "0")])
7063 (define_insn "main_base_31_small"
7064   [(set (match_operand 0 "register_operand" "=a")
7065         (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))]
7066   "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
7067   "basr\t%0,0"
7068   [(set_attr "op_type" "RR")
7069    (set_attr "type"    "la")])
7071 (define_insn "main_base_31_large"
7072   [(set (match_operand 0 "register_operand" "=a")
7073         (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))
7074    (set (pc) (label_ref (match_operand 2 "" "")))]
7075   "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
7076   "bras\t%0,%2"
7077   [(set_attr "op_type" "RI")])
7079 (define_insn "main_base_64"
7080   [(set (match_operand 0 "register_operand" "=a")
7081         (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))]
7082   "TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
7083   "larl\t%0,%1"
7084   [(set_attr "op_type" "RIL")
7085    (set_attr "type"    "larl")])
7087 (define_insn "main_pool"
7088   [(set (match_operand 0 "register_operand" "=a")
7089         (unspec_volatile [(const_int 0)] UNSPECV_MAIN_POOL))]
7090   "GET_MODE (operands[0]) == Pmode"
7091   "* abort ();"
7092   [(set (attr "type") 
7093         (if_then_else (ne (symbol_ref "TARGET_CPU_ZARCH") (const_int 0))
7094                       (const_string "larl") (const_string "la")))])
7096 (define_insn "reload_base_31"
7097   [(set (match_operand 0 "register_operand" "=a")
7098         (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_RELOAD_BASE))]
7099   "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
7100   "basr\t%0,0\;la\t%0,%1-.(%0)"
7101   [(set_attr "length" "6")
7102    (set_attr "type" "la")])
7104 (define_insn "reload_base_64"
7105   [(set (match_operand 0 "register_operand" "=a")
7106         (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_RELOAD_BASE))]
7107   "TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
7108   "larl\t%0,%1"
7109   [(set_attr "op_type" "RIL")
7110    (set_attr "type"    "larl")])
7112 (define_insn "pool"
7113   [(unspec_volatile [(match_operand 0 "const_int_operand" "n")] UNSPECV_POOL)]
7114   ""
7115   "* abort ();"
7116   [(set (attr "length") (symbol_ref "INTVAL (operands[0])"))])
7119 ;; Insns related to generating the function prologue and epilogue.
7123 (define_expand "prologue"
7124   [(use (const_int 0))]
7125   ""
7126   "s390_emit_prologue (); DONE;")
7128 (define_insn "prologue_tpf"
7129   [(unspec_volatile [(const_int 0)] UNSPECV_TPF_PROLOGUE)
7130    (clobber (reg:DI 1))]
7131   "TARGET_TPF_PROFILING"
7132   "larl\t%%r1,.+14\;tm\t4065,255\;bnz\t4064"
7133   [(set_attr "length"   "14")])
7135 (define_expand "epilogue"
7136   [(use (const_int 1))]
7137   ""
7138   "s390_emit_epilogue (false); DONE;")
7140 (define_insn "epilogue_tpf"
7141   [(unspec_volatile [(const_int 0)] UNSPECV_TPF_EPILOGUE)
7142    (clobber (reg:DI 1))]
7143   "TARGET_TPF_PROFILING"
7144   "larl\t%%r1,.+14\;tm\t4071,255\;bnz\t4070"
7145   [(set_attr "length"   "14")])
7147 (define_expand "sibcall_epilogue"
7148   [(use (const_int 0))]
7149   ""
7150   "s390_emit_epilogue (true); DONE;")
7152 (define_insn "*return"
7153   [(return)
7154    (use (match_operand 0 "register_operand" "a"))]
7155   "GET_MODE (operands[0]) == Pmode"
7156   "br\t%0"
7157   [(set_attr "op_type" "RR")
7158    (set_attr "type"    "jsr")
7159    (set_attr "atype"   "agen")])
7162 ;; Instruction definition to extend a 31-bit pointer into a 64-bit
7163 ;; pointer. This is used for compatibility.
7165 (define_expand "ptr_extend"
7166   [(set (match_operand:DI 0 "register_operand" "=r")
7167         (match_operand:SI 1 "register_operand" "r"))]
7168   "TARGET_64BIT"
7170   emit_insn (gen_anddi3 (operands[0],
7171                          gen_lowpart (DImode, operands[1]),
7172                          GEN_INT (0x7fffffff)));
7173   DONE;
7176 ;; Instruction definition to expand eh_return macro to support
7177 ;; swapping in special linkage return addresses.
7179 (define_expand "eh_return"
7180   [(use (match_operand 0 "register_operand" ""))]
7181   "TARGET_TPF"
7183   s390_emit_tpf_eh_return (operands[0]);
7184   DONE;