OSDN Git Service

7c6e82178b1db7e6e8435f3932fd3a8cf4276c68
[pf3gnuchains/gcc-fork.git] / gcc / config / s390 / s390.md
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).
6
7 ;; This file is part of GCC.
8
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.
13
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.
18
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.
23
24 ;;
25 ;; Special constraints for s/390 machine description:
26 ;;
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)
42 ;;
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.
59 ;;
60 ;; Special formats used for outputting 390 instructions.
61 ;;
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.
70
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
76
77 ;;
78 ;; We have a special constraint for pattern matching.
79 ;;
80 ;;   s_operand -- Matches a valid S operand in a RS, SI or SS type instruction.
81 ;;
82
83 ;;
84 ;; UNSPEC usage
85 ;;
86
87 (define_constants
88   [; Miscellaneous
89    (UNSPEC_ROUND                1)
90    (UNSPEC_CMPINT               2)
91    (UNSPEC_SETHIGH              10)
92
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)
101
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)
108
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)
116
117    ; TLS support
118    (UNSPEC_TLSLDM_NTPOFF        511)
119    (UNSPEC_TLS_LOAD             512)
120
121    ; String Functions
122    (UNSPEC_SRST         600)
123  ])
124
125 ;;
126 ;; UNSPEC_VOLATILE usage
127 ;;
128
129 (define_constants
130   [; Blockage
131    (UNSPECV_BLOCKAGE            0)
132
133    ; TPF Support
134    (UNSPECV_TPF_PROLOGUE        20)
135    (UNSPECV_TPF_EPILOGUE        21)
136
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)
143
144    ; TLS support
145    (UNSPECV_SET_TP              500)
146   ])
147
148 ;;
149 ;; Registers
150 ;;
151
152 (define_constants
153   [
154    ; Sibling call register.
155    (SIBCALL_REGNUM               1)
156    ; Literal pool base register.
157    (BASE_REGNUM                 13)
158    ; Return address register.
159    (RETURN_REGNUM               14)
160    ; Condition code register.
161    (CC_REGNUM                   33)
162    ; Thread local storage pointer register. 
163    (TP_REGNUM                   36)
164   ])
165
166
167 ;; Instruction operand type as used in the Principles of Operation.
168 ;; Used to determine defaults for length and other attribute values.
169
170 (define_attr "op_type"
171   "NN,E,RR,RRE,RX,RS,RSI,RI,SI,S,SS,SSE,RXE,RSE,RIL,RIE,RXY,RSY,SIY"
172   (const_string "NN"))
173
174 ;; Instruction type attribute used for scheduling.
175
176 (define_attr "type" "none,integer,load,lr,la,larl,lm,stm,
177                      cs,vs,store,idiv,
178                      imulhi,imulsi,imuldi,
179                      branch,jsr,fsimpdf,fsimpsf,
180                      floaddf,floadsf,fstoredf,fstoresf,
181                      fmuldf,fmulsf,fdivdf,fdivsf,
182                      ftoi,itof,fsqrtdf,fsqrtsf,
183                      other"
184   (cond [(eq_attr "op_type" "NN")  (const_string "other")
185          (eq_attr "op_type" "SS")  (const_string "cs")]
186     (const_string "integer")))
187
188 ;; Another attribute used for scheduling purposes:
189 ;;   agen: Instruction uses the address generation unit
190 ;;   reg: Instruction does not use the agen unit
191
192 (define_attr "atype" "agen,reg"
193   (cond [(eq_attr "op_type" "E")   (const_string "reg")
194          (eq_attr "op_type" "RR")  (const_string "reg")
195          (eq_attr "op_type" "RX")  (const_string "agen")
196          (eq_attr "op_type" "RI")  (const_string "reg")
197          (eq_attr "op_type" "RRE") (const_string "reg")
198          (eq_attr "op_type" "RS")  (const_string "agen")
199          (eq_attr "op_type" "RSI") (const_string "agen")
200          (eq_attr "op_type" "S")   (const_string "agen")
201          (eq_attr "op_type" "SI")  (const_string "agen")
202          (eq_attr "op_type" "SS")  (const_string "agen")
203          (eq_attr "op_type" "SSE") (const_string "agen")
204          (eq_attr "op_type" "RXE") (const_string "agen")
205          (eq_attr "op_type" "RSE") (const_string "agen")
206          (eq_attr "op_type" "RIL") (const_string "agen")
207          (eq_attr "op_type" "RXY") (const_string "agen")
208          (eq_attr "op_type" "RSY") (const_string "agen")
209          (eq_attr "op_type" "SIY") (const_string "agen")]
210     (const_string "agen")))
211
212 ;; Length in bytes.
213
214 (define_attr "length" ""
215   (cond [(eq_attr "op_type" "E")   (const_int 2)
216          (eq_attr "op_type" "RR")  (const_int 2)
217          (eq_attr "op_type" "RX")  (const_int 4)
218          (eq_attr "op_type" "RI")  (const_int 4)
219          (eq_attr "op_type" "RRE") (const_int 4)
220          (eq_attr "op_type" "RS")  (const_int 4)
221          (eq_attr "op_type" "RSI") (const_int 4)
222          (eq_attr "op_type" "S")   (const_int 4)
223          (eq_attr "op_type" "SI")  (const_int 4)
224          (eq_attr "op_type" "SS")  (const_int 6)
225          (eq_attr "op_type" "SSE") (const_int 6)
226          (eq_attr "op_type" "RXE") (const_int 6)
227          (eq_attr "op_type" "RSE") (const_int 6)
228          (eq_attr "op_type" "RIL") (const_int 6)
229          (eq_attr "op_type" "RXY") (const_int 6)
230          (eq_attr "op_type" "RSY") (const_int 6)
231          (eq_attr "op_type" "SIY") (const_int 6)]
232     (const_int 6)))
233
234
235 ;; Processor type.  This attribute must exactly match the processor_type
236 ;; enumeration in s390.h.  The current machine description does not
237 ;; distinguish between g5 and g6, but there are differences between the two
238 ;; CPUs could in theory be modeled.
239
240 (define_attr "cpu" "g5,g6,z900,z990"
241   (const (symbol_ref "s390_tune")))
242
243 ;; Pipeline description for z900.  For lack of anything better,
244 ;; this description is also used for the g5 and g6.
245 (include "2064.md")
246
247 ;; Pipeline description for z990. 
248 (include "2084.md")
249
250 ;; Predicates
251 (include "predicates.md")
252
253
254 ;; Macros
255
256 ;; This mode macro allows DF and SF patterns to be generated from the
257 ;; same template.
258 (define_mode_macro FPR     [DF SF])
259
260 ;; These mode macros allow 31-bit and 64-bit GPR patterns to be generated
261 ;; from the same template.
262 (define_mode_macro GPR [(DI "TARGET_64BIT") SI])
263 (define_mode_macro DSI [DI SI])
264
265 ;; This mode macro allows :P to be used for patterns that operate on
266 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
267 (define_mode_macro P [(DI "TARGET_64BIT") (SI "!TARGET_64BIT")])
268
269 ;; This mode macro allows the QI and HI patterns to be defined from
270 ;; the same template.
271 (define_mode_macro HQI [HI QI])
272
273 ;; This mode macro allows the integer patterns to be defined from the
274 ;; same template.
275 (define_mode_macro INT [(DI "TARGET_64BIT") SI HI QI])
276
277 ;; This macro allows to unify all 'bCOND' expander patterns.
278 (define_code_macro COMPARE [eq ne gt gtu lt ltu ge geu le leu unordered 
279                             ordered uneq unlt ungt unle unge ltgt])
280
281 ;; This macro allows to unify all 'sCOND' patterns.
282 (define_code_macro SCOND [ltu gtu leu geu])
283
284 ;; This macro allows some 'ashift' and 'lshiftrt' pattern to be defined from
285 ;; the same template.
286 (define_code_macro SHIFT [ashift lshiftrt])
287
288
289 ;; In FPR templates, a string like "lt<de>br" will expand to "ltdbr" in DFmode
290 ;; and "ltebr" in SFmode.
291 (define_mode_attr de [(DF "d") (SF "e")])
292
293 ;; In FPR templates, a string like "m<dee>br" will expand to "mdbr" in DFmode
294 ;; and "meebr" in SFmode.  This is needed for the 'mul<mode>3' pattern. 
295 (define_mode_attr dee [(DF "d") (SF "ee")])
296
297 ;; In SHIFT templates, a string like "s<lr>dl" will expand to "sldl" in 
298 ;; 'ashift' and "srdl" in 'lshiftrt'.
299 (define_code_attr lr [(ashift "l") (lshiftrt "r")])
300
301 ;; In SHIFT templates, this attribute holds the correct standard name for the
302 ;; pattern itself and the corresponding function calls. 
303 (define_code_attr shift [(ashift "ashl") (lshiftrt "lshr")])
304
305 ;; This attribute handles differences in the instruction 'type' and will result
306 ;; in "RRE" for DImode and "RR" for SImode.
307 (define_mode_attr E [(DI "E") (SI "")])
308
309 ;; In GPR templates, a string like "lc<g>r" will expand to "lcgr" in DImode
310 ;; and "lcr" in SImode.
311 (define_mode_attr g [(DI "g") (SI "")])
312
313 ;; In GPR templates, a string like "c<gf>dbr" will expand to "cgdbr" in DImode
314 ;; and "cfdbr" in SImode.
315 (define_mode_attr gf [(DI "g") (SI "f")])
316
317 ;; ICM mask required to load MODE value into the highest subreg
318 ;; of a SImode register.
319 (define_mode_attr icm_hi [(HI "12") (QI "8")])
320
321 ;; ICM mask required to load MODE value into the lowest subreg
322 ;; of a SImode register.
323 (define_mode_attr icm_lo [(HI "3") (QI "1")])
324
325 ;; In HQI templates, a string like "llg<hc>" will expand to "llgh" in
326 ;; HImode and "llgc" in QImode.
327 (define_mode_attr hc [(HI "h") (QI "c")])
328
329 ;; Maximum unsigned integer that fits in MODE.
330 (define_mode_attr max_uint [(HI "65535") (QI "255")])
331
332
333 ;;
334 ;;- Compare instructions.
335 ;;
336
337 (define_expand "cmp<mode>"
338   [(set (reg:CC CC_REGNUM)
339         (compare:CC (match_operand:GPR 0 "register_operand" "")
340                     (match_operand:GPR 1 "general_operand" "")))]
341   ""
342 {
343   s390_compare_op0 = operands[0];
344   s390_compare_op1 = operands[1];
345   DONE;
346 })
347
348 (define_expand "cmp<mode>"
349   [(set (reg:CC CC_REGNUM)
350         (compare:CC (match_operand:FPR 0 "register_operand" "")
351                     (match_operand:FPR 1 "general_operand" "")))]
352   "TARGET_HARD_FLOAT"
353 {
354   s390_compare_op0 = operands[0];
355   s390_compare_op1 = operands[1];
356   DONE;
357 })
358
359
360 ; Test-under-Mask instructions
361
362 (define_insn "*tmqi_mem"
363   [(set (reg CC_REGNUM)
364         (compare (and:QI (match_operand:QI 0 "memory_operand" "Q,S")
365                          (match_operand:QI 1 "immediate_operand" "n,n"))
366                  (match_operand:QI 2 "immediate_operand" "n,n")))]
367   "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], false))"
368   "@
369    tm\t%S0,%b1
370    tmy\t%S0,%b1"
371   [(set_attr "op_type" "SI,SIY")])
372
373 (define_insn "*tmdi_reg"
374   [(set (reg CC_REGNUM)
375         (compare (and:DI (match_operand:DI 0 "nonimmediate_operand" "d,d,d,d")
376                          (match_operand:DI 1 "immediate_operand"
377                                              "N0HD0,N1HD0,N2HD0,N3HD0"))
378                  (match_operand:DI 2 "immediate_operand" "n,n,n,n")))]
379   "TARGET_64BIT
380    && s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], true))
381    && s390_single_part (operands[1], DImode, HImode, 0) >= 0"
382   "@
383    tmhh\t%0,%i1
384    tmhl\t%0,%i1
385    tmlh\t%0,%i1
386    tmll\t%0,%i1"
387   [(set_attr "op_type" "RI")])
388
389 (define_insn "*tmsi_reg"
390   [(set (reg CC_REGNUM)
391         (compare (and:SI (match_operand:SI 0 "nonimmediate_operand" "d,d")
392                          (match_operand:SI 1 "immediate_operand" "N0HS0,N1HS0"))
393                  (match_operand:SI 2 "immediate_operand" "n,n")))]
394   "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], true))
395    && s390_single_part (operands[1], SImode, HImode, 0) >= 0"
396   "@
397    tmh\t%0,%i1
398    tml\t%0,%i1"
399   [(set_attr "op_type" "RI")])
400
401 (define_insn "*tm<mode>_full"
402   [(set (reg CC_REGNUM)
403         (compare (match_operand:HQI 0 "register_operand" "d")
404                  (match_operand:HQI 1 "immediate_operand" "n")))]
405   "s390_match_ccmode (insn, s390_tm_ccmode (constm1_rtx, operands[1], true))"
406   "tml\t%0,<max_uint>"
407   [(set_attr "op_type" "RI")])
408
409
410 ; Load-and-Test instructions
411
412 (define_insn "*tstdi_sign"
413   [(set (reg CC_REGNUM)
414         (compare (ashiftrt:DI (ashift:DI (subreg:DI (match_operand:SI 0 "register_operand" "d") 0)
415                                          (const_int 32)) (const_int 32))
416                  (match_operand:DI 1 "const0_operand" "")))
417    (set (match_operand:DI 2 "register_operand" "=d")
418         (sign_extend:DI (match_dup 0)))]
419   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
420   "ltgfr\t%2,%0"
421   [(set_attr "op_type" "RRE")])
422
423 (define_insn "*tstdi"
424   [(set (reg CC_REGNUM)
425         (compare (match_operand:DI 0 "register_operand" "d")
426                  (match_operand:DI 1 "const0_operand" "")))
427    (set (match_operand:DI 2 "register_operand" "=d")
428         (match_dup 0))]
429   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
430   "ltgr\t%2,%0"
431   [(set_attr "op_type" "RRE")])
432
433 (define_insn "*tstdi_cconly"
434   [(set (reg CC_REGNUM)
435         (compare (match_operand:DI 0 "register_operand" "d")
436                  (match_operand:DI 1 "const0_operand" "")))]
437   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
438   "ltgr\t%0,%0"
439   [(set_attr "op_type" "RRE")])
440
441 (define_insn "*tstdi_cconly_31"
442   [(set (reg CC_REGNUM)
443         (compare (match_operand:DI 0 "register_operand" "d")
444                  (match_operand:DI 1 "const0_operand" "")))]
445   "s390_match_ccmode(insn, CCSmode) && !TARGET_64BIT"
446   "srda\t%0,0"
447   [(set_attr "op_type" "RS")
448    (set_attr "atype"   "reg")])
449
450
451 (define_insn "*tstsi"
452   [(set (reg CC_REGNUM)
453         (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
454                  (match_operand:SI 1 "const0_operand" "")))
455    (set (match_operand:SI 2 "register_operand" "=d,d,d")
456         (match_dup 0))]
457   "s390_match_ccmode(insn, CCSmode)"
458   "@
459    ltr\t%2,%0
460    icm\t%2,15,%S0
461    icmy\t%2,15,%S0"
462   [(set_attr "op_type" "RR,RS,RSY")])
463
464 (define_insn "*tstsi_cconly"
465   [(set (reg CC_REGNUM)
466         (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
467                  (match_operand:SI 1 "const0_operand" "")))
468    (clobber (match_scratch:SI 2 "=X,d,d"))]
469   "s390_match_ccmode(insn, CCSmode)"
470   "@
471    ltr\t%0,%0
472    icm\t%2,15,%S0
473    icmy\t%2,15,%S0"
474   [(set_attr "op_type" "RR,RS,RSY")])
475
476 (define_insn "*tstsi_cconly2"
477   [(set (reg CC_REGNUM)
478         (compare (match_operand:SI 0 "register_operand" "d")
479                  (match_operand:SI 1 "const0_operand" "")))]
480   "s390_match_ccmode(insn, CCSmode)"
481   "ltr\t%0,%0"
482   [(set_attr "op_type" "RR")])
483
484 (define_insn "*tst<mode>CCT"
485   [(set (reg CC_REGNUM)
486         (compare (match_operand:HQI 0 "nonimmediate_operand" "?Q,?S,d")
487                  (match_operand:HQI 1 "const0_operand" "")))
488    (set (match_operand:HQI 2 "register_operand" "=d,d,0")
489         (match_dup 0))]
490   "s390_match_ccmode(insn, CCTmode)"
491   "@
492    icm\t%2,<icm_lo>,%S0
493    icmy\t%2,<icm_lo>,%S0
494    tml\t%0,<max_uint>"
495   [(set_attr "op_type" "RS,RSY,RI")])
496
497 (define_insn "*tsthiCCT_cconly"
498   [(set (reg CC_REGNUM)
499         (compare (match_operand:HI 0 "nonimmediate_operand" "Q,S,d")
500                  (match_operand:HI 1 "const0_operand" "")))
501    (clobber (match_scratch:HI 2 "=d,d,X"))]
502   "s390_match_ccmode(insn, CCTmode)"
503   "@
504    icm\t%2,3,%S0
505    icmy\t%2,3,%S0
506    tml\t%0,65535"
507   [(set_attr "op_type" "RS,RSY,RI")])
508
509 (define_insn "*tstqiCCT_cconly"
510   [(set (reg CC_REGNUM)
511         (compare (match_operand:QI 0 "nonimmediate_operand" "?Q,?S,d")
512                  (match_operand:QI 1 "const0_operand" "")))]
513   "s390_match_ccmode(insn, CCTmode)"
514   "@
515    cli\t%S0,0
516    cliy\t%S0,0
517    tml\t%0,255"
518   [(set_attr "op_type" "SI,SIY,RI")])
519
520 (define_insn "*tst<mode>"
521   [(set (reg CC_REGNUM)
522         (compare (match_operand:HQI 0 "s_operand" "Q,S")
523                  (match_operand:HQI 1 "const0_operand" "")))
524    (set (match_operand:HQI 2 "register_operand" "=d,d")
525         (match_dup 0))]
526   "s390_match_ccmode(insn, CCSmode)"
527   "@
528    icm\t%2,<icm_lo>,%S0
529    icmy\t%2,<icm_lo>,%S0"
530   [(set_attr "op_type" "RS,RSY")])
531
532 (define_insn "*tst<mode>_cconly"
533   [(set (reg CC_REGNUM)
534         (compare (match_operand:HQI 0 "s_operand" "Q,S")
535                  (match_operand:HQI 1 "const0_operand" "")))
536    (clobber (match_scratch:HQI 2 "=d,d"))]
537   "s390_match_ccmode(insn, CCSmode)"
538   "@
539    icm\t%2,<icm_lo>,%S0
540    icmy\t%2,<icm_lo>,%S0"
541   [(set_attr "op_type" "RS,RSY")])
542
543
544 ; Compare (equality) instructions
545
546 (define_insn "*cmpdi_cct"
547   [(set (reg CC_REGNUM)
548         (compare (match_operand:DI 0 "nonimmediate_operand" "%d,d,d,Q")
549                  (match_operand:DI 1 "general_operand" "d,K,m,BQ")))]
550   "s390_match_ccmode (insn, CCTmode) && TARGET_64BIT"
551   "@
552    cgr\t%0,%1
553    cghi\t%0,%h1
554    cg\t%0,%1
555    #"
556   [(set_attr "op_type" "RRE,RI,RXY,SS")])
557
558 (define_insn "*cmpsi_cct"
559   [(set (reg CC_REGNUM)
560         (compare (match_operand:SI 0 "nonimmediate_operand" "%d,d,d,d,Q")
561                  (match_operand:SI 1 "general_operand" "d,K,R,T,BQ")))]
562   "s390_match_ccmode (insn, CCTmode)"
563   "@
564    cr\t%0,%1
565    chi\t%0,%h1
566    c\t%0,%1
567    cy\t%0,%1
568    #"
569   [(set_attr "op_type" "RR,RI,RX,RXY,SS")])
570
571
572 ; Compare (signed) instructions
573
574 (define_insn "*cmpdi_ccs_sign"
575   [(set (reg CC_REGNUM)
576         (compare (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m"))
577                  (match_operand:DI 0 "register_operand" "d,d")))]
578   "s390_match_ccmode(insn, CCSRmode) && TARGET_64BIT"
579   "@
580    cgfr\t%0,%1
581    cgf\t%0,%1"
582   [(set_attr "op_type" "RRE,RXY")])
583
584 (define_insn "*cmpdi_ccs"
585   [(set (reg CC_REGNUM)
586         (compare (match_operand:DI 0 "register_operand" "d,d,d")
587                  (match_operand:DI 1 "general_operand" "d,K,m")))]
588   "s390_match_ccmode(insn, CCSmode) && TARGET_64BIT"
589   "@
590    cgr\t%0,%1
591    cghi\t%0,%h1
592    cg\t%0,%1"
593   [(set_attr "op_type" "RRE,RI,RXY")])
594
595 (define_insn "*cmpsi_ccs_sign"
596   [(set (reg CC_REGNUM)
597         (compare (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T"))
598                  (match_operand:SI 0 "register_operand" "d,d")))]
599   "s390_match_ccmode(insn, CCSRmode)"
600   "@
601    ch\t%0,%1
602    chy\t%0,%1"
603   [(set_attr "op_type" "RX,RXY")])
604
605 (define_insn "*cmpsi_ccs"
606   [(set (reg CC_REGNUM)
607         (compare (match_operand:SI 0 "register_operand" "d,d,d,d")
608                  (match_operand:SI 1 "general_operand" "d,K,R,T")))]
609   "s390_match_ccmode(insn, CCSmode)"
610   "@
611    cr\t%0,%1
612    chi\t%0,%h1
613    c\t%0,%1
614    cy\t%0,%1"
615   [(set_attr "op_type" "RR,RI,RX,RXY")])
616
617
618 ; Compare (unsigned) instructions
619
620 (define_insn "*cmpdi_ccu_zero"
621   [(set (reg CC_REGNUM)
622         (compare (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m"))
623                  (match_operand:DI 0 "register_operand" "d,d")))]
624   "s390_match_ccmode (insn, CCURmode) && TARGET_64BIT"
625   "@
626    clgfr\t%0,%1
627    clgf\t%0,%1"
628   [(set_attr "op_type" "RRE,RXY")])
629
630 (define_insn "*cmpdi_ccu"
631   [(set (reg CC_REGNUM)
632         (compare (match_operand:DI 0 "nonimmediate_operand" "d,d,Q,BQ")
633                  (match_operand:DI 1 "general_operand" "d,m,BQ,Q")))]
634   "s390_match_ccmode (insn, CCUmode) && TARGET_64BIT"
635   "@
636    clgr\t%0,%1
637    clg\t%0,%1
638    #
639    #"
640   [(set_attr "op_type" "RRE,RXY,SS,SS")])
641
642 (define_insn "*cmpsi_ccu"
643   [(set (reg CC_REGNUM)
644         (compare (match_operand:SI 0 "nonimmediate_operand" "d,d,d,Q,BQ")
645                  (match_operand:SI 1 "general_operand" "d,R,T,BQ,Q")))]
646   "s390_match_ccmode (insn, CCUmode)"
647   "@
648    clr\t%0,%1
649    cl\t%0,%1
650    cly\t%0,%1
651    #
652    #"
653   [(set_attr "op_type" "RR,RX,RXY,SS,SS")])
654
655 (define_insn "*cmphi_ccu"
656   [(set (reg CC_REGNUM)
657         (compare (match_operand:HI 0 "nonimmediate_operand" "d,d,Q,BQ")
658                  (match_operand:HI 1 "general_operand" "Q,S,BQ,Q")))]
659   "s390_match_ccmode (insn, CCUmode)
660    && !register_operand (operands[1], HImode)"
661   "@
662    clm\t%0,3,%S1
663    clmy\t%0,3,%S1
664    #
665    #"
666   [(set_attr "op_type" "RS,RSY,SS,SS")])
667
668 (define_insn "*cmpqi_ccu"
669   [(set (reg CC_REGNUM)
670         (compare (match_operand:QI 0 "nonimmediate_operand" "d,d,Q,S,Q,BQ")
671                  (match_operand:QI 1 "general_operand" "Q,S,n,n,BQ,Q")))]
672   "s390_match_ccmode (insn, CCUmode)
673    && !register_operand (operands[1], QImode)"
674   "@
675    clm\t%0,1,%S1
676    clmy\t%0,1,%S1
677    cli\t%S0,%b1
678    cliy\t%S0,%b1
679    #
680    #"
681   [(set_attr "op_type" "RS,RSY,SI,SIY,SS,SS")])
682
683
684 ; Block compare (CLC) instruction patterns.
685
686 (define_insn "*clc"
687   [(set (reg CC_REGNUM)
688         (compare (match_operand:BLK 0 "memory_operand" "Q")
689                  (match_operand:BLK 1 "memory_operand" "Q")))
690    (use (match_operand 2 "const_int_operand" "n"))]
691   "s390_match_ccmode (insn, CCUmode)
692    && INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
693   "clc\t%O0(%2,%R0),%S1"
694   [(set_attr "op_type" "SS")])
695
696 (define_split
697   [(set (reg CC_REGNUM)
698         (compare (match_operand 0 "memory_operand" "")
699                  (match_operand 1 "memory_operand" "")))]
700   "reload_completed
701    && s390_match_ccmode (insn, CCUmode)
702    && GET_MODE (operands[0]) == GET_MODE (operands[1])
703    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
704   [(parallel
705     [(set (match_dup 0) (match_dup 1))
706      (use (match_dup 2))])]
707 {
708   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
709   operands[0] = adjust_address (operands[0], BLKmode, 0);
710   operands[1] = adjust_address (operands[1], BLKmode, 0);
711
712   operands[1] = gen_rtx_COMPARE (GET_MODE (SET_DEST (PATTERN (curr_insn))),
713                                  operands[0], operands[1]);
714   operands[0] = SET_DEST (PATTERN (curr_insn));
715 })
716
717
718 ; (DF|SF) instructions
719
720 (define_insn "*cmp<mode>_ccs_0"
721   [(set (reg CC_REGNUM)
722         (compare (match_operand:FPR 0 "register_operand" "f")
723                  (match_operand:FPR 1 "const0_operand" "")))]
724   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
725   "lt<de>br\t%0,%0"
726    [(set_attr "op_type" "RRE")
727     (set_attr "type"  "fsimp<mode>")])
728
729 (define_insn "*cmp<mode>_ccs_0_ibm"
730   [(set (reg CC_REGNUM)
731         (compare (match_operand:FPR 0 "register_operand" "f")
732                  (match_operand:FPR 1 "const0_operand" "")))]
733   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
734   "lt<de>r\t%0,%0"
735    [(set_attr "op_type" "RR")
736     (set_attr "type"  "fsimp<mode>")])
737
738 (define_insn "*cmp<mode>_ccs"
739   [(set (reg CC_REGNUM)
740         (compare (match_operand:FPR 0 "register_operand" "f,f")
741                  (match_operand:FPR 1 "general_operand" "f,R")))]
742   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
743   "@
744    c<de>br\t%0,%1
745    c<de>b\t%0,%1"
746    [(set_attr "op_type" "RRE,RXE")
747     (set_attr "type"  "fsimp<mode>")])
748
749 (define_insn "*cmp<mode>_ccs_ibm"
750   [(set (reg CC_REGNUM)
751         (compare (match_operand:FPR 0 "register_operand" "f,f")
752                  (match_operand:FPR 1 "general_operand" "f,R")))]
753   "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
754   "@
755    c<de>r\t%0,%1
756    c<de>\t%0,%1"
757    [(set_attr "op_type" "RR,RX")
758     (set_attr "type"  "fsimp<mode>")])
759
760
761 ;;
762 ;;- Move instructions.
763 ;;
764
765 ;
766 ; movti instruction pattern(s).
767 ;
768
769 (define_insn "movti"
770   [(set (match_operand:TI 0 "nonimmediate_operand" "=d,QS,d,o,Q")
771         (match_operand:TI 1 "general_operand" "QS,d,dKm,d,Q"))]
772   "TARGET_64BIT"
773   "@
774    lmg\t%0,%N0,%S1
775    stmg\t%1,%N1,%S0
776    #
777    #
778    #"
779   [(set_attr "op_type" "RSY,RSY,*,*,SS")
780    (set_attr "type" "lm,stm,*,*,*")])
781
782 (define_split
783   [(set (match_operand:TI 0 "nonimmediate_operand" "")
784         (match_operand:TI 1 "general_operand" ""))]
785   "TARGET_64BIT && reload_completed
786    && s390_split_ok_p (operands[0], operands[1], TImode, 0)"
787   [(set (match_dup 2) (match_dup 4))
788    (set (match_dup 3) (match_dup 5))]
789 {
790   operands[2] = operand_subword (operands[0], 0, 0, TImode);
791   operands[3] = operand_subword (operands[0], 1, 0, TImode);
792   operands[4] = operand_subword (operands[1], 0, 0, TImode);
793   operands[5] = operand_subword (operands[1], 1, 0, TImode);
794 })
795
796 (define_split
797   [(set (match_operand:TI 0 "nonimmediate_operand" "")
798         (match_operand:TI 1 "general_operand" ""))]
799   "TARGET_64BIT && reload_completed
800    && s390_split_ok_p (operands[0], operands[1], TImode, 1)"
801   [(set (match_dup 2) (match_dup 4))
802    (set (match_dup 3) (match_dup 5))]
803 {
804   operands[2] = operand_subword (operands[0], 1, 0, TImode);
805   operands[3] = operand_subword (operands[0], 0, 0, TImode);
806   operands[4] = operand_subword (operands[1], 1, 0, TImode);
807   operands[5] = operand_subword (operands[1], 0, 0, TImode);
808 })
809
810 (define_split
811   [(set (match_operand:TI 0 "register_operand" "")
812         (match_operand:TI 1 "memory_operand" ""))]
813   "TARGET_64BIT && reload_completed
814    && !s_operand (operands[1], VOIDmode)"
815   [(set (match_dup 0) (match_dup 1))]
816 {
817   rtx addr = operand_subword (operands[0], 1, 0, TImode);
818   s390_load_address (addr, XEXP (operands[1], 0));
819   operands[1] = replace_equiv_address (operands[1], addr);
820 })
821
822 (define_expand "reload_outti"
823   [(parallel [(match_operand:TI 0 "" "")
824               (match_operand:TI 1 "register_operand" "d")
825               (match_operand:DI 2 "register_operand" "=&a")])]
826   "TARGET_64BIT"
827 {
828   gcc_assert (MEM_P (operands[0]));
829   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
830   operands[0] = replace_equiv_address (operands[0], operands[2]);
831   emit_move_insn (operands[0], operands[1]);
832   DONE;
833 })
834
835 ;
836 ; movdi instruction pattern(s).
837 ;
838
839 (define_expand "movdi"
840   [(set (match_operand:DI 0 "general_operand" "")
841         (match_operand:DI 1 "general_operand" ""))]
842   ""
843 {
844   /* Handle symbolic constants.  */
845   if (TARGET_64BIT && SYMBOLIC_CONST (operands[1]))
846     emit_symbolic_move (operands);
847 })
848
849 (define_insn "*movdi_larl"
850   [(set (match_operand:DI 0 "register_operand" "=d")
851         (match_operand:DI 1 "larl_operand" "X"))]
852   "TARGET_64BIT
853    && !FP_REG_P (operands[0])"
854   "larl\t%0,%1"
855    [(set_attr "op_type" "RIL")
856     (set_attr "type"    "larl")])
857
858 (define_insn "*movdi_64"
859   [(set (match_operand:DI 0 "nonimmediate_operand"
860                             "=d,d,d,d,d,d,d,d,m,!*f,!*f,!*f,!R,!T,d,t,Q,t,?Q")
861         (match_operand:DI 1 "general_operand"
862                             "K,N0HD0,N1HD0,N2HD0,N3HD0,L,d,m,d,*f,R,T,*f,*f,t,d,t,Q,?Q"))]
863   "TARGET_64BIT"
864   "@
865    lghi\t%0,%h1
866    llihh\t%0,%i1
867    llihl\t%0,%i1
868    llilh\t%0,%i1
869    llill\t%0,%i1
870    lay\t%0,%a1
871    lgr\t%0,%1
872    lg\t%0,%1
873    stg\t%1,%0
874    ldr\t%0,%1
875    ld\t%0,%1
876    ldy\t%0,%1
877    std\t%1,%0
878    stdy\t%1,%0
879    #
880    #
881    stam\t%1,%N1,%S0
882    lam\t%0,%N0,%S1
883    #"
884   [(set_attr "op_type" "RI,RI,RI,RI,RI,RXY,RRE,RXY,RXY,
885                         RR,RX,RXY,RX,RXY,*,*,RS,RS,SS")
886    (set_attr "type" "*,*,*,*,*,la,lr,load,store,
887                      floaddf,floaddf,floaddf,fstoredf,fstoredf,*,*,*,*,*")])
888
889 (define_split
890   [(set (match_operand:DI 0 "register_operand" "")
891         (match_operand:DI 1 "register_operand" ""))]
892   "TARGET_64BIT && ACCESS_REG_P (operands[1])"
893   [(set (match_dup 2) (match_dup 3))
894    (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 32)))
895    (set (strict_low_part (match_dup 2)) (match_dup 4))]
896   "operands[2] = gen_lowpart (SImode, operands[0]);
897    s390_split_access_reg (operands[1], &operands[4], &operands[3]);")
898
899 (define_split
900   [(set (match_operand:DI 0 "register_operand" "")
901         (match_operand:DI 1 "register_operand" ""))]
902   "TARGET_64BIT && ACCESS_REG_P (operands[0])
903    && dead_or_set_p (insn, operands[1])"
904   [(set (match_dup 3) (match_dup 2))
905    (set (match_dup 1) (lshiftrt:DI (match_dup 1) (const_int 32)))
906    (set (match_dup 4) (match_dup 2))]
907   "operands[2] = gen_lowpart (SImode, operands[1]);
908    s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
909
910 (define_split
911   [(set (match_operand:DI 0 "register_operand" "")
912         (match_operand:DI 1 "register_operand" ""))]
913   "TARGET_64BIT && ACCESS_REG_P (operands[0])
914    && !dead_or_set_p (insn, operands[1])"
915   [(set (match_dup 3) (match_dup 2))
916    (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))
917    (set (match_dup 4) (match_dup 2))
918    (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))]
919   "operands[2] = gen_lowpart (SImode, operands[1]);
920    s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
921
922 (define_insn "*movdi_31"
923   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,Q,d,o,!*f,!*f,!*f,!R,!T,Q")
924         (match_operand:DI 1 "general_operand" "Q,d,dKm,d,*f,R,T,*f,*f,Q"))]
925   "!TARGET_64BIT"
926   "@
927    lm\t%0,%N0,%S1
928    stm\t%1,%N1,%S0
929    #
930    #
931    ldr\t%0,%1
932    ld\t%0,%1
933    ldy\t%0,%1
934    std\t%1,%0
935    stdy\t%1,%0
936    #"
937   [(set_attr "op_type" "RS,RS,*,*,RR,RX,RXY,RX,RXY,SS")
938    (set_attr "type" "lm,stm,*,*,floaddf,floaddf,floaddf,fstoredf,fstoredf,*")])
939
940 (define_split
941   [(set (match_operand:DI 0 "nonimmediate_operand" "")
942         (match_operand:DI 1 "general_operand" ""))]
943   "!TARGET_64BIT && reload_completed
944    && s390_split_ok_p (operands[0], operands[1], DImode, 0)"
945   [(set (match_dup 2) (match_dup 4))
946    (set (match_dup 3) (match_dup 5))]
947 {
948   operands[2] = operand_subword (operands[0], 0, 0, DImode);
949   operands[3] = operand_subword (operands[0], 1, 0, DImode);
950   operands[4] = operand_subword (operands[1], 0, 0, DImode);
951   operands[5] = operand_subword (operands[1], 1, 0, DImode);
952 })
953
954 (define_split
955   [(set (match_operand:DI 0 "nonimmediate_operand" "")
956         (match_operand:DI 1 "general_operand" ""))]
957   "!TARGET_64BIT && reload_completed
958    && s390_split_ok_p (operands[0], operands[1], DImode, 1)"
959   [(set (match_dup 2) (match_dup 4))
960    (set (match_dup 3) (match_dup 5))]
961 {
962   operands[2] = operand_subword (operands[0], 1, 0, DImode);
963   operands[3] = operand_subword (operands[0], 0, 0, DImode);
964   operands[4] = operand_subword (operands[1], 1, 0, DImode);
965   operands[5] = operand_subword (operands[1], 0, 0, DImode);
966 })
967
968 (define_split
969   [(set (match_operand:DI 0 "register_operand" "")
970         (match_operand:DI 1 "memory_operand" ""))]
971   "!TARGET_64BIT && reload_completed
972    && !FP_REG_P (operands[0])
973    && !s_operand (operands[1], VOIDmode)"
974   [(set (match_dup 0) (match_dup 1))]
975 {
976   rtx addr = operand_subword (operands[0], 1, 0, DImode);
977   s390_load_address (addr, XEXP (operands[1], 0));
978   operands[1] = replace_equiv_address (operands[1], addr);
979 })
980
981 (define_expand "reload_outdi"
982   [(parallel [(match_operand:DI 0 "" "")
983               (match_operand:DI 1 "register_operand" "d")
984               (match_operand:SI 2 "register_operand" "=&a")])]
985   "!TARGET_64BIT"
986 {
987   gcc_assert (MEM_P (operands[0]));
988   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
989   operands[0] = replace_equiv_address (operands[0], operands[2]);
990   emit_move_insn (operands[0], operands[1]);
991   DONE;
992 })
993
994 (define_peephole2
995   [(set (match_operand:DI 0 "register_operand" "")
996         (mem:DI (match_operand 1 "address_operand" "")))]
997   "TARGET_64BIT
998    && !FP_REG_P (operands[0])
999    && GET_CODE (operands[1]) == SYMBOL_REF
1000    && CONSTANT_POOL_ADDRESS_P (operands[1])
1001    && get_pool_mode (operands[1]) == DImode
1002    && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
1003   [(set (match_dup 0) (match_dup 2))]
1004   "operands[2] = get_pool_constant (operands[1]);")
1005
1006 (define_insn "*la_64"
1007   [(set (match_operand:DI 0 "register_operand" "=d,d")
1008         (match_operand:QI 1 "address_operand" "U,W"))]
1009   "TARGET_64BIT"
1010   "@
1011    la\t%0,%a1
1012    lay\t%0,%a1"
1013   [(set_attr "op_type" "RX,RXY")
1014    (set_attr "type"    "la")])
1015
1016 (define_peephole2
1017   [(parallel
1018     [(set (match_operand:DI 0 "register_operand" "")
1019           (match_operand:QI 1 "address_operand" ""))
1020      (clobber (reg:CC CC_REGNUM))])]
1021   "TARGET_64BIT
1022    && preferred_la_operand_p (operands[1], const0_rtx)"
1023   [(set (match_dup 0) (match_dup 1))]
1024   "")
1025
1026 (define_peephole2
1027   [(set (match_operand:DI 0 "register_operand" "")
1028         (match_operand:DI 1 "register_operand" ""))
1029    (parallel
1030     [(set (match_dup 0)
1031           (plus:DI (match_dup 0)
1032                    (match_operand:DI 2 "nonmemory_operand" "")))
1033      (clobber (reg:CC CC_REGNUM))])]
1034   "TARGET_64BIT
1035    && !reg_overlap_mentioned_p (operands[0], operands[2])
1036    && preferred_la_operand_p (operands[1], operands[2])"
1037   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))]
1038   "")
1039
1040 (define_expand "reload_indi"
1041   [(parallel [(match_operand:DI 0 "register_operand" "=a")
1042               (match_operand:DI 1 "s390_plus_operand" "")
1043               (match_operand:DI 2 "register_operand" "=&a")])]
1044   "TARGET_64BIT"
1045 {
1046   s390_expand_plus_operand (operands[0], operands[1], operands[2]);
1047   DONE;
1048 })
1049
1050 ;
1051 ; movsi instruction pattern(s).
1052 ;
1053
1054 (define_expand "movsi"
1055   [(set (match_operand:SI 0 "general_operand" "")
1056         (match_operand:SI 1 "general_operand" ""))]
1057   ""
1058 {
1059   /* Handle symbolic constants.  */
1060   if (!TARGET_64BIT && SYMBOLIC_CONST (operands[1]))
1061     emit_symbolic_move (operands);
1062 })
1063
1064 (define_insn "*movsi_larl"
1065   [(set (match_operand:SI 0 "register_operand" "=d")
1066         (match_operand:SI 1 "larl_operand" "X"))]
1067   "!TARGET_64BIT && TARGET_CPU_ZARCH
1068    && !FP_REG_P (operands[0])"
1069   "larl\t%0,%1"
1070    [(set_attr "op_type" "RIL")
1071     (set_attr "type"    "larl")])
1072
1073 (define_insn "*movsi_zarch"
1074   [(set (match_operand:SI 0 "nonimmediate_operand"
1075                             "=d,d,d,d,d,d,d,R,T,!*f,!*f,!*f,!R,!T,d,t,Q,t,?Q")
1076         (match_operand:SI 1 "general_operand"
1077                             "K,N0HS0,N1HS0,L,d,R,T,d,d,*f,R,T,*f,*f,t,d,t,Q,?Q"))]
1078   "TARGET_ZARCH"
1079   "@
1080    lhi\t%0,%h1
1081    llilh\t%0,%i1
1082    llill\t%0,%i1
1083    lay\t%0,%a1
1084    lr\t%0,%1
1085    l\t%0,%1
1086    ly\t%0,%1
1087    st\t%1,%0
1088    sty\t%1,%0
1089    ler\t%0,%1
1090    le\t%0,%1
1091    ley\t%0,%1
1092    ste\t%1,%0
1093    stey\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,RI,RI,RXY,RR,RX,RXY,RX,RXY,
1100                         RR,RX,RXY,RX,RXY,RRE,RRE,RS,RS,SS")
1101    (set_attr "type" "*,*,*,la,lr,load,load,store,store,
1102                      floadsf,floadsf,floadsf,fstoresf,fstoresf,*,*,*,*,*")])
1103
1104 (define_insn "*movsi_esa"
1105   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,R,!*f,!*f,!R,d,t,Q,t,?Q")
1106         (match_operand:SI 1 "general_operand" "K,d,R,d,*f,R,*f,t,d,t,Q,?Q"))]
1107   "!TARGET_ZARCH"
1108   "@
1109    lhi\t%0,%h1
1110    lr\t%0,%1
1111    l\t%0,%1
1112    st\t%1,%0
1113    ler\t%0,%1
1114    le\t%0,%1
1115    ste\t%1,%0
1116    ear\t%0,%1
1117    sar\t%0,%1
1118    stam\t%1,%1,%S0
1119    lam\t%0,%0,%S1
1120    #"
1121   [(set_attr "op_type" "RI,RR,RX,RX,RR,RX,RX,RRE,RRE,RS,RS,SS")
1122    (set_attr "type" "*,lr,load,store,floadsf,floadsf,fstoresf,*,*,*,*,*")])
1123
1124 (define_peephole2
1125   [(set (match_operand:SI 0 "register_operand" "")
1126         (mem:SI (match_operand 1 "address_operand" "")))]
1127   "!FP_REG_P (operands[0])
1128    && GET_CODE (operands[1]) == SYMBOL_REF
1129    && CONSTANT_POOL_ADDRESS_P (operands[1])
1130    && get_pool_mode (operands[1]) == SImode
1131    && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
1132   [(set (match_dup 0) (match_dup 2))]
1133   "operands[2] = get_pool_constant (operands[1]);")
1134
1135 (define_insn "*la_31"
1136   [(set (match_operand:SI 0 "register_operand" "=d,d")
1137         (match_operand:QI 1 "address_operand" "U,W"))]
1138   "!TARGET_64BIT && legitimate_la_operand_p (operands[1])"
1139   "@
1140    la\t%0,%a1
1141    lay\t%0,%a1"
1142   [(set_attr "op_type"  "RX,RXY")
1143    (set_attr "type"     "la")])
1144
1145 (define_peephole2
1146   [(parallel
1147     [(set (match_operand:SI 0 "register_operand" "")
1148           (match_operand:QI 1 "address_operand" ""))
1149      (clobber (reg:CC CC_REGNUM))])]
1150   "!TARGET_64BIT
1151    && preferred_la_operand_p (operands[1], const0_rtx)"
1152   [(set (match_dup 0) (match_dup 1))]
1153   "")
1154
1155 (define_peephole2
1156   [(set (match_operand:SI 0 "register_operand" "")
1157         (match_operand:SI 1 "register_operand" ""))
1158    (parallel
1159     [(set (match_dup 0)
1160           (plus:SI (match_dup 0)
1161                    (match_operand:SI 2 "nonmemory_operand" "")))
1162      (clobber (reg:CC CC_REGNUM))])]
1163   "!TARGET_64BIT
1164    && !reg_overlap_mentioned_p (operands[0], operands[2])
1165    && preferred_la_operand_p (operands[1], operands[2])"
1166   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))]
1167   "")
1168
1169 (define_insn "*la_31_and"
1170   [(set (match_operand:SI 0 "register_operand" "=d,d")
1171         (and:SI (match_operand:QI 1 "address_operand" "U,W")
1172                 (const_int 2147483647)))]
1173   "!TARGET_64BIT"
1174   "@
1175    la\t%0,%a1
1176    lay\t%0,%a1"
1177   [(set_attr "op_type"  "RX,RXY")
1178    (set_attr "type"     "la")])
1179
1180 (define_insn_and_split "*la_31_and_cc"
1181   [(set (match_operand:SI 0 "register_operand" "=d")
1182         (and:SI (match_operand:QI 1 "address_operand" "p")
1183                 (const_int 2147483647)))
1184    (clobber (reg:CC CC_REGNUM))]
1185   "!TARGET_64BIT"
1186   "#"
1187   "&& reload_completed"
1188   [(set (match_dup 0)
1189         (and:SI (match_dup 1) (const_int 2147483647)))]
1190   ""
1191   [(set_attr "op_type"  "RX")
1192    (set_attr "type"     "la")])
1193
1194 (define_insn "force_la_31"
1195   [(set (match_operand:SI 0 "register_operand" "=d,d")
1196         (match_operand:QI 1 "address_operand" "U,W"))
1197    (use (const_int 0))]
1198   "!TARGET_64BIT"
1199   "@
1200    la\t%0,%a1
1201    lay\t%0,%a1"
1202   [(set_attr "op_type"  "RX")
1203    (set_attr "type"     "la")])
1204
1205 (define_expand "reload_insi"
1206   [(parallel [(match_operand:SI 0 "register_operand" "=a")
1207               (match_operand:SI 1 "s390_plus_operand" "")
1208               (match_operand:SI 2 "register_operand" "=&a")])]
1209   "!TARGET_64BIT"
1210 {
1211   s390_expand_plus_operand (operands[0], operands[1], operands[2]);
1212   DONE;
1213 })
1214
1215 ;
1216 ; movhi instruction pattern(s).
1217 ;
1218
1219 (define_expand "movhi"
1220   [(set (match_operand:HI 0 "nonimmediate_operand" "")
1221         (match_operand:HI 1 "general_operand" ""))]
1222   ""
1223 {
1224   /* Make it explicit that loading a register from memory
1225      always sign-extends (at least) to SImode.  */
1226   if (optimize && !no_new_pseudos
1227       && register_operand (operands[0], VOIDmode)
1228       && GET_CODE (operands[1]) == MEM)
1229     {
1230       rtx tmp = gen_reg_rtx (SImode);
1231       rtx ext = gen_rtx_SIGN_EXTEND (SImode, operands[1]);
1232       emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1233       operands[1] = gen_lowpart (HImode, tmp);
1234     }
1235 })
1236
1237 (define_insn "*movhi"
1238   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d,d,R,T,?Q")
1239         (match_operand:HI 1 "general_operand" "d,n,R,T,d,d,?Q"))]
1240   ""
1241   "@
1242    lr\t%0,%1
1243    lhi\t%0,%h1
1244    lh\t%0,%1
1245    lhy\t%0,%1
1246    sth\t%1,%0
1247    sthy\t%1,%0
1248    #"
1249   [(set_attr "op_type" "RR,RI,RX,RXY,RX,RXY,SS")
1250    (set_attr "type" "lr,*,*,*,store,store,*")])
1251
1252 (define_peephole2
1253   [(set (match_operand:HI 0 "register_operand" "")
1254         (mem:HI (match_operand 1 "address_operand" "")))]
1255   "GET_CODE (operands[1]) == SYMBOL_REF
1256    && CONSTANT_POOL_ADDRESS_P (operands[1])
1257    && get_pool_mode (operands[1]) == HImode
1258    && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1259   [(set (match_dup 0) (match_dup 2))]
1260   "operands[2] = get_pool_constant (operands[1]);")
1261
1262 ;
1263 ; movqi instruction pattern(s).
1264 ;
1265
1266 (define_expand "movqi"
1267   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1268         (match_operand:QI 1 "general_operand" ""))]
1269   ""
1270 {
1271   /* On z/Architecture, zero-extending from memory to register
1272      is just as fast as a QImode load.  */
1273   if (TARGET_ZARCH && optimize && !no_new_pseudos
1274       && register_operand (operands[0], VOIDmode)
1275       && GET_CODE (operands[1]) == MEM)
1276     {
1277       rtx tmp = gen_reg_rtx (word_mode);
1278       rtx ext = gen_rtx_ZERO_EXTEND (word_mode, operands[1]);
1279       emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1280       operands[1] = gen_lowpart (QImode, tmp);
1281     }
1282 })
1283
1284 (define_insn "*movqi"
1285   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,d,R,T,Q,S,?Q")
1286         (match_operand:QI 1 "general_operand" "d,n,R,T,d,d,n,n,?Q"))]
1287   ""
1288   "@
1289    lr\t%0,%1
1290    lhi\t%0,%b1
1291    ic\t%0,%1
1292    icy\t%0,%1
1293    stc\t%1,%0
1294    stcy\t%1,%0
1295    mvi\t%S0,%b1
1296    mviy\t%S0,%b1
1297    #"
1298   [(set_attr "op_type" "RR,RI,RX,RXY,RX,RXY,SI,SIY,SS")
1299    (set_attr "type" "lr,*,*,*,store,store,store,store,*")])
1300
1301 (define_peephole2
1302   [(set (match_operand:QI 0 "nonimmediate_operand" "")
1303         (mem:QI (match_operand 1 "address_operand" "")))]
1304   "GET_CODE (operands[1]) == SYMBOL_REF
1305    && CONSTANT_POOL_ADDRESS_P (operands[1])
1306    && get_pool_mode (operands[1]) == QImode
1307    && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1308   [(set (match_dup 0) (match_dup 2))]
1309   "operands[2] = get_pool_constant (operands[1]);")
1310
1311 ;
1312 ; movstrictqi instruction pattern(s).
1313 ;
1314
1315 (define_insn "*movstrictqi"
1316   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d,d"))
1317                          (match_operand:QI 1 "memory_operand" "R,T"))]
1318   ""
1319   "@
1320    ic\t%0,%1
1321    icy\t%0,%1"
1322   [(set_attr "op_type"  "RX,RXY")])
1323
1324 ;
1325 ; movstricthi instruction pattern(s).
1326 ;
1327
1328 (define_insn "*movstricthi"
1329   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d,d"))
1330                          (match_operand:HI 1 "memory_operand" "Q,S"))
1331    (clobber (reg:CC CC_REGNUM))]
1332   ""
1333   "@
1334    icm\t%0,3,%S1
1335    icmy\t%0,3,%S1"
1336   [(set_attr "op_type" "RS,RSY")])
1337
1338 ;
1339 ; movstrictsi instruction pattern(s).
1340 ;
1341
1342 (define_insn "movstrictsi"
1343   [(set (strict_low_part (match_operand:SI 0 "register_operand" "+d,d,d,d"))
1344                          (match_operand:SI 1 "general_operand" "d,R,T,t"))]
1345   "TARGET_64BIT"
1346   "@
1347    lr\t%0,%1
1348    l\t%0,%1
1349    ly\t%0,%1
1350    ear\t%0,%1"
1351   [(set_attr "op_type" "RR,RX,RXY,RRE")
1352    (set_attr "type" "lr,load,load,*")])
1353
1354 ;
1355 ; movdf instruction pattern(s).
1356 ;
1357
1358 (define_expand "movdf"
1359   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1360         (match_operand:DF 1 "general_operand"  ""))]
1361   ""
1362   "")
1363
1364 (define_insn "*movdf_64"
1365   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,R,T,d,d,m,?Q")
1366         (match_operand:DF 1 "general_operand" "f,R,T,f,f,d,m,d,?Q"))]
1367   "TARGET_64BIT"
1368   "@
1369    ldr\t%0,%1
1370    ld\t%0,%1
1371    ldy\t%0,%1
1372    std\t%1,%0
1373    stdy\t%1,%0
1374    lgr\t%0,%1
1375    lg\t%0,%1
1376    stg\t%1,%0
1377    #"
1378   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RRE,RXY,RXY,SS")
1379    (set_attr "type" "floaddf,floaddf,floaddf,fstoredf,fstoredf,lr,load,store,*")])
1380
1381 (define_insn "*movdf_31"
1382   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,R,T,d,Q,d,o,Q")
1383         (match_operand:DF 1 "general_operand" "f,R,T,f,f,Q,d,dKm,d,Q"))]
1384   "!TARGET_64BIT"
1385   "@
1386    ldr\t%0,%1
1387    ld\t%0,%1
1388    ldy\t%0,%1
1389    std\t%1,%0
1390    stdy\t%1,%0
1391    lm\t%0,%N0,%S1
1392    stm\t%1,%N1,%S0
1393    #
1394    #
1395    #"
1396   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RS,RS,*,*,SS")
1397    (set_attr "type" "floaddf,floaddf,floaddf,fstoredf,fstoredf,lm,stm,*,*,*")])
1398
1399 (define_split
1400   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1401         (match_operand:DF 1 "general_operand" ""))]
1402   "!TARGET_64BIT && reload_completed
1403    && s390_split_ok_p (operands[0], operands[1], DFmode, 0)"
1404   [(set (match_dup 2) (match_dup 4))
1405    (set (match_dup 3) (match_dup 5))]
1406 {
1407   operands[2] = operand_subword (operands[0], 0, 0, DFmode);
1408   operands[3] = operand_subword (operands[0], 1, 0, DFmode);
1409   operands[4] = operand_subword (operands[1], 0, 0, DFmode);
1410   operands[5] = operand_subword (operands[1], 1, 0, DFmode);
1411 })
1412
1413 (define_split
1414   [(set (match_operand:DF 0 "nonimmediate_operand" "")
1415         (match_operand:DF 1 "general_operand" ""))]
1416   "!TARGET_64BIT && reload_completed
1417    && s390_split_ok_p (operands[0], operands[1], DFmode, 1)"
1418   [(set (match_dup 2) (match_dup 4))
1419    (set (match_dup 3) (match_dup 5))]
1420 {
1421   operands[2] = operand_subword (operands[0], 1, 0, DFmode);
1422   operands[3] = operand_subword (operands[0], 0, 0, DFmode);
1423   operands[4] = operand_subword (operands[1], 1, 0, DFmode);
1424   operands[5] = operand_subword (operands[1], 0, 0, DFmode);
1425 })
1426
1427 (define_split
1428   [(set (match_operand:DF 0 "register_operand" "")
1429         (match_operand:DF 1 "memory_operand" ""))]
1430   "!TARGET_64BIT && reload_completed
1431    && !FP_REG_P (operands[0])
1432    && !s_operand (operands[1], VOIDmode)"
1433   [(set (match_dup 0) (match_dup 1))]
1434 {
1435   rtx addr = operand_subword (operands[0], 1, 0, DFmode);
1436   s390_load_address (addr, XEXP (operands[1], 0));
1437   operands[1] = replace_equiv_address (operands[1], addr);
1438 })
1439
1440 (define_expand "reload_outdf"
1441   [(parallel [(match_operand:DF 0 "" "")
1442               (match_operand:DF 1 "register_operand" "d")
1443               (match_operand:SI 2 "register_operand" "=&a")])]
1444   "!TARGET_64BIT"
1445 {
1446   gcc_assert (MEM_P (operands[0]));
1447   s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
1448   operands[0] = replace_equiv_address (operands[0], operands[2]);
1449   emit_move_insn (operands[0], operands[1]);
1450   DONE;
1451 })
1452
1453 ;
1454 ; movsf instruction pattern(s).
1455 ;
1456
1457 (define_insn "movsf"
1458   [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f,R,T,d,d,d,R,T,?Q")
1459         (match_operand:SF 1 "general_operand" "f,R,T,f,f,d,R,T,d,d,?Q"))]
1460   ""
1461   "@
1462    ler\t%0,%1
1463    le\t%0,%1
1464    ley\t%0,%1
1465    ste\t%1,%0
1466    stey\t%1,%0
1467    lr\t%0,%1
1468    l\t%0,%1
1469    ly\t%0,%1
1470    st\t%1,%0
1471    sty\t%1,%0
1472    #"
1473   [(set_attr "op_type" "RR,RX,RXY,RX,RXY,RR,RX,RXY,RX,RXY,SS")
1474    (set_attr "type" "floadsf,floadsf,floadsf,fstoresf,fstoresf,
1475                      lr,load,load,store,store,*")])
1476
1477 ;
1478 ; movcc instruction pattern
1479 ;
1480
1481 (define_insn "movcc"
1482   [(set (match_operand:CC 0 "nonimmediate_operand" "=d,c,d,d,d,R,T")
1483         (match_operand:CC 1 "nonimmediate_operand" "d,d,c,R,T,d,d"))]
1484   ""
1485   "@
1486    lr\t%0,%1
1487    tmh\t%1,12288
1488    ipm\t%0
1489    st\t%0,%1
1490    sty\t%0,%1
1491    l\t%1,%0
1492    ly\t%1,%0"
1493   [(set_attr "op_type" "RR,RI,RRE,RX,RXY,RX,RXY")
1494    (set_attr "type" "lr,*,*,store,store,load,load")])
1495
1496 ;
1497 ; Block move (MVC) patterns.
1498 ;
1499
1500 (define_insn "*mvc"
1501   [(set (match_operand:BLK 0 "memory_operand" "=Q")
1502         (match_operand:BLK 1 "memory_operand" "Q"))
1503    (use (match_operand 2 "const_int_operand" "n"))]
1504   "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
1505   "mvc\t%O0(%2,%R0),%S1"
1506   [(set_attr "op_type" "SS")])
1507
1508 (define_split
1509   [(set (match_operand 0 "memory_operand" "")
1510         (match_operand 1 "memory_operand" ""))]
1511   "reload_completed
1512    && GET_MODE (operands[0]) == GET_MODE (operands[1])
1513    && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
1514   [(parallel
1515     [(set (match_dup 0) (match_dup 1))
1516      (use (match_dup 2))])]
1517 {
1518   operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
1519   operands[0] = adjust_address (operands[0], BLKmode, 0);
1520   operands[1] = adjust_address (operands[1], BLKmode, 0);
1521 })
1522
1523 (define_peephole2
1524   [(parallel
1525     [(set (match_operand:BLK 0 "memory_operand" "")
1526           (match_operand:BLK 1 "memory_operand" ""))
1527      (use (match_operand 2 "const_int_operand" ""))])
1528    (parallel
1529     [(set (match_operand:BLK 3 "memory_operand" "")
1530           (match_operand:BLK 4 "memory_operand" ""))
1531      (use (match_operand 5 "const_int_operand" ""))])]
1532   "s390_offset_p (operands[0], operands[3], operands[2])
1533    && s390_offset_p (operands[1], operands[4], operands[2])
1534    && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
1535   [(parallel
1536     [(set (match_dup 6) (match_dup 7))
1537      (use (match_dup 8))])]
1538   "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
1539    operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
1540    operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
1541
1542
1543 ;
1544 ; load_multiple pattern(s).
1545 ;
1546 ; ??? Due to reload problems with replacing registers inside match_parallel
1547 ; we currently support load_multiple/store_multiple only after reload.
1548 ;
1549
1550 (define_expand "load_multiple"
1551   [(match_par_dup 3 [(set (match_operand 0 "" "")
1552                           (match_operand 1 "" ""))
1553                      (use (match_operand 2 "" ""))])]
1554   "reload_completed"
1555 {
1556   enum machine_mode mode;
1557   int regno;
1558   int count;
1559   rtx from;
1560   int i, off;
1561
1562   /* Support only loading a constant number of fixed-point registers from
1563      memory and only bother with this if more than two */
1564   if (GET_CODE (operands[2]) != CONST_INT
1565       || INTVAL (operands[2]) < 2
1566       || INTVAL (operands[2]) > 16
1567       || GET_CODE (operands[1]) != MEM
1568       || GET_CODE (operands[0]) != REG
1569       || REGNO (operands[0]) >= 16)
1570     FAIL;
1571
1572   count = INTVAL (operands[2]);
1573   regno = REGNO (operands[0]);
1574   mode = GET_MODE (operands[0]);
1575   if (mode != SImode && mode != word_mode)
1576     FAIL;
1577
1578   operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
1579   if (no_new_pseudos)
1580     {
1581       if (GET_CODE (XEXP (operands[1], 0)) == REG)
1582         {
1583           from = XEXP (operands[1], 0);
1584           off = 0;
1585         }
1586       else if (GET_CODE (XEXP (operands[1], 0)) == PLUS
1587                && GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == REG
1588                && GET_CODE (XEXP (XEXP (operands[1], 0), 1)) == CONST_INT)
1589         {
1590           from = XEXP (XEXP (operands[1], 0), 0);
1591           off = INTVAL (XEXP (XEXP (operands[1], 0), 1));
1592         }
1593       else
1594         FAIL;
1595     }
1596   else
1597     {
1598       from = force_reg (Pmode, XEXP (operands[1], 0));
1599       off = 0;
1600     }
1601
1602   for (i = 0; i < count; i++)
1603     XVECEXP (operands[3], 0, i)
1604       = gen_rtx_SET (VOIDmode, gen_rtx_REG (mode, regno + i),
1605                      change_address (operands[1], mode,
1606                        plus_constant (from, off + i * GET_MODE_SIZE (mode))));
1607 })
1608
1609 (define_insn "*load_multiple_di"
1610   [(match_parallel 0 "load_multiple_operation"
1611                    [(set (match_operand:DI 1 "register_operand" "=r")
1612                          (match_operand:DI 2 "s_operand" "QS"))])]
1613   "reload_completed && word_mode == DImode"
1614 {
1615   int words = XVECLEN (operands[0], 0);
1616   operands[0] = gen_rtx_REG (DImode, REGNO (operands[1]) + words - 1);
1617   return "lmg\t%1,%0,%S2";
1618 }
1619    [(set_attr "op_type" "RSY")
1620     (set_attr "type"    "lm")])
1621
1622 (define_insn "*load_multiple_si"
1623   [(match_parallel 0 "load_multiple_operation"
1624                    [(set (match_operand:SI 1 "register_operand" "=r,r")
1625                          (match_operand:SI 2 "s_operand" "Q,S"))])]
1626   "reload_completed"
1627 {
1628   int words = XVECLEN (operands[0], 0);
1629   operands[0] = gen_rtx_REG (SImode, REGNO (operands[1]) + words - 1);
1630   return which_alternative == 0 ? "lm\t%1,%0,%S2" : "lmy\t%1,%0,%S2";
1631 }
1632    [(set_attr "op_type" "RS,RSY")
1633     (set_attr "type"    "lm")])
1634
1635 ;
1636 ; store multiple pattern(s).
1637 ;
1638
1639 (define_expand "store_multiple"
1640   [(match_par_dup 3 [(set (match_operand 0 "" "")
1641                           (match_operand 1 "" ""))
1642                      (use (match_operand 2 "" ""))])]
1643   "reload_completed"
1644 {
1645   enum machine_mode mode;
1646   int regno;
1647   int count;
1648   rtx to;
1649   int i, off;
1650
1651   /* Support only storing a constant number of fixed-point registers to
1652      memory and only bother with this if more than two.  */
1653   if (GET_CODE (operands[2]) != CONST_INT
1654       || INTVAL (operands[2]) < 2
1655       || INTVAL (operands[2]) > 16
1656       || GET_CODE (operands[0]) != MEM
1657       || GET_CODE (operands[1]) != REG
1658       || REGNO (operands[1]) >= 16)
1659     FAIL;
1660
1661   count = INTVAL (operands[2]);
1662   regno = REGNO (operands[1]);
1663   mode = GET_MODE (operands[1]);
1664   if (mode != SImode && mode != word_mode)
1665     FAIL;
1666
1667   operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
1668
1669   if (no_new_pseudos)
1670     {
1671       if (GET_CODE (XEXP (operands[0], 0)) == REG)
1672         {
1673           to = XEXP (operands[0], 0);
1674           off = 0;
1675         }
1676       else if (GET_CODE (XEXP (operands[0], 0)) == PLUS
1677                && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
1678                && GET_CODE (XEXP (XEXP (operands[0], 0), 1)) == CONST_INT)
1679         {
1680           to = XEXP (XEXP (operands[0], 0), 0);
1681           off = INTVAL (XEXP (XEXP (operands[0], 0), 1));
1682         }
1683       else
1684         FAIL;
1685     }
1686   else
1687     {
1688       to = force_reg (Pmode, XEXP (operands[0], 0));
1689       off = 0;
1690     }
1691
1692   for (i = 0; i < count; i++)
1693     XVECEXP (operands[3], 0, i)
1694       = gen_rtx_SET (VOIDmode,
1695                      change_address (operands[0], mode,
1696                        plus_constant (to, off + i * GET_MODE_SIZE (mode))),
1697                      gen_rtx_REG (mode, regno + i));
1698 })
1699
1700 (define_insn "*store_multiple_di"
1701   [(match_parallel 0 "store_multiple_operation"
1702                    [(set (match_operand:DI 1 "s_operand" "=QS")
1703                          (match_operand:DI 2 "register_operand" "r"))])]
1704   "reload_completed && word_mode == DImode"
1705 {
1706   int words = XVECLEN (operands[0], 0);
1707   operands[0] = gen_rtx_REG (DImode, REGNO (operands[2]) + words - 1);
1708   return "stmg\t%2,%0,%S1";
1709 }
1710    [(set_attr "op_type" "RSY")
1711     (set_attr "type"    "stm")])
1712
1713
1714 (define_insn "*store_multiple_si"
1715   [(match_parallel 0 "store_multiple_operation"
1716                    [(set (match_operand:SI 1 "s_operand" "=Q,S")
1717                          (match_operand:SI 2 "register_operand" "r,r"))])]
1718   "reload_completed"
1719 {
1720   int words = XVECLEN (operands[0], 0);
1721   operands[0] = gen_rtx_REG (SImode, REGNO (operands[2]) + words - 1);
1722   return which_alternative == 0 ? "stm\t%2,%0,%S1" : "stmy\t%2,%0,%S1";
1723 }
1724    [(set_attr "op_type" "RS,RSY")
1725     (set_attr "type"    "stm")])
1726
1727 ;;
1728 ;; String instructions.
1729 ;;
1730
1731 (define_insn "*execute"
1732   [(match_parallel 0 ""
1733     [(unspec [(match_operand 1 "register_operand" "a")
1734               (match_operand:BLK 2 "memory_operand" "R")
1735               (match_operand 3 "" "")] UNSPEC_EXECUTE)])]
1736   "GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
1737    && GET_MODE_SIZE (GET_MODE (operands[1])) <= UNITS_PER_WORD"
1738   "ex\t%1,%2"
1739   [(set_attr "op_type" "RX")
1740    (set_attr "type" "cs")])
1741
1742
1743 ;
1744 ; strlenM instruction pattern(s).
1745 ;
1746
1747 (define_expand "strlen<mode>"
1748   [(set (reg:QI 0) (match_operand:QI 2 "immediate_operand" ""))
1749    (parallel
1750     [(set (match_dup 4)
1751           (unspec:P [(const_int 0)
1752                       (match_operand:BLK 1 "memory_operand" "")
1753                       (reg:QI 0)
1754                       (match_operand 3 "immediate_operand" "")] UNSPEC_SRST))
1755      (clobber (scratch:P))
1756      (clobber (reg:CC CC_REGNUM))])
1757    (parallel
1758     [(set (match_operand:P 0 "register_operand" "")
1759           (minus:P (match_dup 4) (match_dup 5)))
1760      (clobber (reg:CC CC_REGNUM))])]
1761   ""
1762 {
1763   operands[4] = gen_reg_rtx (Pmode);
1764   operands[5] = gen_reg_rtx (Pmode);
1765   emit_move_insn (operands[5], force_operand (XEXP (operands[1], 0), NULL_RTX));
1766   operands[1] = replace_equiv_address (operands[1], operands[5]);
1767 })
1768
1769 (define_insn "*strlen<mode>"
1770   [(set (match_operand:P 0 "register_operand" "=a")
1771         (unspec:P [(match_operand:P 2 "general_operand" "0")
1772                     (mem:BLK (match_operand:P 3 "register_operand" "1"))
1773                     (reg:QI 0)
1774                     (match_operand 4 "immediate_operand" "")] UNSPEC_SRST))
1775    (clobber (match_scratch:P 1 "=a"))
1776    (clobber (reg:CC CC_REGNUM))]
1777   ""
1778   "srst\t%0,%1\;jo\t.-4"
1779   [(set_attr "length" "8")
1780    (set_attr "type" "vs")])
1781
1782 ;
1783 ; movmemM instruction pattern(s).
1784 ;
1785
1786 (define_expand "movmem<mode>"
1787   [(set (match_operand:BLK 0 "memory_operand" "")
1788         (match_operand:BLK 1 "memory_operand" ""))
1789    (use (match_operand:GPR 2 "general_operand" ""))
1790    (match_operand 3 "" "")]
1791   ""
1792   "s390_expand_movmem (operands[0], operands[1], operands[2]); DONE;")
1793
1794 ; Move a block that is up to 256 bytes in length.
1795 ; The block length is taken as (operands[2] % 256) + 1.
1796
1797 (define_expand "movmem_short"
1798   [(parallel
1799     [(set (match_operand:BLK 0 "memory_operand" "")
1800           (match_operand:BLK 1 "memory_operand" ""))
1801      (use (match_operand 2 "nonmemory_operand" ""))
1802      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1803      (clobber (match_dup 3))])]
1804   ""
1805   "operands[3] = gen_rtx_SCRATCH (Pmode);")
1806
1807 (define_insn "*movmem_short"
1808   [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q")
1809         (match_operand:BLK 1 "memory_operand" "Q,Q,Q"))
1810    (use (match_operand 2 "nonmemory_operand" "n,a,a"))
1811    (use (match_operand 3 "immediate_operand" "X,R,X"))
1812    (clobber (match_scratch 4 "=X,X,&a"))]
1813   "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)
1814    && GET_MODE (operands[4]) == Pmode"
1815   "#"
1816   [(set_attr "type" "cs")])
1817
1818 (define_split
1819   [(set (match_operand:BLK 0 "memory_operand" "")
1820         (match_operand:BLK 1 "memory_operand" ""))
1821    (use (match_operand 2 "const_int_operand" ""))
1822    (use (match_operand 3 "immediate_operand" ""))
1823    (clobber (scratch))]
1824   "reload_completed"
1825   [(parallel
1826     [(set (match_dup 0) (match_dup 1))
1827      (use (match_dup 2))])]
1828   "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
1829
1830 (define_split
1831   [(set (match_operand:BLK 0 "memory_operand" "")
1832         (match_operand:BLK 1 "memory_operand" ""))
1833    (use (match_operand 2 "register_operand" ""))
1834    (use (match_operand 3 "memory_operand" ""))
1835    (clobber (scratch))]
1836   "reload_completed"
1837   [(parallel
1838     [(unspec [(match_dup 2) (match_dup 3)
1839               (const_int 0)] UNSPEC_EXECUTE)
1840      (set (match_dup 0) (match_dup 1))
1841      (use (const_int 1))])]
1842   "")
1843
1844 (define_split
1845   [(set (match_operand:BLK 0 "memory_operand" "")
1846         (match_operand:BLK 1 "memory_operand" ""))
1847    (use (match_operand 2 "register_operand" ""))
1848    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1849    (clobber (match_operand 3 "register_operand" ""))]
1850   "reload_completed && TARGET_CPU_ZARCH"
1851   [(set (match_dup 3) (label_ref (match_dup 4)))
1852    (parallel
1853     [(unspec [(match_dup 2) (mem:BLK (match_dup 3)) 
1854               (label_ref (match_dup 4))] UNSPEC_EXECUTE)
1855      (set (match_dup 0) (match_dup 1))
1856      (use (const_int 1))])]
1857   "operands[4] = gen_label_rtx ();")
1858
1859 ; Move a block of arbitrary length.
1860
1861 (define_expand "movmem_long"
1862   [(parallel
1863     [(clobber (match_dup 2))
1864      (clobber (match_dup 3))
1865      (set (match_operand:BLK 0 "memory_operand" "")
1866           (match_operand:BLK 1 "memory_operand" ""))
1867      (use (match_operand 2 "general_operand" ""))
1868      (use (match_dup 3))
1869      (clobber (reg:CC CC_REGNUM))])]
1870   ""
1871 {
1872   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
1873   rtx reg0 = gen_reg_rtx (dword_mode);
1874   rtx reg1 = gen_reg_rtx (dword_mode);
1875   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
1876   rtx addr1 = gen_lowpart (Pmode, gen_highpart (word_mode, reg1));
1877   rtx len0 = gen_lowpart (Pmode, reg0);
1878   rtx len1 = gen_lowpart (Pmode, reg1);
1879
1880   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
1881   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
1882   emit_move_insn (len0, operands[2]);
1883
1884   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg1));
1885   emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
1886   emit_move_insn (len1, operands[2]);
1887
1888   operands[0] = replace_equiv_address_nv (operands[0], addr0);
1889   operands[1] = replace_equiv_address_nv (operands[1], addr1);
1890   operands[2] = reg0;
1891   operands[3] = reg1;
1892 })
1893
1894 (define_insn "*movmem_long_64"
1895   [(clobber (match_operand:TI 0 "register_operand" "=d"))
1896    (clobber (match_operand:TI 1 "register_operand" "=d"))
1897    (set (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
1898         (mem:BLK (subreg:DI (match_operand:TI 3 "register_operand" "1") 0)))
1899    (use (match_dup 2))
1900    (use (match_dup 3))
1901    (clobber (reg:CC CC_REGNUM))]
1902   "TARGET_64BIT"
1903   "mvcle\t%0,%1,0\;jo\t.-4"
1904   [(set_attr "length" "8")
1905    (set_attr "type" "vs")])
1906
1907 (define_insn "*movmem_long_31"
1908   [(clobber (match_operand:DI 0 "register_operand" "=d"))
1909    (clobber (match_operand:DI 1 "register_operand" "=d"))
1910    (set (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
1911         (mem:BLK (subreg:SI (match_operand:DI 3 "register_operand" "1") 0)))
1912    (use (match_dup 2))
1913    (use (match_dup 3))
1914    (clobber (reg:CC CC_REGNUM))]
1915   "!TARGET_64BIT"
1916   "mvcle\t%0,%1,0\;jo\t.-4"
1917   [(set_attr "length" "8")
1918    (set_attr "type" "vs")])
1919
1920 ;
1921 ; clrmemM instruction pattern(s).
1922 ;
1923
1924 (define_expand "clrmem<mode>"
1925   [(set (match_operand:BLK 0 "memory_operand" "")
1926         (const_int 0))
1927    (use (match_operand:GPR 1 "general_operand" ""))
1928    (match_operand 2 "" "")]
1929   ""
1930   "s390_expand_clrmem (operands[0], operands[1]); DONE;")
1931
1932 ; Clear a block that is up to 256 bytes in length.
1933 ; The block length is taken as (operands[1] % 256) + 1.
1934
1935 (define_expand "clrmem_short"
1936   [(parallel
1937     [(set (match_operand:BLK 0 "memory_operand" "")
1938           (const_int 0))
1939      (use (match_operand 1 "nonmemory_operand" ""))
1940      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1941      (clobber (match_dup 2))
1942      (clobber (reg:CC CC_REGNUM))])]
1943   ""
1944   "operands[2] = gen_rtx_SCRATCH (Pmode);")
1945
1946 (define_insn "*clrmem_short"
1947   [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q")
1948         (const_int 0))
1949    (use (match_operand 1 "nonmemory_operand" "n,a,a"))
1950    (use (match_operand 2 "immediate_operand" "X,R,X"))
1951    (clobber (match_scratch 3 "=X,X,&a"))
1952    (clobber (reg:CC CC_REGNUM))]
1953   "(GET_MODE (operands[1]) == Pmode || GET_MODE (operands[1]) == VOIDmode)
1954    && GET_MODE (operands[3]) == Pmode"
1955   "#"
1956   [(set_attr "type" "cs")])
1957
1958 (define_split
1959   [(set (match_operand:BLK 0 "memory_operand" "")
1960         (const_int 0))
1961    (use (match_operand 1 "const_int_operand" ""))
1962    (use (match_operand 2 "immediate_operand" ""))
1963    (clobber (scratch))
1964    (clobber (reg:CC CC_REGNUM))]
1965   "reload_completed"
1966   [(parallel
1967     [(set (match_dup 0) (const_int 0))
1968      (use (match_dup 1))
1969      (clobber (reg:CC CC_REGNUM))])]
1970   "operands[1] = GEN_INT ((INTVAL (operands[1]) & 0xff) + 1);")
1971
1972 (define_split
1973   [(set (match_operand:BLK 0 "memory_operand" "")
1974         (const_int 0))
1975    (use (match_operand 1 "register_operand" ""))
1976    (use (match_operand 2 "memory_operand" ""))
1977    (clobber (scratch))
1978    (clobber (reg:CC CC_REGNUM))]
1979   "reload_completed"
1980   [(parallel
1981     [(unspec [(match_dup 1) (match_dup 2)
1982               (const_int 0)] UNSPEC_EXECUTE)
1983      (set (match_dup 0) (const_int 0))
1984      (use (const_int 1))
1985      (clobber (reg:CC CC_REGNUM))])]
1986   "")
1987
1988 (define_split
1989   [(set (match_operand:BLK 0 "memory_operand" "")
1990         (const_int 0))
1991    (use (match_operand 1 "register_operand" ""))
1992    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
1993    (clobber (match_operand 2 "register_operand" ""))
1994    (clobber (reg:CC CC_REGNUM))]
1995   "reload_completed && TARGET_CPU_ZARCH"
1996   [(set (match_dup 2) (label_ref (match_dup 3)))
1997    (parallel
1998     [(unspec [(match_dup 1) (mem:BLK (match_dup 2)) 
1999               (label_ref (match_dup 3))] UNSPEC_EXECUTE)
2000      (set (match_dup 0) (const_int 0))
2001      (use (const_int 1))
2002      (clobber (reg:CC CC_REGNUM))])]
2003   "operands[3] = gen_label_rtx ();")
2004
2005 ; Clear a block of arbitrary length.
2006
2007 (define_expand "clrmem_long"
2008   [(parallel
2009     [(clobber (match_dup 1))
2010      (set (match_operand:BLK 0 "memory_operand" "")
2011           (const_int 0))
2012      (use (match_operand 1 "general_operand" ""))
2013      (use (match_dup 2))
2014      (clobber (reg:CC CC_REGNUM))])]
2015   ""
2016 {
2017   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
2018   rtx reg0 = gen_reg_rtx (dword_mode);
2019   rtx reg1 = gen_reg_rtx (dword_mode);
2020   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
2021   rtx len0 = gen_lowpart (Pmode, reg0);
2022
2023   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
2024   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
2025   emit_move_insn (len0, operands[1]);
2026
2027   emit_move_insn (reg1, const0_rtx);
2028
2029   operands[0] = replace_equiv_address_nv (operands[0], addr0);
2030   operands[1] = reg0;
2031   operands[2] = reg1;
2032 })
2033
2034 (define_insn "*clrmem_long_64"
2035   [(clobber (match_operand:TI 0 "register_operand" "=d"))
2036    (set (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
2037         (const_int 0))
2038    (use (match_dup 2))
2039    (use (match_operand:TI 1 "register_operand" "d"))
2040    (clobber (reg:CC CC_REGNUM))]
2041   "TARGET_64BIT"
2042   "mvcle\t%0,%1,0\;jo\t.-4"
2043   [(set_attr "length" "8")
2044    (set_attr "type" "vs")])
2045
2046 (define_insn "*clrmem_long_31"
2047   [(clobber (match_operand:DI 0 "register_operand" "=d"))
2048    (set (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
2049         (const_int 0))
2050    (use (match_dup 2))
2051    (use (match_operand:DI 1 "register_operand" "d"))
2052    (clobber (reg:CC CC_REGNUM))]
2053   "!TARGET_64BIT"
2054   "mvcle\t%0,%1,0\;jo\t.-4"
2055   [(set_attr "length" "8")
2056    (set_attr "type" "vs")])
2057
2058 ;
2059 ; cmpmemM instruction pattern(s).
2060 ;
2061
2062 (define_expand "cmpmemsi"
2063   [(set (match_operand:SI 0 "register_operand" "")
2064         (compare:SI (match_operand:BLK 1 "memory_operand" "")
2065                     (match_operand:BLK 2 "memory_operand" "") ) )
2066    (use (match_operand:SI 3 "general_operand" ""))
2067    (use (match_operand:SI 4 "" ""))]
2068   ""
2069   "s390_expand_cmpmem (operands[0], operands[1],
2070                        operands[2], operands[3]); DONE;")
2071
2072 ; Compare a block that is up to 256 bytes in length.
2073 ; The block length is taken as (operands[2] % 256) + 1.
2074
2075 (define_expand "cmpmem_short"
2076   [(parallel
2077     [(set (reg:CCU CC_REGNUM)
2078           (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2079                        (match_operand:BLK 1 "memory_operand" "")))
2080      (use (match_operand 2 "nonmemory_operand" ""))
2081      (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2082      (clobber (match_dup 3))])]
2083   ""
2084   "operands[3] = gen_rtx_SCRATCH (Pmode);")
2085
2086 (define_insn "*cmpmem_short"
2087   [(set (reg:CCU CC_REGNUM)
2088         (compare:CCU (match_operand:BLK 0 "memory_operand" "Q,Q,Q")
2089                      (match_operand:BLK 1 "memory_operand" "Q,Q,Q")))
2090    (use (match_operand 2 "nonmemory_operand" "n,a,a"))
2091    (use (match_operand 3 "immediate_operand" "X,R,X"))
2092    (clobber (match_scratch 4 "=X,X,&a"))]
2093   "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)
2094    && GET_MODE (operands[4]) == Pmode"
2095   "#"
2096   [(set_attr "type" "cs")])
2097
2098 (define_split
2099   [(set (reg:CCU CC_REGNUM)
2100         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2101                      (match_operand:BLK 1 "memory_operand" "")))
2102    (use (match_operand 2 "const_int_operand" ""))
2103    (use (match_operand 3 "immediate_operand" ""))
2104    (clobber (scratch))]
2105   "reload_completed"
2106   [(parallel
2107     [(set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
2108      (use (match_dup 2))])]
2109   "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
2110
2111 (define_split
2112   [(set (reg:CCU CC_REGNUM)
2113         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2114                      (match_operand:BLK 1 "memory_operand" "")))
2115    (use (match_operand 2 "register_operand" ""))
2116    (use (match_operand 3 "memory_operand" ""))
2117    (clobber (scratch))]
2118   "reload_completed"
2119   [(parallel
2120     [(unspec [(match_dup 2) (match_dup 3)
2121               (const_int 0)] UNSPEC_EXECUTE)
2122      (set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
2123      (use (const_int 1))])]
2124   "")
2125
2126 (define_split
2127   [(set (reg:CCU CC_REGNUM)
2128         (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2129                      (match_operand:BLK 1 "memory_operand" "")))
2130    (use (match_operand 2 "register_operand" ""))
2131    (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2132    (clobber (match_operand 3 "register_operand" ""))]
2133   "reload_completed && TARGET_CPU_ZARCH"
2134   [(set (match_dup 3) (label_ref (match_dup 4)))
2135    (parallel
2136     [(unspec [(match_dup 2) (mem:BLK (match_dup 3)) 
2137               (label_ref (match_dup 4))] UNSPEC_EXECUTE)
2138      (set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
2139      (use (const_int 1))])]
2140   "operands[4] = gen_label_rtx ();")
2141
2142 ; Compare a block of arbitrary length.
2143
2144 (define_expand "cmpmem_long"
2145   [(parallel
2146     [(clobber (match_dup 2))
2147      (clobber (match_dup 3))
2148      (set (reg:CCU CC_REGNUM)
2149           (compare:CCU (match_operand:BLK 0 "memory_operand" "")
2150                        (match_operand:BLK 1 "memory_operand" "")))
2151      (use (match_operand 2 "general_operand" ""))
2152      (use (match_dup 3))])]
2153   ""
2154 {
2155   enum machine_mode dword_mode = word_mode == DImode ? TImode : DImode;
2156   rtx reg0 = gen_reg_rtx (dword_mode);
2157   rtx reg1 = gen_reg_rtx (dword_mode);
2158   rtx addr0 = gen_lowpart (Pmode, gen_highpart (word_mode, reg0));
2159   rtx addr1 = gen_lowpart (Pmode, gen_highpart (word_mode, reg1));
2160   rtx len0 = gen_lowpart (Pmode, reg0);
2161   rtx len1 = gen_lowpart (Pmode, reg1);
2162
2163   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg0));
2164   emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
2165   emit_move_insn (len0, operands[2]);
2166
2167   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg1));
2168   emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
2169   emit_move_insn (len1, operands[2]);
2170
2171   operands[0] = replace_equiv_address_nv (operands[0], addr0);
2172   operands[1] = replace_equiv_address_nv (operands[1], addr1);
2173   operands[2] = reg0;
2174   operands[3] = reg1;
2175 })
2176
2177 (define_insn "*cmpmem_long_64"
2178   [(clobber (match_operand:TI 0 "register_operand" "=d"))
2179    (clobber (match_operand:TI 1 "register_operand" "=d"))
2180    (set (reg:CCU CC_REGNUM)
2181         (compare:CCU (mem:BLK (subreg:DI (match_operand:TI 2 "register_operand" "0") 0))
2182                      (mem:BLK (subreg:DI (match_operand:TI 3 "register_operand" "1") 0))))
2183    (use (match_dup 2))
2184    (use (match_dup 3))]
2185   "TARGET_64BIT"
2186   "clcle\t%0,%1,0\;jo\t.-4"
2187   [(set_attr "length" "8")
2188    (set_attr "type" "vs")])
2189
2190 (define_insn "*cmpmem_long_31"
2191   [(clobber (match_operand:DI 0 "register_operand" "=d"))
2192    (clobber (match_operand:DI 1 "register_operand" "=d"))
2193    (set (reg:CCU CC_REGNUM)
2194         (compare:CCU (mem:BLK (subreg:SI (match_operand:DI 2 "register_operand" "0") 0))
2195                      (mem:BLK (subreg:SI (match_operand:DI 3 "register_operand" "1") 0))))
2196    (use (match_dup 2))
2197    (use (match_dup 3))]
2198   "!TARGET_64BIT"
2199   "clcle\t%0,%1,0\;jo\t.-4"
2200   [(set_attr "length" "8")
2201    (set_attr "type" "vs")])
2202
2203 ; Convert CCUmode condition code to integer.
2204 ; Result is zero if EQ, positive if LTU, negative if GTU.
2205
2206 (define_insn_and_split "cmpint"
2207   [(set (match_operand:SI 0 "register_operand" "=d")
2208         (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2209                    UNSPEC_CMPINT))
2210    (clobber (reg:CC CC_REGNUM))]
2211   ""
2212   "#"
2213   "reload_completed"
2214   [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
2215    (parallel
2216     [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))
2217      (clobber (reg:CC CC_REGNUM))])])
2218
2219 (define_insn_and_split "*cmpint_cc"
2220   [(set (reg CC_REGNUM)
2221         (compare (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2222                             UNSPEC_CMPINT)
2223                  (const_int 0)))
2224    (set (match_operand:SI 0 "register_operand" "=d")
2225         (unspec:SI [(match_dup 1)] UNSPEC_CMPINT))]
2226   "s390_match_ccmode (insn, CCSmode)"
2227   "#"
2228   "&& reload_completed"
2229   [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
2230    (parallel
2231     [(set (match_dup 2) (match_dup 3))
2232      (set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))])]
2233 {
2234   rtx result = gen_rtx_ASHIFTRT (SImode, operands[0], GEN_INT (30));
2235   operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
2236   operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
2237 })
2238
2239 (define_insn_and_split "*cmpint_sign"
2240   [(set (match_operand:DI 0 "register_operand" "=d")
2241         (sign_extend:DI (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2242                                    UNSPEC_CMPINT)))
2243    (clobber (reg:CC CC_REGNUM))]
2244   "TARGET_64BIT"
2245   "#"
2246   "&& reload_completed"
2247   [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
2248    (parallel
2249     [(set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))
2250      (clobber (reg:CC CC_REGNUM))])])
2251
2252 (define_insn_and_split "*cmpint_sign_cc"
2253   [(set (reg CC_REGNUM)
2254         (compare (ashiftrt:DI (ashift:DI (subreg:DI 
2255                    (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
2256                               UNSPEC_CMPINT) 0)
2257                    (const_int 32)) (const_int 32))
2258                  (const_int 0)))
2259    (set (match_operand:DI 0 "register_operand" "=d")
2260         (sign_extend:DI (unspec:SI [(match_dup 1)] UNSPEC_CMPINT)))]
2261   "s390_match_ccmode (insn, CCSmode) && TARGET_64BIT"
2262   "#"
2263   "&& reload_completed"
2264   [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
2265    (parallel
2266     [(set (match_dup 2) (match_dup 3))
2267      (set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))])]
2268 {
2269   rtx result = gen_rtx_ASHIFTRT (DImode, operands[0], GEN_INT (62));
2270   operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
2271   operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
2272 })
2273
2274
2275 ;;
2276 ;;- Conversion instructions.
2277 ;;
2278
2279
2280 (define_insn "*sethigh<mode>si"
2281   [(set (match_operand:SI 0 "register_operand" "=d,d")
2282         (unspec:SI [(match_operand:HQI 1 "s_operand" "Q,S")] UNSPEC_SETHIGH))
2283    (clobber (reg:CC CC_REGNUM))]
2284   ""
2285   "@
2286    icm\t%0,<icm_hi>,%S1
2287    icmy\t%0,<icm_hi>,%S1"
2288   [(set_attr "op_type" "RS,RSY")])
2289
2290 (define_insn "*sethighqidi_64"
2291   [(set (match_operand:DI 0 "register_operand" "=d")
2292         (unspec:DI [(match_operand:QI 1 "s_operand" "QS")] UNSPEC_SETHIGH))
2293    (clobber (reg:CC CC_REGNUM))]
2294   "TARGET_64BIT"
2295   "icmh\t%0,8,%S1"
2296   [(set_attr "op_type" "RSY")])
2297
2298 (define_insn "*sethighqidi_31"
2299   [(set (match_operand:DI 0 "register_operand" "=d,d")
2300         (unspec:DI [(match_operand:QI 1 "s_operand" "Q,S")] UNSPEC_SETHIGH))
2301    (clobber (reg:CC CC_REGNUM))]
2302   "!TARGET_64BIT"
2303   "@
2304    icm\t%0,8,%S1
2305    icmy\t%0,8,%S1"
2306   [(set_attr "op_type" "RS,RSY")])
2307
2308 (define_insn_and_split "*extractqi"
2309   [(set (match_operand:SI 0 "register_operand" "=d")
2310         (zero_extract:SI (match_operand:QI 1 "s_operand" "Q")
2311                          (match_operand 2 "const_int_operand" "n")
2312                          (const_int 0)))
2313    (clobber (reg:CC CC_REGNUM))]
2314   "!TARGET_64BIT
2315    && INTVAL (operands[2]) > 0 && INTVAL (operands[2]) < 8"
2316   "#"
2317   "&& reload_completed"
2318   [(parallel
2319     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2320      (clobber (reg:CC CC_REGNUM))])
2321     (set (match_dup 0) (lshiftrt:SI (match_dup 0) (match_dup 2)))]
2322 {
2323   operands[2] = GEN_INT (32 - INTVAL (operands[2]));
2324   operands[1] = change_address (operands[1], QImode, 0);
2325 })
2326
2327 (define_insn_and_split "*extracthi"
2328   [(set (match_operand:SI 0 "register_operand" "=d")
2329         (zero_extract:SI (match_operand:QI 1 "s_operand" "Q")
2330                          (match_operand 2 "const_int_operand" "n")
2331                          (const_int 0)))
2332    (clobber (reg:CC CC_REGNUM))]
2333   "!TARGET_64BIT
2334    && INTVAL (operands[2]) >= 8 && INTVAL (operands[2]) < 16"
2335   "#"
2336   "&& reload_completed"
2337   [(parallel
2338     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2339      (clobber (reg:CC CC_REGNUM))])
2340     (set (match_dup 0) (lshiftrt:SI (match_dup 0) (match_dup 2)))]
2341 {
2342   operands[2] = GEN_INT (32 - INTVAL (operands[2]));
2343   operands[1] = change_address (operands[1], HImode, 0);
2344 })
2345
2346 ;
2347 ; extendsidi2 instruction pattern(s).
2348 ;
2349
2350 (define_expand "extendsidi2"
2351   [(set (match_operand:DI 0 "register_operand" "")
2352         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
2353   ""
2354   "
2355 {
2356   if (!TARGET_64BIT)
2357     {
2358       emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
2359       emit_move_insn (gen_highpart (SImode, operands[0]), operands[1]);
2360       emit_move_insn (gen_lowpart (SImode, operands[0]), const0_rtx);
2361       emit_insn (gen_ashrdi3 (operands[0], operands[0], GEN_INT (32)));
2362       DONE;
2363     }
2364 }
2365 ")
2366
2367 (define_insn "*extendsidi2"
2368   [(set (match_operand:DI 0 "register_operand" "=d,d")
2369         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m")))]
2370   "TARGET_64BIT"
2371   "@
2372    lgfr\t%0,%1
2373    lgf\t%0,%1"
2374   [(set_attr "op_type" "RRE,RXY")])
2375
2376 ;
2377 ; extend(hi|qi)di2 instruction pattern(s).
2378 ;
2379
2380 (define_expand "extend<mode>di2"
2381   [(set (match_operand:DI 0 "register_operand" "")
2382         (sign_extend:DI (match_operand:HQI 1 "register_operand" "")))]
2383   ""
2384   "
2385 {
2386   if (!TARGET_64BIT)
2387     {
2388       rtx tmp = gen_reg_rtx (SImode);
2389       emit_insn (gen_extend<mode>si2 (tmp, operands[1]));
2390       emit_insn (gen_extendsidi2 (operands[0], tmp));
2391       DONE;
2392     }
2393   else
2394     {
2395       rtx bitcount = GEN_INT (GET_MODE_BITSIZE (DImode) - 
2396                               GET_MODE_BITSIZE (<MODE>mode));
2397       operands[1] = gen_lowpart (DImode, operands[1]);
2398       emit_insn (gen_ashldi3 (operands[0], operands[1], bitcount));
2399       emit_insn (gen_ashrdi3 (operands[0], operands[0], bitcount));
2400       DONE;
2401     }
2402 }
2403 ")
2404
2405 (define_insn "*extendhidi2"
2406   [(set (match_operand:DI 0 "register_operand" "=d")
2407         (sign_extend:DI (match_operand:HI 1 "memory_operand" "m")))]
2408   "TARGET_64BIT"
2409   "lgh\t%0,%1"
2410   [(set_attr "op_type" "RXY")])
2411
2412 (define_insn "*extendqidi2"
2413   [(set (match_operand:DI 0 "register_operand" "=d")
2414         (sign_extend:DI (match_operand:QI 1 "memory_operand" "m")))]
2415   "TARGET_64BIT && TARGET_LONG_DISPLACEMENT"
2416   "lgb\t%0,%1"
2417   [(set_attr "op_type" "RXY")])
2418
2419 (define_insn_and_split "*extendqidi2_short_displ"
2420   [(set (match_operand:DI 0 "register_operand" "=d")
2421         (sign_extend:DI (match_operand:QI 1 "s_operand" "Q")))
2422    (clobber (reg:CC CC_REGNUM))]
2423   "TARGET_64BIT && !TARGET_LONG_DISPLACEMENT"
2424   "#"
2425   "&& reload_completed"
2426   [(parallel
2427     [(set (match_dup 0) (unspec:DI [(match_dup 1)] UNSPEC_SETHIGH))
2428      (clobber (reg:CC CC_REGNUM))])
2429    (parallel
2430     [(set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 56)))
2431      (clobber (reg:CC CC_REGNUM))])]
2432   "")
2433
2434 ;
2435 ; extend(hi|qi)si2 instruction pattern(s).
2436 ;
2437
2438 (define_expand "extend<mode>si2"
2439   [(set (match_operand:SI 0 "register_operand" "")
2440         (sign_extend:SI (match_operand:HQI 1 "register_operand" "")))]
2441   ""
2442   "
2443 {
2444   rtx bitcount = GEN_INT (GET_MODE_BITSIZE(SImode) - 
2445                           GET_MODE_BITSIZE(<MODE>mode));
2446   operands[1] = gen_lowpart (SImode, operands[1]);
2447   emit_insn (gen_ashlsi3 (operands[0], operands[1], bitcount));
2448   emit_insn (gen_ashrsi3 (operands[0], operands[0], bitcount));
2449   DONE;
2450 }
2451 ")
2452
2453 (define_insn "*extendhisi2"
2454   [(set (match_operand:SI 0 "register_operand" "=d,d")
2455         (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T")))]
2456   ""
2457   "@
2458    lh\t%0,%1
2459    lhy\t%0,%1"
2460   [(set_attr "op_type" "RX,RXY")])
2461
2462 (define_insn "*extendqisi2"
2463   [(set (match_operand:SI 0 "register_operand" "=d")
2464         (sign_extend:SI (match_operand:QI 1 "memory_operand" "m")))]
2465   "TARGET_LONG_DISPLACEMENT"
2466   "lb\t%0,%1"
2467   [(set_attr "op_type" "RXY")])
2468
2469 (define_insn_and_split "*extendqisi2_short_displ"
2470   [(set (match_operand:SI 0 "register_operand" "=d")
2471         (sign_extend:SI (match_operand:QI 1 "s_operand" "Q")))
2472    (clobber (reg:CC CC_REGNUM))]
2473   "!TARGET_LONG_DISPLACEMENT"
2474   "#"
2475   "&& reload_completed"
2476   [(parallel
2477     [(set (match_dup 0) (unspec:SI [(match_dup 1)] UNSPEC_SETHIGH))
2478      (clobber (reg:CC CC_REGNUM))])
2479    (parallel
2480     [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 24)))
2481      (clobber (reg:CC CC_REGNUM))])]
2482   "")
2483
2484 ;
2485 ; extendqihi2 instruction pattern(s).
2486 ;
2487
2488
2489 ;
2490 ; zero_extendsidi2 instruction pattern(s).
2491 ;
2492
2493 (define_expand "zero_extendsidi2"
2494   [(set (match_operand:DI 0 "register_operand" "")
2495         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
2496   ""
2497   "
2498 {
2499   if (!TARGET_64BIT)
2500     {
2501       emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
2502       emit_move_insn (gen_lowpart (SImode, operands[0]), operands[1]);
2503       emit_move_insn (gen_highpart (SImode, operands[0]), const0_rtx);
2504       DONE;
2505     }
2506 }
2507 ")
2508
2509 (define_insn "*zero_extendsidi2"
2510   [(set (match_operand:DI 0 "register_operand" "=d,d")
2511         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,m")))]
2512   "TARGET_64BIT"
2513   "@
2514    llgfr\t%0,%1
2515    llgf\t%0,%1"
2516   [(set_attr "op_type" "RRE,RXY")])
2517
2518 ;
2519 ; zero_extend(hi|qi)di2 instruction pattern(s).
2520 ;
2521
2522 (define_expand "zero_extend<mode>di2"
2523   [(set (match_operand:DI 0 "register_operand" "")
2524         (zero_extend:DI (match_operand:HQI 1 "register_operand" "")))]
2525   ""
2526   "
2527 {
2528   if (!TARGET_64BIT)
2529     {
2530       rtx tmp = gen_reg_rtx (SImode);
2531       emit_insn (gen_zero_extend<mode>si2 (tmp, operands[1]));
2532       emit_insn (gen_zero_extendsidi2 (operands[0], tmp));
2533       DONE;
2534     }
2535   else
2536     {
2537       rtx bitcount = GEN_INT (GET_MODE_BITSIZE(DImode) - 
2538                               GET_MODE_BITSIZE(<MODE>mode));
2539       operands[1] = gen_lowpart (DImode, operands[1]);
2540       emit_insn (gen_ashldi3 (operands[0], operands[1], bitcount));
2541       emit_insn (gen_lshrdi3 (operands[0], operands[0], bitcount));
2542       DONE;
2543     }
2544 }
2545 ")
2546
2547 (define_insn "*zero_extend<mode>di2"
2548   [(set (match_operand:DI 0 "register_operand" "=d")
2549         (zero_extend:DI (match_operand:HQI 1 "memory_operand" "m")))]
2550   "TARGET_64BIT"
2551   "llg<hc>\t%0,%1"
2552   [(set_attr "op_type" "RXY")])
2553
2554 ;
2555 ; LLGT-type instructions (zero-extend from 31 bit to 64 bit).
2556 ;
2557
2558 (define_insn "*llgt_sidi"
2559   [(set (match_operand:DI 0 "register_operand" "=d")
2560         (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "m") 0)
2561                 (const_int 2147483647)))]
2562   "TARGET_64BIT"
2563   "llgt\t%0,%1"
2564   [(set_attr "op_type"  "RXE")])
2565
2566 (define_insn_and_split "*llgt_sidi_split"
2567   [(set (match_operand:DI 0 "register_operand" "=d")
2568         (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "m") 0)
2569                 (const_int 2147483647)))
2570    (clobber (reg:CC CC_REGNUM))]
2571   "TARGET_64BIT"
2572   "#"
2573   "&& reload_completed"
2574   [(set (match_dup 0)
2575         (and:DI (subreg:DI (match_dup 1) 0)
2576                 (const_int 2147483647)))]
2577   "")
2578
2579 (define_insn "*llgt_sisi"
2580   [(set (match_operand:SI 0 "register_operand" "=d,d")
2581         (and:SI (match_operand:SI 1 "nonimmediate_operand" "d,m")
2582                 (const_int 2147483647)))]
2583   "TARGET_64BIT"
2584   "@
2585    llgtr\t%0,%1
2586    llgt\t%0,%1"
2587   [(set_attr "op_type"  "RRE,RXE")])
2588
2589 (define_insn "*llgt_didi"
2590   [(set (match_operand:DI 0 "register_operand" "=d,d")
2591         (and:DI (match_operand:DI 1 "nonimmediate_operand" "d,o")
2592                 (const_int 2147483647)))]
2593   "TARGET_64BIT"
2594   "@
2595    llgtr\t%0,%1
2596    llgt\t%0,%N1"
2597   [(set_attr "op_type"  "RRE,RXE")])
2598
2599 (define_split
2600   [(set (match_operand:GPR 0 "register_operand" "")
2601         (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "")
2602                  (const_int 2147483647)))
2603    (clobber (reg:CC CC_REGNUM))]
2604   "TARGET_64BIT && reload_completed"
2605   [(set (match_dup 0)
2606         (and:GPR (match_dup 1)
2607                  (const_int 2147483647)))]
2608   "")
2609
2610 ;
2611 ; zero_extend(hi|qi)si2 instruction pattern(s).
2612 ;
2613
2614 (define_expand "zero_extend<mode>si2"
2615   [(set (match_operand:SI 0 "register_operand" "")
2616         (zero_extend:SI (match_operand:HQI 1 "register_operand" "")))]
2617   ""
2618   "
2619 {
2620   operands[1] = gen_lowpart (SImode, operands[1]);
2621   emit_insn (gen_andsi3 (operands[0], operands[1], 
2622     GEN_INT ((1 << GET_MODE_BITSIZE(<MODE>mode)) - 1)));
2623   DONE;
2624 }
2625 ")
2626
2627 (define_insn "*zero_extend<mode>si2_64"
2628   [(set (match_operand:SI 0 "register_operand" "=d")
2629         (zero_extend:SI (match_operand:HQI 1 "memory_operand" "m")))]
2630   "TARGET_ZARCH"
2631   "llg<hc>\t%0,%1"
2632   [(set_attr "op_type" "RXY")])
2633
2634 (define_insn_and_split "*zero_extendhisi2_31"
2635   [(set (match_operand:SI 0 "register_operand" "=&d")
2636         (zero_extend:SI (match_operand:HI 1 "s_operand" "QS")))
2637    (clobber (reg:CC CC_REGNUM))]
2638   "!TARGET_ZARCH"
2639   "#"
2640   "&& reload_completed"
2641   [(set (match_dup 0) (const_int 0))
2642    (parallel
2643     [(set (strict_low_part (match_dup 2)) (match_dup 1))
2644      (clobber (reg:CC CC_REGNUM))])]
2645   "operands[2] = gen_lowpart (HImode, operands[0]);")
2646
2647 (define_insn_and_split "*zero_extendqisi2_31"
2648   [(set (match_operand:SI 0 "register_operand" "=&d")
2649         (zero_extend:SI (match_operand:QI 1 "memory_operand" "m")))]
2650   "!TARGET_ZARCH"
2651   "#"
2652   "&& reload_completed"
2653   [(set (match_dup 0) (const_int 0))
2654    (set (strict_low_part (match_dup 2)) (match_dup 1))]
2655   "operands[2] = gen_lowpart (QImode, operands[0]);")
2656
2657 ;
2658 ; zero_extendqihi2 instruction pattern(s).
2659 ;
2660
2661 (define_expand "zero_extendqihi2"
2662   [(set (match_operand:HI 0 "register_operand" "")
2663         (zero_extend:HI (match_operand:QI 1 "register_operand" "")))]
2664   "TARGET_ZARCH"
2665   "
2666 {
2667   operands[1] = gen_lowpart (HImode, operands[1]);
2668   emit_insn (gen_andhi3 (operands[0], operands[1], GEN_INT (0xff)));
2669   DONE;
2670 }
2671 ")
2672
2673 (define_insn "*zero_extendqihi2_64"
2674   [(set (match_operand:HI 0 "register_operand" "=d")
2675         (zero_extend:HI (match_operand:QI 1 "memory_operand" "m")))]
2676   "TARGET_ZARCH"
2677   "llgc\t%0,%1"
2678   [(set_attr "op_type" "RXY")])
2679
2680 (define_insn_and_split "*zero_extendqihi2_31"
2681   [(set (match_operand:HI 0 "register_operand" "=&d")
2682         (zero_extend:HI (match_operand:QI 1 "memory_operand" "m")))]
2683   "!TARGET_ZARCH"
2684   "#"
2685   "&& reload_completed"
2686   [(set (match_dup 0) (const_int 0))
2687    (set (strict_low_part (match_dup 2)) (match_dup 1))]
2688   "operands[2] = gen_lowpart (QImode, operands[0]);")
2689
2690
2691 ;
2692 ; fixuns_trunc(sf|df)(si|di)2 and fix_trunc(sf|df)(si|di)2 instruction pattern(s).
2693 ;
2694
2695 (define_expand "fixuns_trunc<FPR:mode><GPR:mode>2"
2696   [(set (match_operand:GPR 0 "register_operand" "")
2697         (unsigned_fix:GPR (match_operand:FPR 1 "register_operand" "")))]
2698   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2699 {
2700   rtx label1 = gen_label_rtx ();
2701   rtx label2 = gen_label_rtx ();
2702   rtx temp = gen_reg_rtx (<FPR:MODE>mode);
2703   REAL_VALUE_TYPE cmp, sub;
2704   
2705   operands[1] = force_reg (<FPR:MODE>mode, operands[1]);
2706   real_2expN (&cmp, GET_MODE_BITSIZE(<GPR:MODE>mode) - 1);
2707   real_2expN (&sub, GET_MODE_BITSIZE(<GPR:MODE>mode));
2708   
2709   emit_insn (gen_cmp<FPR:mode> (operands[1],
2710         CONST_DOUBLE_FROM_REAL_VALUE (cmp, <FPR:MODE>mode)));
2711   emit_jump_insn (gen_blt (label1));
2712   emit_insn (gen_sub<FPR:mode>3 (temp, operands[1],
2713         CONST_DOUBLE_FROM_REAL_VALUE (sub, <FPR:MODE>mode)));
2714   emit_insn (gen_fix_trunc<FPR:mode><GPR:mode>2_ieee (operands[0], temp,
2715         GEN_INT(7)));
2716   emit_jump (label2);
2717
2718   emit_label (label1);
2719   emit_insn (gen_fix_trunc<FPR:mode><GPR:mode>2_ieee (operands[0],
2720         operands[1], GEN_INT(5)));
2721   emit_label (label2);
2722   DONE;
2723 })
2724
2725 (define_expand "fix_trunc<FPR:mode>di2"
2726   [(set (match_operand:DI 0 "register_operand" "")
2727         (fix:DI (match_operand:FPR 1 "nonimmediate_operand" "")))]
2728   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2729 {
2730   operands[1] = force_reg (<FPR:MODE>mode, operands[1]);
2731   emit_insn (gen_fix_trunc<FPR:mode>di2_ieee (operands[0], operands[1],
2732       GEN_INT(5)));
2733   DONE;
2734 })
2735
2736 (define_insn "fix_trunc<FPR:mode><GPR:mode>2_ieee"
2737   [(set (match_operand:GPR 0 "register_operand" "=d")
2738         (fix:GPR (match_operand:FPR 1 "register_operand" "f")))
2739    (unspec:GPR [(match_operand:GPR 2 "immediate_operand" "K")] UNSPEC_ROUND)
2740    (clobber (reg:CC CC_REGNUM))]
2741   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2742   "c<GPR:gf><FPR:de>br\t%0,%h2,%1"
2743   [(set_attr "op_type" "RRE")
2744    (set_attr "type"    "ftoi")])
2745
2746 ;
2747 ; fix_truncdfsi2 instruction pattern(s).
2748 ;
2749
2750 (define_expand "fix_truncdfsi2"
2751   [(set (match_operand:SI 0 "register_operand" "")
2752         (fix:SI (match_operand:DF 1 "nonimmediate_operand" "")))]
2753   "TARGET_HARD_FLOAT"
2754 {
2755   if (TARGET_IBM_FLOAT)
2756     {
2757       /* This is the algorithm from POP chapter A.5.7.2.  */
2758
2759       rtx temp   = assign_stack_local (BLKmode, 8, BITS_PER_WORD);
2760       rtx two31r = s390_gen_rtx_const_DI (0x4f000000, 0x08000000);
2761       rtx two32  = s390_gen_rtx_const_DI (0x4e000001, 0x00000000);
2762
2763       operands[1] = force_reg (DFmode, operands[1]);
2764       emit_insn (gen_fix_truncdfsi2_ibm (operands[0], operands[1],
2765                                          two31r, two32, temp));
2766     }
2767   else
2768     {
2769       operands[1] = force_reg (DFmode, operands[1]);
2770       emit_insn (gen_fix_truncdfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2771     }
2772
2773   DONE;
2774 })
2775
2776 (define_insn "fix_truncdfsi2_ibm"
2777   [(set (match_operand:SI 0 "register_operand" "=d")
2778         (fix:SI (match_operand:DF 1 "nonimmediate_operand" "+f")))
2779    (use (match_operand:DI 2 "immediate_operand" "m"))
2780    (use (match_operand:DI 3 "immediate_operand" "m"))
2781    (use (match_operand:BLK 4 "memory_operand" "m"))
2782    (clobber (reg:CC CC_REGNUM))]
2783   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2784 {
2785    output_asm_insn ("sd\t%1,%2", operands);
2786    output_asm_insn ("aw\t%1,%3", operands);
2787    output_asm_insn ("std\t%1,%4", operands);
2788    output_asm_insn ("xi\t%N4,128", operands);
2789    return "l\t%0,%N4";
2790 }
2791   [(set_attr "length" "20")])
2792
2793 ;
2794 ; fix_truncsfsi2 instruction pattern(s).
2795 ;
2796
2797 (define_expand "fix_truncsfsi2"
2798   [(set (match_operand:SI 0 "register_operand" "")
2799         (fix:SI (match_operand:SF 1 "nonimmediate_operand" "")))]
2800   "TARGET_HARD_FLOAT"
2801 {
2802   if (TARGET_IBM_FLOAT)
2803     {
2804       /* Convert to DFmode and then use the POP algorithm.  */
2805       rtx temp = gen_reg_rtx (DFmode);
2806       emit_insn (gen_extendsfdf2 (temp, operands[1]));
2807       emit_insn (gen_fix_truncdfsi2 (operands[0], temp));
2808     }
2809   else
2810     {
2811       operands[1] = force_reg (SFmode, operands[1]);
2812       emit_insn (gen_fix_truncsfsi2_ieee (operands[0], operands[1], GEN_INT (5)));
2813     }
2814
2815   DONE;
2816 })
2817
2818 ;
2819 ; floatdi(df|sf)2 instruction pattern(s).
2820 ;
2821
2822 (define_insn "floatdi<mode>2"
2823   [(set (match_operand:FPR 0 "register_operand" "=f")
2824         (float:FPR (match_operand:DI 1 "register_operand" "d")))]
2825   "TARGET_64BIT && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2826   "c<de>gbr\t%0,%1"
2827   [(set_attr "op_type" "RRE")
2828    (set_attr "type"    "itof" )])
2829
2830 ;
2831 ; floatsidf2 instruction pattern(s).
2832 ;
2833
2834 (define_expand "floatsidf2"
2835   [(set (match_operand:DF 0 "register_operand" "")
2836         (float:DF (match_operand:SI 1 "register_operand" "")))]
2837   "TARGET_HARD_FLOAT"
2838 {
2839   if (TARGET_IBM_FLOAT)
2840     {
2841       /* This is the algorithm from POP chapter A.5.7.1.  */
2842
2843       rtx temp  = assign_stack_local (BLKmode, 8, BITS_PER_WORD);
2844       rtx two31 = s390_gen_rtx_const_DI (0x4e000000, 0x80000000);
2845
2846       emit_insn (gen_floatsidf2_ibm (operands[0], operands[1], two31, temp));
2847       DONE;
2848     }
2849 })
2850
2851 (define_insn "floatsidf2_ieee"
2852   [(set (match_operand:DF 0 "register_operand" "=f")
2853         (float:DF (match_operand:SI 1 "register_operand" "d")))]
2854   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2855   "cdfbr\t%0,%1"
2856   [(set_attr "op_type" "RRE")
2857    (set_attr "type"   "itof" )])
2858
2859 (define_insn "floatsidf2_ibm"
2860   [(set (match_operand:DF 0 "register_operand" "=f")
2861         (float:DF (match_operand:SI 1 "register_operand" "d")))
2862    (use (match_operand:DI 2 "immediate_operand" "m"))
2863    (use (match_operand:BLK 3 "memory_operand" "m"))
2864    (clobber (reg:CC CC_REGNUM))]
2865   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2866 {
2867    output_asm_insn ("st\t%1,%N3", operands);
2868    output_asm_insn ("xi\t%N3,128", operands);
2869    output_asm_insn ("mvc\t%O3(4,%R3),%2", operands);
2870    output_asm_insn ("ld\t%0,%3", operands);
2871    return "sd\t%0,%2";
2872 }
2873   [(set_attr "length" "20")])
2874
2875 ;
2876 ; floatsisf2 instruction pattern(s).
2877 ;
2878
2879 (define_expand "floatsisf2"
2880   [(set (match_operand:SF 0 "register_operand" "")
2881         (float:SF (match_operand:SI 1 "register_operand" "")))]
2882   "TARGET_HARD_FLOAT"
2883 {
2884   if (TARGET_IBM_FLOAT)
2885     {
2886       /* Use the POP algorithm to convert to DFmode and then truncate.  */
2887       rtx temp = gen_reg_rtx (DFmode);
2888       emit_insn (gen_floatsidf2 (temp, operands[1]));
2889       emit_insn (gen_truncdfsf2 (operands[0], temp));
2890       DONE;
2891     }
2892 })
2893
2894 (define_insn "floatsisf2_ieee"
2895   [(set (match_operand:SF 0 "register_operand" "=f")
2896         (float:SF (match_operand:SI 1 "register_operand" "d")))]
2897   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2898   "cefbr\t%0,%1"
2899   [(set_attr "op_type" "RRE")
2900    (set_attr "type"    "itof" )])
2901
2902 ;
2903 ; truncdfsf2 instruction pattern(s).
2904 ;
2905
2906 (define_expand "truncdfsf2"
2907   [(set (match_operand:SF 0 "register_operand" "")
2908         (float_truncate:SF (match_operand:DF 1 "register_operand" "")))]
2909   "TARGET_HARD_FLOAT"
2910   "")
2911
2912 (define_insn "truncdfsf2_ieee"
2913   [(set (match_operand:SF 0 "register_operand" "=f")
2914         (float_truncate:SF (match_operand:DF 1 "register_operand" "f")))]
2915   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2916   "ledbr\t%0,%1"
2917   [(set_attr "op_type"  "RRE")])
2918
2919 (define_insn "truncdfsf2_ibm"
2920   [(set (match_operand:SF 0 "register_operand" "=f,f")
2921         (float_truncate:SF (match_operand:DF 1 "nonimmediate_operand" "f,R")))]
2922   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2923   "@
2924    ler\t%0,%1
2925    le\t%0,%1"
2926   [(set_attr "op_type"  "RR,RX")
2927    (set_attr "type"   "floadsf")])
2928
2929 ;
2930 ; extendsfdf2 instruction pattern(s).
2931 ;
2932
2933 (define_expand "extendsfdf2"
2934   [(set (match_operand:DF 0 "register_operand" "")
2935         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "")))]
2936   "TARGET_HARD_FLOAT"
2937 {
2938   if (TARGET_IBM_FLOAT)
2939     {
2940       emit_insn (gen_extendsfdf2_ibm (operands[0], operands[1]));
2941       DONE;
2942     }
2943 })
2944
2945 (define_insn "extendsfdf2_ieee"
2946   [(set (match_operand:DF 0 "register_operand" "=f,f")
2947         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand"  "f,R")))]
2948   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
2949   "@
2950    ldebr\t%0,%1
2951    ldeb\t%0,%1"
2952   [(set_attr "op_type"  "RRE,RXE")
2953    (set_attr "type"   "floadsf")])
2954
2955 (define_insn "extendsfdf2_ibm"
2956   [(set (match_operand:DF 0 "register_operand" "=f,f")
2957         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "f,R")))
2958    (clobber (reg:CC CC_REGNUM))]
2959   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
2960   "@
2961    sdr\t%0,%0\;ler\t%0,%1
2962    sdr\t%0,%0\;le\t%0,%1"
2963   [(set_attr "length"   "4,6")
2964    (set_attr "type"     "floadsf")])
2965
2966
2967 ;;
2968 ;; ARITHMETIC OPERATIONS
2969 ;;
2970 ;  arithmetic operations set the ConditionCode,
2971 ;  because of unpredictable Bits in Register for Halfword and Byte
2972 ;  the ConditionCode can be set wrong in operations for Halfword and Byte
2973
2974 ;;
2975 ;;- Add instructions.
2976 ;;
2977
2978 ;
2979 ; addti3 instruction pattern(s).
2980 ;
2981
2982 (define_insn_and_split "addti3"
2983   [(set (match_operand:TI 0 "register_operand" "=&d")
2984         (plus:TI (match_operand:TI 1 "nonimmediate_operand" "%0")
2985                  (match_operand:TI 2 "general_operand" "do") ) )
2986    (clobber (reg:CC CC_REGNUM))]
2987   "TARGET_64BIT"
2988   "#"
2989   "&& reload_completed"
2990   [(parallel
2991     [(set (reg:CCL1 CC_REGNUM)
2992           (compare:CCL1 (plus:DI (match_dup 7) (match_dup 8))
2993                         (match_dup 7)))
2994      (set (match_dup 6) (plus:DI (match_dup 7) (match_dup 8)))])
2995    (parallel
2996     [(set (match_dup 3) (plus:DI (plus:DI (match_dup 4) (match_dup 5))
2997                                  (ltu:DI (reg:CCL1 CC_REGNUM) (const_int 0))))
2998      (clobber (reg:CC CC_REGNUM))])]
2999   "operands[3] = operand_subword (operands[0], 0, 0, TImode);
3000    operands[4] = operand_subword (operands[1], 0, 0, TImode);
3001    operands[5] = operand_subword (operands[2], 0, 0, TImode);
3002    operands[6] = operand_subword (operands[0], 1, 0, TImode);
3003    operands[7] = operand_subword (operands[1], 1, 0, TImode);
3004    operands[8] = operand_subword (operands[2], 1, 0, TImode);")
3005
3006 ;
3007 ; adddi3 instruction pattern(s).
3008 ;
3009
3010 (define_insn "*adddi3_sign"
3011   [(set (match_operand:DI 0 "register_operand" "=d,d")
3012         (plus:DI (sign_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3013                  (match_operand:DI 1 "register_operand" "0,0")))
3014    (clobber (reg:CC CC_REGNUM))]
3015   "TARGET_64BIT"
3016   "@
3017    agfr\t%0,%2
3018    agf\t%0,%2"
3019   [(set_attr "op_type"  "RRE,RXY")])
3020
3021 (define_insn "*adddi3_zero_cc"
3022   [(set (reg CC_REGNUM)
3023         (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3024                           (match_operand:DI 1 "register_operand" "0,0"))
3025                  (const_int 0)))
3026    (set (match_operand:DI 0 "register_operand" "=d,d")
3027         (plus:DI (zero_extend:DI (match_dup 2)) (match_dup 1)))]
3028   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3029   "@
3030    algfr\t%0,%2
3031    algf\t%0,%2"
3032   [(set_attr "op_type"  "RRE,RXY")])
3033
3034 (define_insn "*adddi3_zero_cconly"
3035   [(set (reg CC_REGNUM)
3036         (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3037                           (match_operand:DI 1 "register_operand" "0,0"))
3038                  (const_int 0)))
3039    (clobber (match_scratch:DI 0 "=d,d"))]
3040   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3041   "@
3042    algfr\t%0,%2
3043    algf\t%0,%2"
3044   [(set_attr "op_type"  "RRE,RXY")])
3045
3046 (define_insn "*adddi3_zero"
3047   [(set (match_operand:DI 0 "register_operand" "=d,d")
3048         (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))
3049                  (match_operand:DI 1 "register_operand" "0,0")))
3050    (clobber (reg:CC CC_REGNUM))]
3051   "TARGET_64BIT"
3052   "@
3053    algfr\t%0,%2
3054    algf\t%0,%2"
3055   [(set_attr "op_type"  "RRE,RXY")])
3056
3057 (define_insn "*adddi3_imm_cc"
3058   [(set (reg CC_REGNUM)
3059         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "0")
3060                           (match_operand:DI 2 "const_int_operand" "K"))
3061                  (const_int 0)))
3062    (set (match_operand:DI 0 "register_operand" "=d")
3063         (plus:DI (match_dup 1) (match_dup 2)))]
3064   "TARGET_64BIT
3065    && s390_match_ccmode (insn, CCAmode)
3066    && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'K', \"K\")"
3067   "aghi\t%0,%h2"
3068   [(set_attr "op_type"  "RI")])
3069
3070 (define_insn "*adddi3_carry1_cc"
3071   [(set (reg CC_REGNUM)
3072         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3073                           (match_operand:DI 2 "general_operand" "d,m"))
3074                  (match_dup 1)))
3075    (set (match_operand:DI 0 "register_operand" "=d,d")
3076         (plus:DI (match_dup 1) (match_dup 2)))]
3077   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3078   "@
3079    algr\t%0,%2
3080    alg\t%0,%2"
3081   [(set_attr "op_type"  "RRE,RXY")])
3082
3083 (define_insn "*adddi3_carry1_cconly"
3084   [(set (reg CC_REGNUM)
3085         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3086                           (match_operand:DI 2 "general_operand" "d,m"))
3087                  (match_dup 1)))
3088    (clobber (match_scratch:DI 0 "=d,d"))]
3089   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3090   "@
3091    algr\t%0,%2
3092    alg\t%0,%2"
3093   [(set_attr "op_type"  "RRE,RXY")])
3094
3095 (define_insn "*adddi3_carry2_cc"
3096   [(set (reg CC_REGNUM)
3097         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3098                           (match_operand:DI 2 "general_operand" "d,m"))
3099                  (match_dup 2)))
3100    (set (match_operand:DI 0 "register_operand" "=d,d")
3101         (plus:DI (match_dup 1) (match_dup 2)))]
3102   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3103   "@
3104    algr\t%0,%2
3105    alg\t%0,%2"
3106   [(set_attr "op_type"  "RRE,RXY")])
3107
3108 (define_insn "*adddi3_carry2_cconly"
3109   [(set (reg CC_REGNUM)
3110         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3111                           (match_operand:DI 2 "general_operand" "d,m"))
3112                  (match_dup 2)))
3113    (clobber (match_scratch:DI 0 "=d,d"))]
3114   "s390_match_ccmode (insn, CCL1mode) && TARGET_64BIT"
3115   "@
3116    algr\t%0,%2
3117    alg\t%0,%2"
3118   [(set_attr "op_type"  "RRE,RXY")])
3119
3120 (define_insn "*adddi3_cc"
3121   [(set (reg CC_REGNUM)
3122         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3123                           (match_operand:DI 2 "general_operand" "d,m"))
3124                  (const_int 0)))
3125    (set (match_operand:DI 0 "register_operand" "=d,d")
3126         (plus:DI (match_dup 1) (match_dup 2)))]
3127   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3128   "@
3129    algr\t%0,%2
3130    alg\t%0,%2"
3131   [(set_attr "op_type"  "RRE,RXY")])
3132
3133 (define_insn "*adddi3_cconly"
3134   [(set (reg CC_REGNUM)
3135         (compare (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3136                           (match_operand:DI 2 "general_operand" "d,m"))
3137                  (const_int 0)))
3138    (clobber (match_scratch:DI 0 "=d,d"))]
3139   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3140   "@
3141    algr\t%0,%2
3142    alg\t%0,%2"
3143   [(set_attr "op_type"  "RRE,RXY")])
3144
3145 (define_insn "*adddi3_cconly2"
3146   [(set (reg CC_REGNUM)
3147         (compare (match_operand:DI 1 "nonimmediate_operand" "%0,0")
3148                  (neg:SI (match_operand:DI 2 "general_operand" "d,m"))))
3149    (clobber (match_scratch:DI 0 "=d,d"))]
3150   "s390_match_ccmode(insn, CCLmode) && TARGET_64BIT"
3151   "@
3152    algr\t%0,%2
3153    alg\t%0,%2"
3154   [(set_attr "op_type"  "RRE,RXY")])
3155
3156 (define_insn "*adddi3_64"
3157   [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3158         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0")
3159                  (match_operand:DI 2 "general_operand" "d,K,m") ) )
3160    (clobber (reg:CC CC_REGNUM))]
3161   "TARGET_64BIT"
3162   "@
3163    agr\t%0,%2
3164    aghi\t%0,%h2
3165    ag\t%0,%2"
3166   [(set_attr "op_type"  "RRE,RI,RXY")])
3167
3168 (define_insn_and_split "*adddi3_31z"
3169   [(set (match_operand:DI 0 "register_operand" "=&d")
3170         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
3171                  (match_operand:DI 2 "general_operand" "do") ) )
3172    (clobber (reg:CC CC_REGNUM))]
3173   "!TARGET_64BIT && TARGET_CPU_ZARCH"
3174   "#"
3175   "&& reload_completed"
3176   [(parallel
3177     [(set (reg:CCL1 CC_REGNUM)
3178           (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
3179                         (match_dup 7)))
3180      (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
3181    (parallel
3182     [(set (match_dup 3) (plus:SI (plus:SI (match_dup 4) (match_dup 5))
3183                                  (ltu:SI (reg:CCL1 CC_REGNUM) (const_int 0))))
3184      (clobber (reg:CC CC_REGNUM))])]
3185   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3186    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3187    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3188    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3189    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3190    operands[8] = operand_subword (operands[2], 1, 0, DImode);")
3191
3192 (define_insn_and_split "*adddi3_31"
3193   [(set (match_operand:DI 0 "register_operand" "=&d")
3194         (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
3195                  (match_operand:DI 2 "general_operand" "do") ) )
3196    (clobber (reg:CC CC_REGNUM))]
3197   "!TARGET_CPU_ZARCH"
3198   "#"
3199   "&& reload_completed"
3200   [(parallel
3201     [(set (match_dup 3) (plus:SI (match_dup 4) (match_dup 5)))
3202      (clobber (reg:CC CC_REGNUM))])
3203    (parallel
3204     [(set (reg:CCL1 CC_REGNUM)
3205           (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
3206                         (match_dup 7)))
3207      (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
3208    (set (pc)
3209         (if_then_else (ltu (reg:CCL1 CC_REGNUM) (const_int 0))
3210                       (pc)
3211                       (label_ref (match_dup 9))))
3212    (parallel
3213     [(set (match_dup 3) (plus:SI (match_dup 3) (const_int 1)))
3214      (clobber (reg:CC CC_REGNUM))])
3215    (match_dup 9)]
3216   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3217    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3218    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3219    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3220    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3221    operands[8] = operand_subword (operands[2], 1, 0, DImode);
3222    operands[9] = gen_label_rtx ();")
3223
3224 (define_expand "adddi3"
3225   [(parallel
3226     [(set (match_operand:DI 0 "register_operand" "")
3227           (plus:DI (match_operand:DI 1 "nonimmediate_operand" "")
3228                    (match_operand:DI 2 "general_operand" "")))
3229      (clobber (reg:CC CC_REGNUM))])]
3230   ""
3231   "")
3232
3233 ;
3234 ; addsi3 instruction pattern(s).
3235 ;
3236
3237 (define_insn "*addsi3_imm_cc"
3238   [(set (reg CC_REGNUM)
3239         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "0")
3240                           (match_operand:SI 2 "const_int_operand" "K"))
3241                  (const_int 0)))
3242    (set (match_operand:SI 0 "register_operand" "=d")
3243         (plus:SI (match_dup 1) (match_dup 2)))]
3244   "s390_match_ccmode (insn, CCAmode)
3245    && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'K', \"K\")"
3246   "ahi\t%0,%h2"
3247   [(set_attr "op_type"  "RI")])
3248
3249 (define_insn "*addsi3_carry1_cc"
3250   [(set (reg CC_REGNUM)
3251         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3252                           (match_operand:SI 2 "general_operand" "d,R,T"))
3253                  (match_dup 1)))
3254    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3255         (plus:SI (match_dup 1) (match_dup 2)))]
3256   "s390_match_ccmode (insn, CCL1mode)"
3257   "@
3258    alr\t%0,%2
3259    al\t%0,%2
3260    aly\t%0,%2"
3261   [(set_attr "op_type"  "RR,RX,RXY")])
3262
3263 (define_insn "*addsi3_carry1_cconly"
3264   [(set (reg CC_REGNUM)
3265         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3266                           (match_operand:SI 2 "general_operand" "d,R,T"))
3267                  (match_dup 1)))
3268    (clobber (match_scratch:SI 0 "=d,d,d"))]
3269   "s390_match_ccmode (insn, CCL1mode)"
3270   "@
3271    alr\t%0,%2
3272    al\t%0,%2
3273    aly\t%0,%2"
3274   [(set_attr "op_type"  "RR,RX,RXY")])
3275
3276 (define_insn "*addsi3_carry2_cc"
3277   [(set (reg CC_REGNUM)
3278         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3279                           (match_operand:SI 2 "general_operand" "d,R,T"))
3280                  (match_dup 2)))
3281    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3282         (plus:SI (match_dup 1) (match_dup 2)))]
3283   "s390_match_ccmode (insn, CCL1mode)"
3284   "@
3285    alr\t%0,%2
3286    al\t%0,%2
3287    aly\t%0,%2"
3288   [(set_attr "op_type"  "RR,RX,RXY")])
3289
3290 (define_insn "*addsi3_carry2_cconly"
3291   [(set (reg CC_REGNUM)
3292         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3293                           (match_operand:SI 2 "general_operand" "d,R,T"))
3294                  (match_dup 2)))
3295    (clobber (match_scratch:SI 0 "=d,d,d"))]
3296   "s390_match_ccmode (insn, CCL1mode)"
3297   "@
3298    alr\t%0,%2
3299    al\t%0,%2
3300    aly\t%0,%2"
3301   [(set_attr "op_type"  "RR,RX,RXY")])
3302
3303 (define_insn "*addsi3_cc"
3304   [(set (reg CC_REGNUM)
3305         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3306                           (match_operand:SI 2 "general_operand" "d,R,T"))
3307                  (const_int 0)))
3308    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3309         (plus:SI (match_dup 1) (match_dup 2)))]
3310   "s390_match_ccmode (insn, CCLmode)"
3311   "@
3312    alr\t%0,%2
3313    al\t%0,%2
3314    aly\t%0,%2"
3315   [(set_attr "op_type"  "RR,RX,RXY")])
3316
3317 (define_insn "*addsi3_cconly"
3318   [(set (reg CC_REGNUM)
3319         (compare (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3320                           (match_operand:SI 2 "general_operand" "d,R,T"))
3321                  (const_int 0)))
3322    (clobber (match_scratch:SI 0 "=d,d,d"))]
3323   "s390_match_ccmode (insn, CCLmode)"
3324   "@
3325    alr\t%0,%2
3326    al\t%0,%2
3327    aly\t%0,%2"
3328   [(set_attr "op_type"  "RR,RX,RXY")])
3329
3330 (define_insn "*addsi3_cconly2"
3331   [(set (reg CC_REGNUM)
3332         (compare (match_operand:SI 1 "nonimmediate_operand" "%0,0,0")
3333                  (neg:SI (match_operand:SI 2 "general_operand" "d,R,T"))))
3334    (clobber (match_scratch:SI 0 "=d,d,d"))]
3335   "s390_match_ccmode (insn, CCLmode)"
3336   "@
3337    alr\t%0,%2
3338    al\t%0,%2
3339    aly\t%0,%2"
3340   [(set_attr "op_type"  "RR,RX,RXY")])
3341
3342 (define_insn "*addsi3_sign"
3343   [(set (match_operand:SI 0 "register_operand" "=d,d")
3344         (plus:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))
3345                  (match_operand:SI 1 "register_operand" "0,0")))
3346    (clobber (reg:CC CC_REGNUM))]
3347   ""
3348   "@
3349    ah\t%0,%2
3350    ahy\t%0,%2"
3351   [(set_attr "op_type"  "RX,RXY")])
3352
3353 (define_insn "addsi3"
3354   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
3355         (plus:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
3356                  (match_operand:SI 2 "general_operand" "d,K,R,T")))
3357    (clobber (reg:CC CC_REGNUM))]
3358   ""
3359   "@
3360    ar\t%0,%2
3361    ahi\t%0,%h2
3362    a\t%0,%2
3363    ay\t%0,%2"
3364   [(set_attr "op_type"  "RR,RI,RX,RXY")])
3365
3366 ;
3367 ; add(df|sf)3 instruction pattern(s).
3368 ;
3369
3370 (define_expand "add<mode>3"
3371   [(parallel
3372     [(set (match_operand:FPR 0 "register_operand" "=f,f")
3373           (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3374                     (match_operand:FPR 2 "general_operand" "f,R")))
3375      (clobber (reg:CC CC_REGNUM))])]
3376   "TARGET_HARD_FLOAT"
3377   "")
3378
3379 (define_insn "*add<mode>3"
3380   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3381         (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3382                   (match_operand:FPR 2 "general_operand" "f,R")))
3383    (clobber (reg:CC CC_REGNUM))]
3384   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3385   "@
3386    a<de>br\t%0,%2
3387    a<de>b\t%0,%2"
3388   [(set_attr "op_type"  "RRE,RXE")
3389    (set_attr "type"     "fsimp<mode>")])
3390
3391 (define_insn "*add<mode>3_cc"
3392   [(set (reg CC_REGNUM)
3393         (compare (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3394                            (match_operand:FPR 2 "general_operand" "f,R"))
3395                  (match_operand:FPR 3 "const0_operand" "")))
3396    (set (match_operand:FPR 0 "register_operand" "=f,f")
3397         (plus:FPR (match_dup 1) (match_dup 2)))]
3398   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3399   "@
3400    a<de>br\t%0,%2
3401    a<de>b\t%0,%2"
3402   [(set_attr "op_type"  "RRE,RXE")
3403    (set_attr "type"     "fsimp<mode>")])
3404
3405 (define_insn "*add<mode>3_cconly"
3406   [(set (reg CC_REGNUM)
3407         (compare (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3408                            (match_operand:FPR 2 "general_operand" "f,R"))
3409                  (match_operand:FPR 3 "const0_operand" "")))
3410    (clobber (match_scratch:FPR 0 "=f,f"))]
3411   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3412   "@
3413    a<de>br\t%0,%2
3414    a<de>b\t%0,%2"
3415   [(set_attr "op_type"  "RRE,RXE")
3416    (set_attr "type"     "fsimp<mode>")])
3417
3418 (define_insn "*add<mode>3_ibm"
3419   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3420         (plus:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
3421                   (match_operand:FPR 2 "general_operand" "f,R")))
3422    (clobber (reg:CC CC_REGNUM))]
3423   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3424   "@
3425    a<de>r\t%0,%2
3426    a<de>\t%0,%2"
3427   [(set_attr "op_type"  "RR,RX")
3428    (set_attr "type"     "fsimp<mode>")])
3429
3430
3431 ;;
3432 ;;- Subtract instructions.
3433 ;;
3434
3435 ;
3436 ; subti3 instruction pattern(s).
3437 ;
3438
3439 (define_insn_and_split "subti3"
3440   [(set (match_operand:TI 0 "register_operand" "=&d")
3441         (minus:TI (match_operand:TI 1 "register_operand" "0")
3442                   (match_operand:TI 2 "general_operand" "do") ) )
3443    (clobber (reg:CC CC_REGNUM))]
3444   "TARGET_64BIT"
3445   "#"
3446   "&& reload_completed"
3447   [(parallel
3448     [(set (reg:CCL2 CC_REGNUM)
3449           (compare:CCL2 (minus:DI (match_dup 7) (match_dup 8))
3450                         (match_dup 7)))
3451      (set (match_dup 6) (minus:DI (match_dup 7) (match_dup 8)))])
3452    (parallel
3453     [(set (match_dup 3) (minus:DI (minus:DI (match_dup 4) (match_dup 5))
3454                                   (gtu:DI (reg:CCL2 CC_REGNUM) (const_int 0))))
3455      (clobber (reg:CC CC_REGNUM))])]
3456   "operands[3] = operand_subword (operands[0], 0, 0, TImode);
3457    operands[4] = operand_subword (operands[1], 0, 0, TImode);
3458    operands[5] = operand_subword (operands[2], 0, 0, TImode);
3459    operands[6] = operand_subword (operands[0], 1, 0, TImode);
3460    operands[7] = operand_subword (operands[1], 1, 0, TImode);
3461    operands[8] = operand_subword (operands[2], 1, 0, TImode);")
3462
3463 ;
3464 ; subdi3 instruction pattern(s).
3465 ;
3466
3467 (define_insn "*subdi3_sign"
3468   [(set (match_operand:DI 0 "register_operand" "=d,d")
3469         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3470                   (sign_extend:DI (match_operand:SI 2 "general_operand" "d,m"))))
3471    (clobber (reg:CC CC_REGNUM))]
3472   "TARGET_64BIT"
3473   "@
3474    sgfr\t%0,%2
3475    sgf\t%0,%2"
3476   [(set_attr "op_type"  "RRE,RXY")])
3477
3478 (define_insn "*subdi3_zero_cc"
3479   [(set (reg CC_REGNUM)
3480         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3481                            (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m")))
3482                  (const_int 0)))
3483    (set (match_operand:DI 0 "register_operand" "=d,d")
3484         (minus:DI (match_dup 1) (zero_extend:DI (match_dup 2))))]
3485   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3486   "@
3487    slgfr\t%0,%2
3488    slgf\t%0,%2"
3489   [(set_attr "op_type"  "RRE,RXY")])
3490
3491 (define_insn "*subdi3_zero_cconly"
3492   [(set (reg CC_REGNUM)
3493         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3494                            (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m")))
3495                  (const_int 0)))
3496    (clobber (match_scratch:DI 0 "=d,d"))]
3497   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3498   "@
3499    slgfr\t%0,%2
3500    slgf\t%0,%2"
3501   [(set_attr "op_type"  "RRE,RXY")])
3502
3503 (define_insn "*subdi3_zero"
3504   [(set (match_operand:DI 0 "register_operand" "=d,d")
3505         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3506                   (zero_extend:DI (match_operand:SI 2 "general_operand" "d,m"))))
3507    (clobber (reg:CC CC_REGNUM))]
3508   "TARGET_64BIT"
3509   "@
3510    slgfr\t%0,%2
3511    slgf\t%0,%2"
3512   [(set_attr "op_type"  "RRE,RXY")])
3513
3514 (define_insn "*subdi3_borrow_cc"
3515   [(set (reg CC_REGNUM)
3516         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3517                            (match_operand:DI 2 "general_operand" "d,m"))
3518                  (match_dup 1)))
3519    (set (match_operand:DI 0 "register_operand" "=d,d")
3520         (minus:DI (match_dup 1) (match_dup 2)))]
3521   "s390_match_ccmode (insn, CCL2mode) && TARGET_64BIT"
3522   "@
3523    slgr\t%0,%2
3524    slg\t%0,%2"
3525   [(set_attr "op_type"  "RRE,RXY")])
3526
3527 (define_insn "*subdi3_borrow_cconly"
3528   [(set (reg CC_REGNUM)
3529         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3530                            (match_operand:DI 2 "general_operand" "d,m"))
3531                  (match_dup 1)))
3532    (clobber (match_scratch:DI 0 "=d,d"))]
3533   "s390_match_ccmode (insn, CCL2mode) && TARGET_64BIT"
3534   "@
3535    slgr\t%0,%2
3536    slg\t%0,%2"
3537   [(set_attr "op_type"  "RRE,RXY")])
3538
3539 (define_insn "*subdi3_cc"
3540   [(set (reg CC_REGNUM)
3541         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3542                            (match_operand:DI 2 "general_operand" "d,m"))
3543                  (const_int 0)))
3544    (set (match_operand:DI 0 "register_operand" "=d,d")
3545         (minus:DI (match_dup 1) (match_dup 2)))]
3546   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3547   "@
3548    slgr\t%0,%2
3549    slg\t%0,%2"
3550   [(set_attr "op_type"  "RRE,RXY")])
3551
3552 (define_insn "*subdi3_cc2"
3553   [(set (reg CC_REGNUM)
3554         (compare (match_operand:DI 1 "register_operand" "0,0")
3555                  (match_operand:DI 2 "general_operand" "d,m")))
3556    (set (match_operand:DI 0 "register_operand" "=d,d")
3557         (minus:DI (match_dup 1) (match_dup 2)))]
3558   "s390_match_ccmode (insn, CCL3mode) && TARGET_64BIT"
3559   "@
3560    slgr\t%0,%2
3561    slg\t%0,%2"
3562   [(set_attr "op_type"  "RRE,RXY")])
3563
3564 (define_insn "*subdi3_cconly"
3565   [(set (reg CC_REGNUM)
3566         (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3567                            (match_operand:DI 2 "general_operand" "d,m"))
3568                  (const_int 0)))
3569    (clobber (match_scratch:DI 0 "=d,d"))]
3570   "s390_match_ccmode (insn, CCLmode) && TARGET_64BIT"
3571   "@
3572    slgr\t%0,%2
3573    slg\t%0,%2"
3574   [(set_attr "op_type"  "RRE,RXY")])
3575
3576 (define_insn "*subdi3_cconly2"
3577   [(set (reg CC_REGNUM)
3578         (compare (match_operand:DI 1 "register_operand" "0,0")
3579                  (match_operand:DI 2 "general_operand" "d,m")))
3580    (clobber (match_scratch:DI 0 "=d,d"))]
3581   "s390_match_ccmode (insn, CCL3mode) && TARGET_64BIT"
3582   "@
3583    slgr\t%0,%2
3584    slg\t%0,%2"
3585   [(set_attr "op_type"  "RRE,RXY")])
3586
3587 (define_insn "*subdi3_64"
3588   [(set (match_operand:DI 0 "register_operand" "=d,d")
3589         (minus:DI (match_operand:DI 1 "register_operand" "0,0")
3590                   (match_operand:DI 2 "general_operand" "d,m") ) )
3591    (clobber (reg:CC CC_REGNUM))]
3592   "TARGET_64BIT"
3593   "@
3594    sgr\t%0,%2
3595    sg\t%0,%2"
3596   [(set_attr "op_type"  "RRE,RRE")])
3597
3598 (define_insn_and_split "*subdi3_31z"
3599   [(set (match_operand:DI 0 "register_operand" "=&d")
3600         (minus:DI (match_operand:DI 1 "register_operand" "0")
3601                   (match_operand:DI 2 "general_operand" "do") ) )
3602    (clobber (reg:CC CC_REGNUM))]
3603   "!TARGET_64BIT && TARGET_CPU_ZARCH"
3604   "#"
3605   "&& reload_completed"
3606   [(parallel
3607     [(set (reg:CCL2 CC_REGNUM)
3608           (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
3609                         (match_dup 7)))
3610      (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
3611    (parallel
3612     [(set (match_dup 3) (minus:SI (minus:SI (match_dup 4) (match_dup 5))
3613                                   (gtu:SI (reg:CCL2 CC_REGNUM) (const_int 0))))
3614      (clobber (reg:CC CC_REGNUM))])]
3615   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3616    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3617    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3618    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3619    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3620    operands[8] = operand_subword (operands[2], 1, 0, DImode);")
3621
3622 (define_insn_and_split "*subdi3_31"
3623   [(set (match_operand:DI 0 "register_operand" "=&d")
3624         (minus:DI (match_operand:DI 1 "register_operand" "0")
3625                   (match_operand:DI 2 "general_operand" "do") ) )
3626    (clobber (reg:CC CC_REGNUM))]
3627   "!TARGET_CPU_ZARCH"
3628   "#"
3629   "&& reload_completed"
3630   [(parallel
3631     [(set (match_dup 3) (minus:SI (match_dup 4) (match_dup 5)))
3632      (clobber (reg:CC CC_REGNUM))])
3633    (parallel
3634     [(set (reg:CCL2 CC_REGNUM)
3635           (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
3636                         (match_dup 7)))
3637      (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
3638    (set (pc)
3639         (if_then_else (gtu (reg:CCL2 CC_REGNUM) (const_int 0))
3640                       (pc)
3641                       (label_ref (match_dup 9))))
3642    (parallel
3643     [(set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))
3644      (clobber (reg:CC CC_REGNUM))])
3645    (match_dup 9)]
3646   "operands[3] = operand_subword (operands[0], 0, 0, DImode);
3647    operands[4] = operand_subword (operands[1], 0, 0, DImode);
3648    operands[5] = operand_subword (operands[2], 0, 0, DImode);
3649    operands[6] = operand_subword (operands[0], 1, 0, DImode);
3650    operands[7] = operand_subword (operands[1], 1, 0, DImode);
3651    operands[8] = operand_subword (operands[2], 1, 0, DImode);
3652    operands[9] = gen_label_rtx ();")
3653
3654 (define_expand "subdi3"
3655   [(parallel
3656     [(set (match_operand:DI 0 "register_operand" "")
3657           (minus:DI (match_operand:DI 1 "register_operand" "")
3658                     (match_operand:DI 2 "general_operand" "")))
3659      (clobber (reg:CC CC_REGNUM))])]
3660   ""
3661   "")
3662
3663 ;
3664 ; subsi3 instruction pattern(s).
3665 ;
3666
3667 (define_insn "*subsi3_borrow_cc"
3668   [(set (reg CC_REGNUM)
3669         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3670                            (match_operand:SI 2 "general_operand" "d,R,T"))
3671                  (match_dup 1)))
3672    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3673         (minus:SI (match_dup 1) (match_dup 2)))]
3674   "s390_match_ccmode (insn, CCL2mode)"
3675   "@
3676    slr\t%0,%2
3677    sl\t%0,%2
3678    sly\t%0,%2"
3679   [(set_attr "op_type"  "RR,RX,RXY")])
3680
3681 (define_insn "*subsi3_borrow_cconly"
3682   [(set (reg CC_REGNUM)
3683         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3684                            (match_operand:SI 2 "general_operand" "d,R,T"))
3685                  (match_dup 1)))
3686    (clobber (match_scratch:SI 0 "=d,d,d"))]
3687   "s390_match_ccmode (insn, CCL2mode)"
3688   "@
3689    slr\t%0,%2
3690    sl\t%0,%2
3691    sly\t%0,%2"
3692   [(set_attr "op_type"  "RR,RX,RXY")])
3693
3694 (define_insn "*subsi3_cc"
3695   [(set (reg CC_REGNUM)
3696         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3697                            (match_operand:SI 2 "general_operand" "d,R,T"))
3698                  (const_int 0)))
3699    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3700         (minus:SI (match_dup 1) (match_dup 2)))]
3701   "s390_match_ccmode (insn, CCLmode)"
3702   "@
3703    slr\t%0,%2
3704    sl\t%0,%2
3705    sly\t%0,%2"
3706   [(set_attr "op_type"  "RR,RX,RXY")])
3707
3708 (define_insn "*subsi3_cc2"
3709   [(set (reg CC_REGNUM)
3710         (compare (match_operand:SI 1 "register_operand" "0,0,0")
3711                  (match_operand:SI 2 "general_operand" "d,R,T")))
3712    (set (match_operand:SI 0 "register_operand" "=d,d,d")
3713         (minus:SI (match_dup 1) (match_dup 2)))]
3714   "s390_match_ccmode (insn, CCL3mode)"
3715   "@
3716    slr\t%0,%2
3717    sl\t%0,%2
3718    sly\t%0,%2"
3719   [(set_attr "op_type"  "RR,RX,RXY")])
3720
3721 (define_insn "*subsi3_cconly"
3722   [(set (reg CC_REGNUM)
3723         (compare (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3724                            (match_operand:SI 2 "general_operand" "d,R,T"))
3725                  (const_int 0)))
3726    (clobber (match_scratch:SI 0 "=d,d,d"))]
3727   "s390_match_ccmode (insn, CCLmode)"
3728   "@
3729    slr\t%0,%2
3730    sl\t%0,%2
3731    sly\t%0,%2"
3732   [(set_attr "op_type"  "RR,RX,RXY")])
3733
3734 (define_insn "*subsi3_cconly2"
3735   [(set (reg CC_REGNUM)
3736         (compare (match_operand:SI 1 "register_operand" "0,0,0")
3737                  (match_operand:SI 2 "general_operand" "d,R,T")))
3738    (clobber (match_scratch:SI 0 "=d,d,d"))]
3739   "s390_match_ccmode (insn, CCL3mode)"
3740   "@
3741    slr\t%0,%2
3742    sl\t%0,%2
3743    sly\t%0,%2"
3744   [(set_attr "op_type"  "RR,RX,RXY")])
3745
3746 (define_insn "*subsi3_sign"
3747   [(set (match_operand:SI 0 "register_operand" "=d,d")
3748         (minus:SI (match_operand:SI 1 "register_operand" "0,0")
3749                   (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))))
3750    (clobber (reg:CC CC_REGNUM))]
3751   ""
3752   "@
3753    sh\t%0,%2
3754    shy\t%0,%2"
3755   [(set_attr "op_type"  "RX,RXY")])
3756
3757 (define_insn "subsi3"
3758   [(set (match_operand:SI 0 "register_operand" "=d,d,d")
3759         (minus:SI (match_operand:SI 1 "register_operand" "0,0,0")
3760                   (match_operand:SI 2 "general_operand" "d,R,T")))
3761    (clobber (reg:CC CC_REGNUM))]
3762   ""
3763   "@
3764    sr\t%0,%2
3765    s\t%0,%2
3766    sy\t%0,%2"
3767   [(set_attr "op_type"  "RR,RX,RXY")])
3768
3769
3770 ;
3771 ; sub(df|sf)3 instruction pattern(s).
3772 ;
3773
3774 (define_expand "sub<mode>3"
3775   [(parallel
3776     [(set (match_operand:FPR 0 "register_operand" "=f,f")
3777           (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3778                      (match_operand:FPR 2 "general_operand" "f,R")))
3779      (clobber (reg:CC CC_REGNUM))])]
3780   "TARGET_HARD_FLOAT"
3781   "")
3782
3783 (define_insn "*sub<mode>3"
3784   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3785         (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3786                    (match_operand:FPR 2 "general_operand" "f,R")))
3787    (clobber (reg:CC CC_REGNUM))]
3788   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3789   "@
3790    s<de>br\t%0,%2
3791    s<de>b\t%0,%2"
3792   [(set_attr "op_type"  "RRE,RXE")
3793    (set_attr "type"     "fsimp<mode>")])
3794
3795 (define_insn "*sub<mode>3_cc"
3796   [(set (reg CC_REGNUM)
3797         (compare (minus:FPR (match_operand:FPR 1 "nonimmediate_operand" "0,0")
3798                             (match_operand:FPR 2 "general_operand" "f,R"))
3799                  (match_operand:FPR 3 "const0_operand" "")))
3800    (set (match_operand:FPR 0 "register_operand" "=f,f")
3801         (minus:FPR (match_dup 1) (match_dup 2)))]
3802   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3803   "@
3804    s<de>br\t%0,%2
3805    s<de>b\t%0,%2"
3806   [(set_attr "op_type"  "RRE,RXE")
3807    (set_attr "type"     "fsimp<mode>")])
3808
3809 (define_insn "*sub<mode>3_cconly"
3810   [(set (reg CC_REGNUM)
3811         (compare (minus:FPR (match_operand:FPR 1 "nonimmediate_operand" "0,0")
3812                             (match_operand:FPR 2 "general_operand" "f,R"))
3813                  (match_operand:FPR 3 "const0_operand" "")))
3814    (clobber (match_scratch:FPR 0 "=f,f"))]
3815   "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
3816   "@
3817    s<de>br\t%0,%2
3818    s<de>b\t%0,%2"
3819   [(set_attr "op_type"  "RRE,RXE")
3820    (set_attr "type"     "fsimp<mode>")])
3821
3822 (define_insn "*sub<mode>3_ibm"
3823   [(set (match_operand:FPR 0 "register_operand" "=f,f")
3824         (minus:FPR (match_operand:FPR 1 "register_operand" "0,0")
3825                    (match_operand:FPR 2 "general_operand" "f,R")))
3826    (clobber (reg:CC CC_REGNUM))]
3827   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
3828   "@
3829    s<de>r\t%0,%2
3830    s<de>\t%0,%2"
3831   [(set_attr "op_type"  "RR,RX")
3832    (set_attr "type"     "fsimp<mode>")])
3833
3834
3835 ;;
3836 ;;- Conditional add/subtract instructions.
3837 ;;
3838
3839 ;
3840 ; add(di|si)cc instruction pattern(s).
3841 ;
3842
3843 (define_insn "*add<mode>3_alc_cc"
3844   [(set (reg CC_REGNUM)
3845         (compare
3846           (plus:GPR (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,0")
3847                               (match_operand:GPR 2 "general_operand" "d,m"))
3848                     (match_operand:GPR 3 "s390_alc_comparison" ""))
3849           (const_int 0)))
3850    (set (match_operand:GPR 0 "register_operand" "=d,d")
3851         (plus:GPR (plus:GPR (match_dup 1) (match_dup 2)) (match_dup 3)))]
3852   "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
3853   "@
3854    alc<g>r\t%0,%2
3855    alc<g>\t%0,%2"
3856   [(set_attr "op_type"  "RRE,RXY")])
3857
3858 (define_insn "*add<mode>3_alc"
3859   [(set (match_operand:GPR 0 "register_operand" "=d,d")
3860         (plus:GPR (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,0")
3861                             (match_operand:GPR 2 "general_operand" "d,m"))
3862                   (match_operand:GPR 3 "s390_alc_comparison" "")))
3863    (clobber (reg:CC CC_REGNUM))]
3864   "TARGET_CPU_ZARCH"
3865   "@
3866    alc<g>r\t%0,%2
3867    alc<g>\t%0,%2"
3868   [(set_attr "op_type"  "RRE,RXY")])
3869
3870 (define_insn "*sub<mode>3_slb_cc"
3871   [(set (reg CC_REGNUM)
3872         (compare
3873           (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
3874                                 (match_operand:GPR 2 "general_operand" "d,m"))
3875                      (match_operand:GPR 3 "s390_slb_comparison" ""))
3876           (const_int 0)))
3877    (set (match_operand:GPR 0 "register_operand" "=d,d")
3878         (minus:GPR (minus:GPR (match_dup 1) (match_dup 2)) (match_dup 3)))]
3879   "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
3880   "@
3881    slb<g>r\t%0,%2
3882    slb<g>\t%0,%2"
3883   [(set_attr "op_type"  "RRE,RXY")])
3884
3885 (define_insn "*sub<mode>3_slb"
3886   [(set (match_operand:GPR 0 "register_operand" "=d,d")
3887         (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
3888                               (match_operand:GPR 2 "general_operand" "d,m"))
3889                    (match_operand:GPR 3 "s390_slb_comparison" "")))
3890    (clobber (reg:CC CC_REGNUM))]
3891   "TARGET_CPU_ZARCH"
3892   "@
3893    slb<g>r\t%0,%2
3894    slb<g>\t%0,%2"
3895   [(set_attr "op_type"  "RRE,RXY")])
3896
3897 (define_expand "add<mode>cc"
3898   [(match_operand:GPR 0 "register_operand" "")
3899    (match_operand 1 "comparison_operator" "")
3900    (match_operand:GPR 2 "register_operand" "")
3901    (match_operand:GPR 3 "const_int_operand" "")]
3902   "TARGET_CPU_ZARCH"
3903   "if (!s390_expand_addcc (GET_CODE (operands[1]), 
3904                            s390_compare_op0, s390_compare_op1, 
3905                            operands[0], operands[2], 
3906                            operands[3])) FAIL; DONE;")
3907
3908 ;
3909 ; scond instruction pattern(s).
3910 ;
3911
3912 (define_insn_and_split "*scond<mode>"
3913   [(set (match_operand:GPR 0 "register_operand" "=&d")
3914         (match_operand:GPR 1 "s390_alc_comparison" ""))
3915    (clobber (reg:CC CC_REGNUM))]
3916   "TARGET_CPU_ZARCH"
3917   "#"
3918   "&& reload_completed"
3919   [(set (match_dup 0) (const_int 0))
3920    (parallel
3921     [(set (match_dup 0) (plus:GPR (plus:GPR (match_dup 0) (match_dup 0))
3922                                   (match_dup 1)))
3923      (clobber (reg:CC CC_REGNUM))])]
3924   "")
3925
3926 (define_insn_and_split "*scond<mode>_neg"
3927   [(set (match_operand:GPR 0 "register_operand" "=&d")
3928         (match_operand:GPR 1 "s390_slb_comparison" ""))
3929    (clobber (reg:CC CC_REGNUM))]
3930   "TARGET_CPU_ZARCH"
3931   "#"
3932   "&& reload_completed"
3933   [(set (match_dup 0) (const_int 0))
3934    (parallel
3935     [(set (match_dup 0) (minus:GPR (minus:GPR (match_dup 0) (match_dup 0))
3936                                    (match_dup 1)))
3937      (clobber (reg:CC CC_REGNUM))])
3938    (parallel
3939     [(set (match_dup 0) (neg:GPR (match_dup 0)))
3940      (clobber (reg:CC CC_REGNUM))])]
3941   "")
3942
3943
3944 (define_expand "s<code>"
3945   [(set (match_operand:SI 0 "register_operand" "")
3946         (SCOND (match_dup 0)
3947                (match_dup 0)))]
3948   "TARGET_CPU_ZARCH"
3949   "if (!s390_expand_addcc (<CODE>, s390_compare_op0, s390_compare_op1,
3950                            operands[0], const0_rtx, const1_rtx)) FAIL; DONE;")
3951
3952
3953 ;;
3954 ;;- Multiply instructions.
3955 ;;
3956
3957 ;
3958 ; muldi3 instruction pattern(s).
3959 ;
3960
3961 (define_insn "*muldi3_sign"
3962   [(set (match_operand:DI 0 "register_operand" "=d,d")
3963         (mult:DI (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "d,m"))
3964                  (match_operand:DI 1 "register_operand" "0,0")))]
3965   "TARGET_64BIT"
3966   "@
3967    msgfr\t%0,%2
3968    msgf\t%0,%2"
3969   [(set_attr "op_type"  "RRE,RXY")
3970    (set_attr "type"     "imuldi")])
3971
3972 (define_insn "muldi3"
3973   [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3974         (mult:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0")
3975                  (match_operand:DI 2 "general_operand" "d,K,m")))]
3976   "TARGET_64BIT"
3977   "@
3978    msgr\t%0,%2
3979    mghi\t%0,%h2
3980    msg\t%0,%2"
3981   [(set_attr "op_type"  "RRE,RI,RXY")
3982    (set_attr "type"     "imuldi")])
3983
3984 ;
3985 ; mulsi3 instruction pattern(s).
3986 ;
3987
3988 (define_insn "*mulsi3_sign"
3989   [(set (match_operand:SI 0 "register_operand" "=d")
3990         (mult:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R"))
3991                  (match_operand:SI 1 "register_operand" "0")))]
3992   ""
3993   "mh\t%0,%2"
3994   [(set_attr "op_type"  "RX")
3995    (set_attr "type"     "imulhi")])
3996
3997 (define_insn "mulsi3"
3998   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
3999         (mult:SI  (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
4000                   (match_operand:SI 2 "general_operand" "d,K,R,T")))]
4001   ""
4002   "@
4003    msr\t%0,%2
4004    mhi\t%0,%h2
4005    ms\t%0,%2
4006    msy\t%0,%2"
4007   [(set_attr "op_type"  "RRE,RI,RX,RXY")
4008    (set_attr "type"     "imulsi,imulhi,imulsi,imulsi")])
4009
4010 ;
4011 ; mulsidi3 instruction pattern(s).
4012 ;
4013
4014 (define_insn "mulsidi3"
4015   [(set (match_operand:DI 0 "register_operand" "=d,d")
4016         (mult:DI (sign_extend:DI
4017                    (match_operand:SI 1 "register_operand" "%0,0"))
4018                  (sign_extend:DI
4019                    (match_operand:SI 2 "nonimmediate_operand" "d,R"))))]
4020   "!TARGET_64BIT"
4021   "@
4022    mr\t%0,%2
4023    m\t%0,%2"
4024   [(set_attr "op_type"  "RR,RX")
4025    (set_attr "type"     "imulsi")])
4026
4027 ;
4028 ; umulsidi3 instruction pattern(s).
4029 ;
4030
4031 (define_insn "umulsidi3"
4032   [(set (match_operand:DI 0 "register_operand" "=d,d")
4033         (mult:DI (zero_extend:DI
4034                    (match_operand:SI 1 "register_operand" "%0,0"))
4035                  (zero_extend:DI
4036                    (match_operand:SI 2 "nonimmediate_operand" "d,m"))))]
4037   "!TARGET_64BIT && TARGET_CPU_ZARCH"
4038   "@
4039    mlr\t%0,%2
4040    ml\t%0,%2"
4041   [(set_attr "op_type"  "RRE,RXY")
4042    (set_attr "type"     "imulsi")])
4043
4044 ;
4045 ; mul(df|sf)3 instruction pattern(s).
4046 ;
4047
4048 (define_expand "mul<mode>3"
4049   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4050         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4051                   (match_operand:FPR 2 "general_operand" "f,R")))]
4052   "TARGET_HARD_FLOAT"
4053   "")
4054
4055 (define_insn "*mul<mode>3"
4056   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4057         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4058                   (match_operand:FPR 2 "general_operand" "f,R")))]
4059   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT"
4060   "@
4061    m<dee>br\t%0,%2
4062    m<dee>b\t%0,%2"
4063   [(set_attr "op_type"  "RRE,RXE")
4064    (set_attr "type"     "fmul<mode>")])
4065
4066 (define_insn "*mul<mode>3_ibm"
4067   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4068         (mult:FPR (match_operand:FPR 1 "nonimmediate_operand" "%0,0")
4069                   (match_operand:FPR 2 "general_operand" "f,R")))]
4070   "TARGET_HARD_FLOAT && TARGET_IBM_FLOAT"
4071   "@
4072    m<de>r\t%0,%2
4073    m<de>\t%0,%2"
4074   [(set_attr "op_type"  "RR,RX")
4075    (set_attr "type"     "fmul<mode>")])
4076
4077 (define_insn "*fmadd<mode>"
4078   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4079         (plus:FPR (mult:FPR (match_operand:FPR 1 "register_operand" "%f,f")
4080                            (match_operand:FPR 2 "nonimmediate_operand"  "f,R"))
4081                  (match_operand:FPR 3 "register_operand" "0,0")))]
4082   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT && TARGET_FUSED_MADD"
4083   "@
4084    ma<de>br\t%0,%1,%2
4085    ma<de>b\t%0,%1,%2"
4086   [(set_attr "op_type"  "RRE,RXE")
4087    (set_attr "type"     "fmul<mode>")])
4088
4089 (define_insn "*fmsub<mode>"
4090   [(set (match_operand:FPR 0 "register_operand" "=f,f")
4091         (minus:FPR (mult:FPR (match_operand:FPR 1 "register_operand" "f,f")
4092                             (match_operand:FPR 2 "nonimmediate_operand"  "f,R"))
4093                  (match_operand:FPR 3 "register_operand" "0,0")))]
4094   "TARGET_HARD_FLOAT && TARGET_IEEE_FLOAT && TARGET_FUSED_MADD"
4095   "@
4096    ms<de>br\t%0,%1,%2
4097    ms<de>b\t%0,%1,%2"
4098   [(set_attr "op_type"  "RRE,RXE")
4099    (set_attr "type"     "fmul<mode>")])
4100
4101 ;;
4102 ;;- Divide and modulo instructions.
4103 ;;
4104
4105 ;
4106 ; divmoddi4 instruction pattern(s).
4107 ;
4108
4109 (define_expand "divmoddi4"
4110   [(parallel [(set (match_operand:DI 0 "general_operand" "")
4111                    (div:DI (match_operand:DI 1 "register_operand" "")
4112                            (match_operand:DI 2 "general_operand" "")))
4113               (set (match_operand:DI 3 "general_operand" "")
4114                    (mod:DI (match_dup 1) (match_dup 2)))])
4115    (clobber (match_dup 4))]
4116   "TARGET_64BIT"
4117 {
4118   rtx insn, div_equal, mod_equal;
4119
4120   div_equal = gen_rtx_DIV (DImode, operands[1], operands[2]);
4121   mod_equal = gen_rtx_MOD (DImode, operands[1], operands[2]);
4122
4123   operands[4] = gen_reg_rtx(TImode);
4124   emit_insn (gen_divmodtidi3 (operands[4], operands[1], operands[2]));
4125
4126   insn = emit_move_insn (operands[0], gen_lowpart (DImode, operands[4]));
4127   REG_NOTES (insn) =
4128         gen_rtx_EXPR_LIST (REG_EQUAL, div_equal, REG_NOTES (insn));
4129
4130   insn = emit_move_insn (operands[3], gen_highpart (DImode, operands[4]));