1 ;;- Machine description for GNU compiler -- S/390 / zSeries version.
2 ;; Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 ;; Contributed by Hartmut Penner (hpenner@de.ibm.com) and
4 ;; Ulrich Weigand (uweigand@de.ibm.com) and
5 ;; Andreas Krebbel (Andreas.Krebbel@de.ibm.com)
7 ;; This file is part of GCC.
9 ;; GCC is free software; you can redistribute it and/or modify it under
10 ;; the terms of the GNU General Public License as published by the Free
11 ;; Software Foundation; either version 3, or (at your option) any later
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
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GCC; see the file COPYING3. If not see
21 ;; <http://www.gnu.org/licenses/>.
24 ;; See constraints.md for a description of constraints specific to s390.
27 ;; Special formats used for outputting 390 instructions.
29 ;; %C: print opcode suffix for branch condition.
30 ;; %D: print opcode suffix for inverse branch condition.
31 ;; %J: print tls_load/tls_gdcall/tls_ldcall suffix
32 ;; %G: print the size of the operand in bytes.
33 ;; %O: print only the displacement of a memory reference.
34 ;; %R: print only the base register of a memory reference.
35 ;; %S: print S-type memory reference (base+displacement).
36 ;; %N: print the second word of a DImode operand.
37 ;; %M: print the second word of a TImode operand.
38 ;; %Y: print shift count operand.
40 ;; %b: print integer X as if it's an unsigned byte.
41 ;; %c: print integer X as if it's an signed byte.
42 ;; %x: print integer X as if it's an unsigned halfword.
43 ;; %h: print integer X as if it's a signed halfword.
44 ;; %i: print the first nonzero HImode part of X.
45 ;; %j: print the first HImode part unequal to -1 of X.
46 ;; %k: print the first nonzero SImode part of X.
47 ;; %m: print the first SImode part unequal to -1 of X.
48 ;; %o: print integer X as if it's an unsigned 32bit word.
50 ;; We have a special constraint for pattern matching.
52 ;; s_operand -- Matches a valid S operand in a RS, SI or SS type instruction.
59 (define_c_enum "unspec" [
65 ; Convert CC into a str comparison result and copy it into an
67 ; cc0->0, cc1->1, cc2->-1, (cc3->-1)
68 UNSPEC_STRCMPCC_TO_INT
70 ; Copy CC as is into the lower 2 bits of an integer register
73 ; GOT/PLT and lt-relative accesses
94 ; TLS relocation specifiers
110 ; Stack Smashing Protector
114 ; Test Data Class (TDC)
126 UNSPEC_FPINT_NEARBYINT
131 ;; UNSPEC_VOLATILE usage
134 (define_c_enum "unspecv" [
156 ; Transactional Execution support
171 ; Registers with special meaning
175 ; Sibling call register.
177 ; Literal pool base register.
179 ; Return address register.
181 ; Condition code register.
183 ; Thread local storage pointer register.
187 ; Hardware register names
191 ; General purpose registers
193 ; Floating point registers.
213 ;; PFPO GPR0 argument format
218 ; PFPO operation type
219 (PFPO_CONVERT 0x1000000)
221 (PFPO_OP_TYPE_SF 0x5)
222 (PFPO_OP_TYPE_DF 0x6)
223 (PFPO_OP_TYPE_TF 0x7)
224 (PFPO_OP_TYPE_SD 0x8)
225 (PFPO_OP_TYPE_DD 0x9)
226 (PFPO_OP_TYPE_TD 0xa)
227 ; Bitposition of operand types
228 (PFPO_OP0_TYPE_SHIFT 16)
229 (PFPO_OP1_TYPE_SHIFT 8)
232 ; Immediate operands for tbegin and tbeginc
233 (define_constants [(TBEGIN_MASK 65292)]) ; 0xff0c
234 (define_constants [(TBEGINC_MASK 65288)]) ; 0xff08
236 ;; Instruction operand type as used in the Principles of Operation.
237 ;; Used to determine defaults for length and other attribute values.
239 (define_attr "op_type"
240 "NN,E,RR,RRE,RX,RS,RSI,RI,SI,S,SS,SSE,RXE,RSE,RIL,RIE,RXY,RSY,SIY,RRF,RRR,SIL,RRS,RIS"
243 ;; Instruction type attribute used for scheduling.
245 (define_attr "type" "none,integer,load,lr,la,larl,lm,stm,
246 cs,vs,store,sem,idiv,
247 imulhi,imulsi,imuldi,
248 branch,jsr,fsimptf,fsimpdf,fsimpsf,fhex,
249 floadtf,floaddf,floadsf,fstoredf,fstoresf,
250 fmultf,fmuldf,fmulsf,fdivtf,fdivdf,fdivsf,
251 ftoi,fsqrttf,fsqrtdf,fsqrtsf,
253 ftrunctf,ftruncdf, ftruncsd, ftruncdd,
254 itoftf, itofdf, itofsf, itofdd, itoftd,
255 fdivdd, fdivtd, floaddd, floadsd, fmuldd, fmultd,
256 fsimpdd, fsimpsd, fsimptd, fstoredd, fstoresd,
258 (cond [(eq_attr "op_type" "NN") (const_string "other")
259 (eq_attr "op_type" "SS") (const_string "cs")]
260 (const_string "integer")))
262 ;; Another attribute used for scheduling purposes:
263 ;; agen: Instruction uses the address generation unit
264 ;; reg: Instruction does not use the agen unit
266 (define_attr "atype" "agen,reg"
267 (if_then_else (eq_attr "op_type" "E,RR,RI,RRE,RSI,RIL,RIE,RRF,RRR")
269 (const_string "agen")))
271 ;; Properties concerning Z10 execution grouping and value forwarding.
272 ;; z10_super: instruction is superscalar.
273 ;; z10_super_c: instruction is superscalar and meets the condition of z10_c.
274 ;; z10_fwd: The instruction reads the value of an operand and stores it into a
275 ;; target register. It can forward this value to a second instruction that reads
276 ;; the same register if that second instruction is issued in the same group.
277 ;; z10_rec: The instruction is in the T pipeline and reads a register. If the
278 ;; instruction in the S pipe writes to the register, then the T instruction
279 ;; can immediately read the new value.
280 ;; z10_fr: union of Z10_fwd and z10_rec.
281 ;; z10_c: second operand of instruction is a register and read with complemented bits.
283 ;; An additional suffix A1, A3, or E1 indicates the respective AGI bypass.
286 (define_attr "z10prop" "none,
287 z10_super, z10_super_E1, z10_super_A1, z10_super_c, z10_super_c_E1,
288 z10_fwd, z10_fwd_A1, z10_fwd_A3, z10_fwd_E1,
290 z10_fr, z10_fr_A3, z10_fr_E1,
292 (const_string "none"))
294 ;; Properties concerning Z196 decoding
295 ;; z196_alone: must group alone
296 ;; z196_end: ends a group
297 ;; z196_cracked: instruction is cracked or expanded
298 (define_attr "z196prop" "none,
299 z196_alone, z196_ends,
301 (const_string "none"))
303 (define_attr "mnemonic" "bcr_flush,unknown" (const_string "unknown"))
307 (define_attr "length" ""
308 (cond [(eq_attr "op_type" "E,RR") (const_int 2)
309 (eq_attr "op_type" "RX,RI,RRE,RS,RSI,S,SI,RRF,RRR") (const_int 4)]
313 ;; Processor type. This attribute must exactly match the processor_type
314 ;; enumeration in s390.h. The current machine description does not
315 ;; distinguish between g5 and g6, but there are differences between the two
316 ;; CPUs could in theory be modeled.
318 (define_attr "cpu" "g5,g6,z900,z990,z9_109,z9_ec,z10,z196,zEC12"
319 (const (symbol_ref "s390_tune_attr")))
321 (define_attr "cpu_facility"
322 "standard,ieee,zarch,cpu_zarch,longdisp,extimm,dfp,z10,z196,zEC12"
323 (const_string "standard"))
325 (define_attr "enabled" ""
326 (cond [(eq_attr "cpu_facility" "standard")
329 (and (eq_attr "cpu_facility" "ieee")
330 (match_test "TARGET_CPU_IEEE_FLOAT"))
333 (and (eq_attr "cpu_facility" "zarch")
334 (match_test "TARGET_ZARCH"))
337 (and (eq_attr "cpu_facility" "longdisp")
338 (match_test "TARGET_LONG_DISPLACEMENT"))
341 (and (eq_attr "cpu_facility" "extimm")
342 (match_test "TARGET_EXTIMM"))
345 (and (eq_attr "cpu_facility" "dfp")
346 (match_test "TARGET_DFP"))
349 (and (eq_attr "cpu_facility" "cpu_zarch")
350 (match_test "TARGET_CPU_ZARCH"))
353 (and (eq_attr "cpu_facility" "z10")
354 (match_test "TARGET_Z10"))
357 (and (eq_attr "cpu_facility" "z196")
358 (match_test "TARGET_Z196"))
361 (and (eq_attr "cpu_facility" "zEC12")
362 (match_test "TARGET_ZEC12"))
366 ;; Pipeline description for z900. For lack of anything better,
367 ;; this description is also used for the g5 and g6.
370 ;; Pipeline description for z990, z9-109 and z9-ec.
373 ;; Pipeline description for z10
376 ;; Pipeline description for z196
379 ;; Pipeline description for zEC12
383 (include "predicates.md")
385 ;; Constraint definitions
386 (include "constraints.md")
393 ;; These mode iterators allow floating point patterns to be generated from the
395 (define_mode_iterator FP_ALL [TF DF SF (TD "TARGET_HARD_DFP") (DD "TARGET_HARD_DFP")
396 (SD "TARGET_HARD_DFP")])
397 (define_mode_iterator FP [TF DF SF (TD "TARGET_HARD_DFP") (DD "TARGET_HARD_DFP")])
398 (define_mode_iterator FPALL [TF DF SF TD DD SD])
399 (define_mode_iterator BFP [TF DF SF])
400 (define_mode_iterator DFP [TD DD])
401 (define_mode_iterator DFP_ALL [TD DD SD])
402 (define_mode_iterator DSF [DF SF])
403 (define_mode_iterator SD_SF [SF SD])
404 (define_mode_iterator DD_DF [DF DD])
405 (define_mode_iterator TD_TF [TF TD])
407 ;; These mode iterators allow 31-bit and 64-bit GPR patterns to be generated
408 ;; from the same template.
409 (define_mode_iterator GPR [(DI "TARGET_ZARCH") SI])
410 (define_mode_iterator DGPR [(TI "TARGET_ZARCH") DI SI])
411 (define_mode_iterator DSI [DI SI])
412 (define_mode_iterator TDI [TI DI])
414 ;; These mode iterators allow :P to be used for patterns that operate on
415 ;; pointer-sized quantities. Exactly one of the two alternatives will match.
416 (define_mode_iterator P [(DI "TARGET_64BIT") (SI "!TARGET_64BIT")])
418 ;; These macros refer to the actual word_mode of the configuration.
419 ;; This is equal to Pmode except on 31-bit machines in zarch mode.
420 (define_mode_iterator DW [(TI "TARGET_ZARCH") (DI "!TARGET_ZARCH")])
421 (define_mode_iterator W [(DI "TARGET_ZARCH") (SI "!TARGET_ZARCH")])
423 ;; Used by the umul pattern to express modes having half the size.
424 (define_mode_attr DWH [(TI "DI") (DI "SI")])
425 (define_mode_attr dwh [(TI "di") (DI "si")])
427 ;; This mode iterator allows the QI and HI patterns to be defined from
428 ;; the same template.
429 (define_mode_iterator HQI [HI QI])
431 ;; This mode iterator allows the integer patterns to be defined from the
433 (define_mode_iterator INT [(DI "TARGET_ZARCH") SI HI QI])
434 (define_mode_iterator INTALL [TI DI SI HI QI])
435 (define_mode_iterator DINT [(TI "TARGET_ZARCH") DI SI HI QI])
437 ;; This iterator allows some 'ashift' and 'lshiftrt' pattern to be defined from
438 ;; the same template.
439 (define_code_iterator SHIFT [ashift lshiftrt])
441 ;; This iterator allows r[ox]sbg to be defined with the same template
442 (define_code_iterator IXOR [ior xor])
444 ;; This iterator is used to expand the patterns for the nearest
445 ;; integer functions.
446 (define_int_iterator FPINT [UNSPEC_FPINT_FLOOR UNSPEC_FPINT_BTRUNC
447 UNSPEC_FPINT_ROUND UNSPEC_FPINT_CEIL
448 UNSPEC_FPINT_NEARBYINT])
449 (define_int_attr fpint_name [(UNSPEC_FPINT_FLOOR "floor")
450 (UNSPEC_FPINT_BTRUNC "btrunc")
451 (UNSPEC_FPINT_ROUND "round")
452 (UNSPEC_FPINT_CEIL "ceil")
453 (UNSPEC_FPINT_NEARBYINT "nearbyint")])
454 (define_int_attr fpint_roundingmode [(UNSPEC_FPINT_FLOOR "7")
455 (UNSPEC_FPINT_BTRUNC "5")
456 (UNSPEC_FPINT_ROUND "1")
457 (UNSPEC_FPINT_CEIL "6")
458 (UNSPEC_FPINT_NEARBYINT "0")])
460 ;; This iterator and attribute allow to combine most atomic operations.
461 (define_code_iterator ATOMIC [and ior xor plus minus mult])
462 (define_code_iterator ATOMIC_Z196 [and ior xor plus])
463 (define_code_attr atomic [(and "and") (ior "ior") (xor "xor")
464 (plus "add") (minus "sub") (mult "nand")])
465 (define_code_attr noxa [(and "n") (ior "o") (xor "x") (plus "a")])
467 ;; In FP templates, a string like "lt<de>br" will expand to "ltxbr" in
468 ;; TF/TDmode, "ltdbr" in DF/DDmode, and "ltebr" in SF/SDmode.
469 (define_mode_attr xde [(TF "x") (DF "d") (SF "e") (TD "x") (DD "d") (SD "e")])
471 ;; In FP templates, a <dee> in "m<dee><bt>r" will expand to "mx<bt>r" in
472 ;; TF/TDmode, "md<bt>r" in DF/DDmode, "mee<bt>r" in SFmode and "me<bt>r in
474 (define_mode_attr xdee [(TF "x") (DF "d") (SF "ee") (TD "x") (DD "d") (SD "e")])
476 ;; In FP templates, "<RRe>" will expand to "RRE" in TFmode and "RR" otherwise.
477 ;; Likewise for "<RXe>".
478 (define_mode_attr RRe [(TF "RRE") (DF "RR") (SF "RR")])
479 (define_mode_attr RXe [(TF "RXE") (DF "RX") (SF "RX")])
481 ;; The decimal floating point variants of add, sub, div and mul support 3
482 ;; fp register operands. The following attributes allow to merge the bfp and
483 ;; dfp variants in a single insn definition.
485 ;; This attribute is used to set op_type accordingly.
486 (define_mode_attr RRer [(TF "RRE") (DF "RRE") (SF "RRE") (TD "RRR")
487 (DD "RRR") (SD "RRR")])
489 ;; This attribute is used in the operand constraint list in order to have the
490 ;; first and the second operand match for bfp modes.
491 (define_mode_attr f0 [(TF "0") (DF "0") (SF "0") (TD "f") (DD "f") (DD "f")])
493 ;; This attribute is used in the operand list of the instruction to have an
494 ;; additional operand for the dfp instructions.
495 (define_mode_attr op1 [(TF "") (DF "") (SF "")
496 (TD "%1,") (DD "%1,") (SD "%1,")])
499 ;; This attribute is used in the operand constraint list
500 ;; for instructions dealing with the sign bit of 32 or 64bit fp values.
501 ;; TFmode values are represented by a fp register pair. Since the
502 ;; sign bit instructions only handle single source and target fp registers
503 ;; these instructions can only be used for TFmode values if the source and
504 ;; target operand uses the same fp register.
505 (define_mode_attr fT0 [(TF "0") (DF "f") (SF "f")])
507 ;; In FP templates, "<Rf>" will expand to "f" in TFmode and "R" otherwise.
508 ;; This is used to disable the memory alternative in TFmode patterns.
509 (define_mode_attr Rf [(TF "f") (DF "R") (SF "R") (TD "f") (DD "f") (SD "f")])
511 ;; This attribute adds b for bfp instructions and t for dfp instructions and is used
512 ;; within instruction mnemonics.
513 (define_mode_attr bt [(TF "b") (DF "b") (SF "b") (TD "t") (DD "t") (SD "t")])
515 ;; This attribute is used within instruction mnemonics. It evaluates to d for dfp
516 ;; modes and to an empty string for bfp modes.
517 (define_mode_attr _d [(TF "") (DF "") (SF "") (TD "d") (DD "d") (SD "d")])
519 ;; In GPR and P templates, a constraint like "<d0>" will expand to "d" in DImode
520 ;; and "0" in SImode. This allows to combine instructions of which the 31bit
521 ;; version only operates on one register.
522 (define_mode_attr d0 [(DI "d") (SI "0")])
524 ;; In combination with d0 this allows to combine instructions of which the 31bit
525 ;; version only operates on one register. The DImode version needs an additional
526 ;; register for the assembler output.
527 (define_mode_attr 1 [(DI "%1,") (SI "")])
529 ;; In SHIFT templates, a string like "s<lr>dl" will expand to "sldl" in
530 ;; 'ashift' and "srdl" in 'lshiftrt'.
531 (define_code_attr lr [(ashift "l") (lshiftrt "r")])
533 ;; In SHIFT templates, this attribute holds the correct standard name for the
534 ;; pattern itself and the corresponding function calls.
535 (define_code_attr shift [(ashift "ashl") (lshiftrt "lshr")])
537 ;; This attribute handles differences in the instruction 'type' and will result
538 ;; in "RRE" for DImode and "RR" for SImode.
539 (define_mode_attr E [(DI "E") (SI "")])
541 ;; This attribute handles differences in the instruction 'type' and makes RX<Y>
542 ;; to result in "RXY" for DImode and "RX" for SImode.
543 (define_mode_attr Y [(DI "Y") (SI "")])
545 ;; This attribute handles differences in the instruction 'type' and will result
546 ;; in "RSE" for TImode and "RS" for DImode.
547 (define_mode_attr TE [(TI "E") (DI "")])
549 ;; In GPR templates, a string like "lc<g>r" will expand to "lcgr" in DImode
550 ;; and "lcr" in SImode.
551 (define_mode_attr g [(DI "g") (SI "")])
553 ;; In GPR templates, a string like "sl<y>" will expand to "slg" in DImode
554 ;; and "sly" in SImode. This is useful because on 64bit the ..g instructions
555 ;; were enhanced with long displacements whereas 31bit instructions got a ..y
556 ;; variant for long displacements.
557 (define_mode_attr y [(DI "g") (SI "y")])
559 ;; In DW templates, a string like "cds<g>" will expand to "cdsg" in TImode
560 ;; and "cds" in DImode.
561 (define_mode_attr tg [(TI "g") (DI "")])
563 ;; In TDI templates, a string like "c<d>sg".
564 (define_mode_attr td [(TI "d") (DI "")])
566 ;; In GPR templates, a string like "c<gf>dbr" will expand to "cgdbr" in DImode
567 ;; and "cfdbr" in SImode.
568 (define_mode_attr gf [(DI "g") (SI "f")])
570 ;; In GPR templates, a string like sll<gk> will expand to sllg for DI
571 ;; and sllk for SI. This way it is possible to merge the new z196 SI
572 ;; 3 operands shift instructions into the existing patterns.
573 (define_mode_attr gk [(DI "g") (SI "k")])
575 ;; ICM mask required to load MODE value into the lowest subreg
576 ;; of a SImode register.
577 (define_mode_attr icm_lo [(HI "3") (QI "1")])
579 ;; In HQI templates, a string like "llg<hc>" will expand to "llgh" in
580 ;; HImode and "llgc" in QImode.
581 (define_mode_attr hc [(HI "h") (QI "c")])
583 ;; In P templates, the mode <DBL> will expand to "TI" in DImode and "DI"
585 (define_mode_attr DBL [(DI "TI") (SI "DI")])
587 ;; This attribute expands to DF for TFmode and to DD for TDmode . It is
588 ;; used for Txmode splitters splitting a Txmode copy into 2 Dxmode copies.
589 (define_mode_attr HALF_TMODE [(TF "DF") (TD "DD")])
591 ;; Maximum unsigned integer that fits in MODE.
592 (define_mode_attr max_uint [(HI "65535") (QI "255")])
594 ;; Start and end field computations for RISBG et al.
595 (define_mode_attr bfstart [(DI "s") (SI "t")])
596 (define_mode_attr bfend [(DI "e") (SI "f")])
598 ;; In place of GET_MODE_BITSIZE (<MODE>mode)
599 (define_mode_attr bitsize [(DI "64") (SI "32") (HI "16") (QI "8")])
601 ;; Allow return and simple_return to be defined from a single template.
602 (define_code_iterator ANY_RETURN [return simple_return])
605 ;;- Compare instructions.
608 ; Test-under-Mask instructions
610 (define_insn "*tmqi_mem"
611 [(set (reg CC_REGNUM)
612 (compare (and:QI (match_operand:QI 0 "memory_operand" "Q,S")
613 (match_operand:QI 1 "immediate_operand" "n,n"))
614 (match_operand:QI 2 "immediate_operand" "n,n")))]
615 "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], false))"
619 [(set_attr "op_type" "SI,SIY")
620 (set_attr "z10prop" "z10_super,z10_super")])
622 (define_insn "*tmdi_reg"
623 [(set (reg CC_REGNUM)
624 (compare (and:DI (match_operand:DI 0 "nonimmediate_operand" "d,d,d,d")
625 (match_operand:DI 1 "immediate_operand"
626 "N0HD0,N1HD0,N2HD0,N3HD0"))
627 (match_operand:DI 2 "immediate_operand" "n,n,n,n")))]
629 && s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], true))
630 && s390_single_part (operands[1], DImode, HImode, 0) >= 0"
636 [(set_attr "op_type" "RI")
637 (set_attr "z10prop" "z10_super,z10_super,z10_super,z10_super")])
639 (define_insn "*tmsi_reg"
640 [(set (reg CC_REGNUM)
641 (compare (and:SI (match_operand:SI 0 "nonimmediate_operand" "d,d")
642 (match_operand:SI 1 "immediate_operand" "N0HS0,N1HS0"))
643 (match_operand:SI 2 "immediate_operand" "n,n")))]
644 "s390_match_ccmode (insn, s390_tm_ccmode (operands[1], operands[2], true))
645 && s390_single_part (operands[1], SImode, HImode, 0) >= 0"
649 [(set_attr "op_type" "RI")
650 (set_attr "z10prop" "z10_super,z10_super")])
652 (define_insn "*tm<mode>_full"
653 [(set (reg CC_REGNUM)
654 (compare (match_operand:HQI 0 "register_operand" "d")
655 (match_operand:HQI 1 "immediate_operand" "n")))]
656 "s390_match_ccmode (insn, s390_tm_ccmode (constm1_rtx, operands[1], true))"
658 [(set_attr "op_type" "RI")
659 (set_attr "z10prop" "z10_super")])
663 ; Load-and-Test instructions
666 ; tst(di|si) instruction pattern(s).
668 (define_insn "*tstdi_sign"
669 [(set (reg CC_REGNUM)
673 (subreg:DI (match_operand:SI 0 "nonimmediate_operand" "d,RT") 0)
674 (const_int 32)) (const_int 32))
675 (match_operand:DI 1 "const0_operand" "")))
676 (set (match_operand:DI 2 "register_operand" "=d,d")
677 (sign_extend:DI (match_dup 0)))]
678 "s390_match_ccmode(insn, CCSmode) && TARGET_ZARCH"
681 [(set_attr "op_type" "RRE,RXY")
682 (set_attr "cpu_facility" "*,z10")
683 (set_attr "z10prop" "z10_super_E1,z10_super_E1") ])
686 (define_insn "*tst<mode>_extimm"
687 [(set (reg CC_REGNUM)
688 (compare (match_operand:GPR 0 "nonimmediate_operand" "d,RT")
689 (match_operand:GPR 1 "const0_operand" "")))
690 (set (match_operand:GPR 2 "register_operand" "=d,d")
692 "s390_match_ccmode(insn, CCSmode) && TARGET_EXTIMM"
696 [(set_attr "op_type" "RR<E>,RXY")
697 (set_attr "z10prop" "z10_fr_E1,z10_fwd_A3") ])
700 (define_insn "*tst<mode>_cconly_extimm"
701 [(set (reg CC_REGNUM)
702 (compare (match_operand:GPR 0 "nonimmediate_operand" "d,RT")
703 (match_operand:GPR 1 "const0_operand" "")))
704 (clobber (match_scratch:GPR 2 "=X,d"))]
705 "s390_match_ccmode(insn, CCSmode) && TARGET_EXTIMM"
709 [(set_attr "op_type" "RR<E>,RXY")
710 (set_attr "z10prop" "z10_fr_E1,z10_fwd_A3")])
712 (define_insn "*tstdi"
713 [(set (reg CC_REGNUM)
714 (compare (match_operand:DI 0 "register_operand" "d")
715 (match_operand:DI 1 "const0_operand" "")))
716 (set (match_operand:DI 2 "register_operand" "=d")
718 "s390_match_ccmode(insn, CCSmode) && TARGET_ZARCH && !TARGET_EXTIMM"
720 [(set_attr "op_type" "RRE")
721 (set_attr "z10prop" "z10_fr_E1")])
723 (define_insn "*tstsi"
724 [(set (reg CC_REGNUM)
725 (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
726 (match_operand:SI 1 "const0_operand" "")))
727 (set (match_operand:SI 2 "register_operand" "=d,d,d")
729 "s390_match_ccmode(insn, CCSmode) && !TARGET_EXTIMM"
734 [(set_attr "op_type" "RR,RS,RSY")
735 (set_attr "z10prop" "z10_fr_E1,z10_super_E1,z10_super_E1")])
737 (define_insn "*tstsi_cconly"
738 [(set (reg CC_REGNUM)
739 (compare (match_operand:SI 0 "nonimmediate_operand" "d,Q,S")
740 (match_operand:SI 1 "const0_operand" "")))
741 (clobber (match_scratch:SI 2 "=X,d,d"))]
742 "s390_match_ccmode(insn, CCSmode)"
747 [(set_attr "op_type" "RR,RS,RSY")
748 (set_attr "z10prop" "z10_fr_E1,z10_super_E1,z10_super_E1")])
750 (define_insn "*tstdi_cconly_31"
751 [(set (reg CC_REGNUM)
752 (compare (match_operand:DI 0 "register_operand" "d")
753 (match_operand:DI 1 "const0_operand" "")))]
754 "s390_match_ccmode(insn, CCSmode) && !TARGET_ZARCH"
756 [(set_attr "op_type" "RS")
757 (set_attr "atype" "reg")])
760 (define_insn "*tst<mode>_cconly2"
761 [(set (reg CC_REGNUM)
762 (compare (match_operand:GPR 0 "register_operand" "d")
763 (match_operand:GPR 1 "const0_operand" "")))]
764 "s390_match_ccmode(insn, CCSmode)"
766 [(set_attr "op_type" "RR<E>")
767 (set_attr "z10prop" "z10_fr_E1")])
769 ; tst(hi|qi) instruction pattern(s).
771 (define_insn "*tst<mode>CCT"
772 [(set (reg CC_REGNUM)
773 (compare (match_operand:HQI 0 "nonimmediate_operand" "?Q,?S,d")
774 (match_operand:HQI 1 "const0_operand" "")))
775 (set (match_operand:HQI 2 "register_operand" "=d,d,0")
777 "s390_match_ccmode(insn, CCTmode)"
780 icmy\t%2,<icm_lo>,%S0
782 [(set_attr "op_type" "RS,RSY,RI")
783 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super")])
785 (define_insn "*tsthiCCT_cconly"
786 [(set (reg CC_REGNUM)
787 (compare (match_operand:HI 0 "nonimmediate_operand" "Q,S,d")
788 (match_operand:HI 1 "const0_operand" "")))
789 (clobber (match_scratch:HI 2 "=d,d,X"))]
790 "s390_match_ccmode(insn, CCTmode)"
795 [(set_attr "op_type" "RS,RSY,RI")
796 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super")])
798 (define_insn "*tstqiCCT_cconly"
799 [(set (reg CC_REGNUM)
800 (compare (match_operand:QI 0 "nonimmediate_operand" "?Q,?S,d")
801 (match_operand:QI 1 "const0_operand" "")))]
802 "s390_match_ccmode(insn, CCTmode)"
807 [(set_attr "op_type" "SI,SIY,RI")
808 (set_attr "z10prop" "z10_super,z10_super,z10_super")])
810 (define_insn "*tst<mode>"
811 [(set (reg CC_REGNUM)
812 (compare (match_operand:HQI 0 "s_operand" "Q,S")
813 (match_operand:HQI 1 "const0_operand" "")))
814 (set (match_operand:HQI 2 "register_operand" "=d,d")
816 "s390_match_ccmode(insn, CCSmode)"
819 icmy\t%2,<icm_lo>,%S0"
820 [(set_attr "op_type" "RS,RSY")
821 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
823 (define_insn "*tst<mode>_cconly"
824 [(set (reg CC_REGNUM)
825 (compare (match_operand:HQI 0 "s_operand" "Q,S")
826 (match_operand:HQI 1 "const0_operand" "")))
827 (clobber (match_scratch:HQI 2 "=d,d"))]
828 "s390_match_ccmode(insn, CCSmode)"
831 icmy\t%2,<icm_lo>,%S0"
832 [(set_attr "op_type" "RS,RSY")
833 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
836 ; Compare (equality) instructions
838 (define_insn "*cmpdi_cct"
839 [(set (reg CC_REGNUM)
840 (compare (match_operand:DI 0 "nonimmediate_operand" "%d,d,d,d,Q")
841 (match_operand:DI 1 "general_operand" "d,K,Os,RT,BQ")))]
842 "s390_match_ccmode (insn, CCTmode) && TARGET_ZARCH"
849 [(set_attr "op_type" "RRE,RI,RIL,RXY,SS")
850 (set_attr "z10prop" "z10_super_c,z10_super,z10_super,z10_super,*")])
852 (define_insn "*cmpsi_cct"
853 [(set (reg CC_REGNUM)
854 (compare (match_operand:SI 0 "nonimmediate_operand" "%d,d,d,d,d,Q")
855 (match_operand:SI 1 "general_operand" "d,K,Os,R,T,BQ")))]
856 "s390_match_ccmode (insn, CCTmode)"
864 [(set_attr "op_type" "RR,RI,RIL,RX,RXY,SS")
865 (set_attr "z10prop" "z10_super_c,z10_super,z10_super,z10_super,z10_super,*")])
867 ; Compare (signed) instructions
869 (define_insn "*cmpdi_ccs_sign"
870 [(set (reg CC_REGNUM)
871 (compare (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand"
873 (match_operand:DI 0 "register_operand" "d, d,d")))]
874 "s390_match_ccmode(insn, CCSRmode) && TARGET_ZARCH"
879 [(set_attr "op_type" "RRE,RXY,RIL")
880 (set_attr "z10prop" "z10_c,*,*")
881 (set_attr "type" "*,*,larl")])
885 (define_insn "*cmpsi_ccs_sign"
886 [(set (reg CC_REGNUM)
887 (compare (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T,b"))
888 (match_operand:SI 0 "register_operand" "d,d,d")))]
889 "s390_match_ccmode(insn, CCSRmode)"
894 [(set_attr "op_type" "RX,RXY,RIL")
895 (set_attr "cpu_facility" "*,*,z10")
896 (set_attr "type" "*,*,larl")
897 (set_attr "z196prop" "z196_cracked,z196_cracked,z196_cracked")])
899 (define_insn "*cmphi_ccs_z10"
900 [(set (reg CC_REGNUM)
901 (compare (match_operand:HI 0 "s_operand" "Q")
902 (match_operand:HI 1 "immediate_operand" "K")))]
903 "s390_match_ccmode(insn, CCSmode) && TARGET_Z10"
905 [(set_attr "op_type" "SIL")
906 (set_attr "z196prop" "z196_cracked")])
908 (define_insn "*cmpdi_ccs_signhi_rl"
909 [(set (reg CC_REGNUM)
910 (compare (sign_extend:DI (match_operand:HI 1 "memory_operand" "RT,b"))
911 (match_operand:GPR 0 "register_operand" "d,d")))]
912 "s390_match_ccmode(insn, CCSRmode) && TARGET_Z10"
916 [(set_attr "op_type" "RXY,RIL")
917 (set_attr "type" "*,larl")])
919 ; cr, chi, cfi, c, cy, cgr, cghi, cgfi, cg, chsi, cghsi, crl, cgrl
920 (define_insn "*cmp<mode>_ccs"
921 [(set (reg CC_REGNUM)
922 (compare (match_operand:GPR 0 "nonimmediate_operand"
924 (match_operand:GPR 1 "general_operand"
926 "s390_match_ccmode(insn, CCSmode)"
935 [(set_attr "op_type" "RR<E>,RI,SIL,RIL,RX<Y>,RXY,RIL")
936 (set_attr "cpu_facility" "*,*,z10,extimm,*,*,z10")
937 (set_attr "type" "*,*,*,*,*,*,larl")
938 (set_attr "z10prop" "z10_super_c,z10_super,z10_super,z10_super,z10_super,z10_super,z10_super")])
941 ; Compare (unsigned) instructions
943 (define_insn "*cmpsi_ccu_zerohi_rlsi"
944 [(set (reg CC_REGNUM)
945 (compare (zero_extend:SI (mem:HI (match_operand:SI 1
946 "larl_operand" "X")))
947 (match_operand:SI 0 "register_operand" "d")))]
948 "s390_match_ccmode(insn, CCURmode) && TARGET_Z10"
950 [(set_attr "op_type" "RIL")
951 (set_attr "type" "larl")
952 (set_attr "z10prop" "z10_super")])
955 (define_insn "*cmp<GPR:mode>_ccu_zerohi_rldi"
956 [(set (reg CC_REGNUM)
957 (compare (zero_extend:GPR (mem:HI (match_operand:DI 1
958 "larl_operand" "X")))
959 (match_operand:GPR 0 "register_operand" "d")))]
960 "s390_match_ccmode(insn, CCURmode) && TARGET_Z10"
962 [(set_attr "op_type" "RIL")
963 (set_attr "type" "larl")
964 (set_attr "z10prop" "z10_super")])
966 (define_insn "*cmpdi_ccu_zero"
967 [(set (reg CC_REGNUM)
968 (compare (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand"
970 (match_operand:DI 0 "register_operand" "d, d,d")))]
971 "s390_match_ccmode (insn, CCURmode) && TARGET_ZARCH"
976 [(set_attr "op_type" "RRE,RXY,RIL")
977 (set_attr "cpu_facility" "*,*,z10")
978 (set_attr "type" "*,*,larl")
979 (set_attr "z10prop" "z10_super_c,z10_super_E1,z10_super")])
981 (define_insn "*cmpdi_ccu"
982 [(set (reg CC_REGNUM)
983 (compare (match_operand:DI 0 "nonimmediate_operand"
985 (match_operand:DI 1 "general_operand"
986 "d,Op,b,D,RT,BQ,Q")))]
987 "s390_match_ccmode (insn, CCUmode) && TARGET_ZARCH"
996 [(set_attr "op_type" "RRE,RIL,RIL,SIL,RXY,SS,SS")
997 (set_attr "cpu_facility" "*,extimm,z10,z10,*,*,*")
998 (set_attr "type" "*,*,larl,*,*,*,*")
999 (set_attr "z10prop" "z10_super_c,z10_super,z10_super,z10_super,z10_super,*,*")])
1001 (define_insn "*cmpsi_ccu"
1002 [(set (reg CC_REGNUM)
1003 (compare (match_operand:SI 0 "nonimmediate_operand" "d, d,d,Q,d,d, Q,BQ")
1004 (match_operand:SI 1 "general_operand" "d,Os,b,D,R,T,BQ, Q")))]
1005 "s390_match_ccmode (insn, CCUmode)"
1015 [(set_attr "op_type" "RR,RIL,RIL,SIL,RX,RXY,SS,SS")
1016 (set_attr "cpu_facility" "*,extimm,z10,z10,*,*,*,*")
1017 (set_attr "type" "*,*,larl,*,*,*,*,*")
1018 (set_attr "z10prop" "z10_super_c,z10_super,z10_super,z10_super,z10_super,z10_super,*,*")])
1020 (define_insn "*cmphi_ccu"
1021 [(set (reg CC_REGNUM)
1022 (compare (match_operand:HI 0 "nonimmediate_operand" "d,d,Q,Q,BQ")
1023 (match_operand:HI 1 "general_operand" "Q,S,D,BQ,Q")))]
1024 "s390_match_ccmode (insn, CCUmode)
1025 && !register_operand (operands[1], HImode)"
1032 [(set_attr "op_type" "RS,RSY,SIL,SS,SS")
1033 (set_attr "cpu_facility" "*,*,z10,*,*")
1034 (set_attr "z10prop" "*,*,z10_super,*,*")])
1036 (define_insn "*cmpqi_ccu"
1037 [(set (reg CC_REGNUM)
1038 (compare (match_operand:QI 0 "nonimmediate_operand" "d,d,Q,S,Q,BQ")
1039 (match_operand:QI 1 "general_operand" "Q,S,n,n,BQ,Q")))]
1040 "s390_match_ccmode (insn, CCUmode)
1041 && !register_operand (operands[1], QImode)"
1049 [(set_attr "op_type" "RS,RSY,SI,SIY,SS,SS")
1050 (set_attr "z10prop" "*,*,z10_super,z10_super,*,*")])
1053 ; Block compare (CLC) instruction patterns.
1056 [(set (reg CC_REGNUM)
1057 (compare (match_operand:BLK 0 "memory_operand" "Q")
1058 (match_operand:BLK 1 "memory_operand" "Q")))
1059 (use (match_operand 2 "const_int_operand" "n"))]
1060 "s390_match_ccmode (insn, CCUmode)
1061 && INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
1062 "clc\t%O0(%2,%R0),%S1"
1063 [(set_attr "op_type" "SS")])
1066 [(set (reg CC_REGNUM)
1067 (compare (match_operand 0 "memory_operand" "")
1068 (match_operand 1 "memory_operand" "")))]
1070 && s390_match_ccmode (insn, CCUmode)
1071 && GET_MODE (operands[0]) == GET_MODE (operands[1])
1072 && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
1074 [(set (match_dup 0) (match_dup 1))
1075 (use (match_dup 2))])]
1077 operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
1078 operands[0] = adjust_address (operands[0], BLKmode, 0);
1079 operands[1] = adjust_address (operands[1], BLKmode, 0);
1081 operands[1] = gen_rtx_COMPARE (GET_MODE (SET_DEST (PATTERN (curr_insn))),
1082 operands[0], operands[1]);
1083 operands[0] = SET_DEST (PATTERN (curr_insn));
1087 ; (TF|DF|SF|TD|DD|SD) instructions
1089 ; ltxbr, ltdbr, ltebr, ltxtr, ltdtr
1090 (define_insn "*cmp<mode>_ccs_0"
1091 [(set (reg CC_REGNUM)
1092 (compare (match_operand:FP 0 "register_operand" "f")
1093 (match_operand:FP 1 "const0_operand" "")))]
1094 "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT"
1095 "lt<xde><bt>r\t%0,%0"
1096 [(set_attr "op_type" "RRE")
1097 (set_attr "type" "fsimp<mode>")])
1099 ; cxtr, cxbr, cdtr, cdbr, cebr, cdb, ceb
1100 (define_insn "*cmp<mode>_ccs"
1101 [(set (reg CC_REGNUM)
1102 (compare (match_operand:FP 0 "register_operand" "f,f")
1103 (match_operand:FP 1 "general_operand" "f,<Rf>")))]
1104 "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT"
1108 [(set_attr "op_type" "RRE,RXE")
1109 (set_attr "type" "fsimp<mode>")])
1112 ; Compare and Branch instructions
1114 ; cij, cgij, crj, cgrj, cfi, cgfi, cr, cgr
1115 ; The following instructions do a complementary access of their second
1116 ; operand (z01 only): crj_c, cgrjc, cr, cgr
1117 (define_insn "*cmp_and_br_signed_<mode>"
1119 (if_then_else (match_operator 0 "s390_signed_integer_comparison"
1120 [(match_operand:GPR 1 "register_operand" "d,d")
1121 (match_operand:GPR 2 "nonmemory_operand" "d,C")])
1122 (label_ref (match_operand 3 "" ""))
1124 (clobber (reg:CC CC_REGNUM))]
1125 "TARGET_Z10 && !TARGET_AVOID_CMP_AND_BRANCH"
1127 if (get_attr_length (insn) == 6)
1128 return which_alternative ?
1129 "c<g>ij%C0\t%1,%c2,%l3" : "c<g>rj%C0\t%1,%2,%l3";
1131 return which_alternative ?
1132 "c<g>fi\t%1,%c2\;jg%C0\t%l3" : "c<g>r\t%1,%2\;jg%C0\t%l3";
1134 [(set_attr "op_type" "RIE")
1135 (set_attr "type" "branch")
1136 (set_attr "z10prop" "z10_super_c,z10_super")
1137 (set (attr "length")
1138 (if_then_else (lt (abs (minus (pc) (match_dup 3))) (const_int 60000))
1139 (const_int 6) (const_int 12)))]) ; 8 byte for cr/jg
1140 ; 10 byte for cgr/jg
1142 ; clij, clgij, clrj, clgrj, clfi, clgfi, clr, clgr
1143 ; The following instructions do a complementary access of their second
1144 ; operand (z10 only): clrj, clgrj, clr, clgr
1145 (define_insn "*cmp_and_br_unsigned_<mode>"
1147 (if_then_else (match_operator 0 "s390_unsigned_integer_comparison"
1148 [(match_operand:GPR 1 "register_operand" "d,d")
1149 (match_operand:GPR 2 "nonmemory_operand" "d,I")])
1150 (label_ref (match_operand 3 "" ""))
1152 (clobber (reg:CC CC_REGNUM))]
1153 "TARGET_Z10 && !TARGET_AVOID_CMP_AND_BRANCH"
1155 if (get_attr_length (insn) == 6)
1156 return which_alternative ?
1157 "cl<g>ij%C0\t%1,%b2,%l3" : "cl<g>rj%C0\t%1,%2,%l3";
1159 return which_alternative ?
1160 "cl<g>fi\t%1,%b2\;jg%C0\t%l3" : "cl<g>r\t%1,%2\;jg%C0\t%l3";
1162 [(set_attr "op_type" "RIE")
1163 (set_attr "type" "branch")
1164 (set_attr "z10prop" "z10_super_c,z10_super")
1165 (set (attr "length")
1166 (if_then_else (lt (abs (minus (pc) (match_dup 3))) (const_int 60000))
1167 (const_int 6) (const_int 12)))]) ; 8 byte for clr/jg
1168 ; 10 byte for clgr/jg
1170 ; And now the same two patterns as above but with a negated CC mask.
1172 ; cij, cgij, crj, cgrj, cfi, cgfi, cr, cgr
1173 ; The following instructions do a complementary access of their second
1174 ; operand (z01 only): crj_c, cgrjc, cr, cgr
1175 (define_insn "*icmp_and_br_signed_<mode>"
1177 (if_then_else (match_operator 0 "s390_signed_integer_comparison"
1178 [(match_operand:GPR 1 "register_operand" "d,d")
1179 (match_operand:GPR 2 "nonmemory_operand" "d,C")])
1181 (label_ref (match_operand 3 "" ""))))
1182 (clobber (reg:CC CC_REGNUM))]
1183 "TARGET_Z10 && !TARGET_AVOID_CMP_AND_BRANCH"
1185 if (get_attr_length (insn) == 6)
1186 return which_alternative ?
1187 "c<g>ij%D0\t%1,%c2,%l3" : "c<g>rj%D0\t%1,%2,%l3";
1189 return which_alternative ?
1190 "c<g>fi\t%1,%c2\;jg%D0\t%l3" : "c<g>r\t%1,%2\;jg%D0\t%l3";
1192 [(set_attr "op_type" "RIE")
1193 (set_attr "type" "branch")
1194 (set_attr "z10prop" "z10_super_c,z10_super")
1195 (set (attr "length")
1196 (if_then_else (lt (abs (minus (pc) (match_dup 3))) (const_int 60000))
1197 (const_int 6) (const_int 12)))]) ; 8 byte for cr/jg
1198 ; 10 byte for cgr/jg
1200 ; clij, clgij, clrj, clgrj, clfi, clgfi, clr, clgr
1201 ; The following instructions do a complementary access of their second
1202 ; operand (z10 only): clrj, clgrj, clr, clgr
1203 (define_insn "*icmp_and_br_unsigned_<mode>"
1205 (if_then_else (match_operator 0 "s390_unsigned_integer_comparison"
1206 [(match_operand:GPR 1 "register_operand" "d,d")
1207 (match_operand:GPR 2 "nonmemory_operand" "d,I")])
1209 (label_ref (match_operand 3 "" ""))))
1210 (clobber (reg:CC CC_REGNUM))]
1211 "TARGET_Z10 && !TARGET_AVOID_CMP_AND_BRANCH"
1213 if (get_attr_length (insn) == 6)
1214 return which_alternative ?
1215 "cl<g>ij%D0\t%1,%b2,%l3" : "cl<g>rj%D0\t%1,%2,%l3";
1217 return which_alternative ?
1218 "cl<g>fi\t%1,%b2\;jg%D0\t%l3" : "cl<g>r\t%1,%2\;jg%D0\t%l3";
1220 [(set_attr "op_type" "RIE")
1221 (set_attr "type" "branch")
1222 (set_attr "z10prop" "z10_super_c,z10_super")
1223 (set (attr "length")
1224 (if_then_else (lt (abs (minus (pc) (match_dup 3))) (const_int 60000))
1225 (const_int 6) (const_int 12)))]) ; 8 byte for clr/jg
1226 ; 10 byte for clgr/jg
1229 ;;- Move instructions.
1233 ; movti instruction pattern(s).
1236 (define_insn "movti"
1237 [(set (match_operand:TI 0 "nonimmediate_operand" "=d,QS,d,o")
1238 (match_operand:TI 1 "general_operand" "QS,d,dPRT,d"))]
1245 [(set_attr "op_type" "RSY,RSY,*,*")
1246 (set_attr "type" "lm,stm,*,*")])
1249 [(set (match_operand:TI 0 "nonimmediate_operand" "")
1250 (match_operand:TI 1 "general_operand" ""))]
1251 "TARGET_ZARCH && reload_completed
1252 && s390_split_ok_p (operands[0], operands[1], TImode, 0)"
1253 [(set (match_dup 2) (match_dup 4))
1254 (set (match_dup 3) (match_dup 5))]
1256 operands[2] = operand_subword (operands[0], 0, 0, TImode);
1257 operands[3] = operand_subword (operands[0], 1, 0, TImode);
1258 operands[4] = operand_subword (operands[1], 0, 0, TImode);
1259 operands[5] = operand_subword (operands[1], 1, 0, TImode);
1263 [(set (match_operand:TI 0 "nonimmediate_operand" "")
1264 (match_operand:TI 1 "general_operand" ""))]
1265 "TARGET_ZARCH && reload_completed
1266 && s390_split_ok_p (operands[0], operands[1], TImode, 1)"
1267 [(set (match_dup 2) (match_dup 4))
1268 (set (match_dup 3) (match_dup 5))]
1270 operands[2] = operand_subword (operands[0], 1, 0, TImode);
1271 operands[3] = operand_subword (operands[0], 0, 0, TImode);
1272 operands[4] = operand_subword (operands[1], 1, 0, TImode);
1273 operands[5] = operand_subword (operands[1], 0, 0, TImode);
1277 [(set (match_operand:TI 0 "register_operand" "")
1278 (match_operand:TI 1 "memory_operand" ""))]
1279 "TARGET_ZARCH && reload_completed
1280 && !s_operand (operands[1], VOIDmode)"
1281 [(set (match_dup 0) (match_dup 1))]
1283 rtx addr = operand_subword (operands[0], 1, 0, TImode);
1284 addr = gen_lowpart (Pmode, addr);
1285 s390_load_address (addr, XEXP (operands[1], 0));
1286 operands[1] = replace_equiv_address (operands[1], addr);
1291 ; Patterns used for secondary reloads
1294 ; z10 provides move instructions accepting larl memory operands.
1295 ; Unfortunately there is no such variant for QI, TI and FP mode moves.
1296 ; These patterns are also used for unaligned SI and DI accesses.
1298 (define_expand "reload<INTALL:mode><P:mode>_tomem_z10"
1299 [(parallel [(match_operand:INTALL 0 "memory_operand" "")
1300 (match_operand:INTALL 1 "register_operand" "=d")
1301 (match_operand:P 2 "register_operand" "=&a")])]
1304 s390_reload_symref_address (operands[1], operands[0], operands[2], 1);
1308 (define_expand "reload<INTALL:mode><P:mode>_toreg_z10"
1309 [(parallel [(match_operand:INTALL 0 "register_operand" "=d")
1310 (match_operand:INTALL 1 "memory_operand" "")
1311 (match_operand:P 2 "register_operand" "=a")])]
1314 s390_reload_symref_address (operands[0], operands[1], operands[2], 0);
1318 (define_expand "reload<FPALL:mode><P:mode>_tomem_z10"
1319 [(parallel [(match_operand:FPALL 0 "memory_operand" "")
1320 (match_operand:FPALL 1 "register_operand" "=d")
1321 (match_operand:P 2 "register_operand" "=&a")])]
1324 s390_reload_symref_address (operands[1], operands[0], operands[2], 1);
1328 (define_expand "reload<FPALL:mode><P:mode>_toreg_z10"
1329 [(parallel [(match_operand:FPALL 0 "register_operand" "=d")
1330 (match_operand:FPALL 1 "memory_operand" "")
1331 (match_operand:P 2 "register_operand" "=a")])]
1334 s390_reload_symref_address (operands[0], operands[1], operands[2], 0);
1338 (define_expand "reload<P:mode>_larl_odd_addend_z10"
1339 [(parallel [(match_operand:P 0 "register_operand" "=d")
1340 (match_operand:P 1 "larl_operand" "")
1341 (match_operand:P 2 "register_operand" "=a")])]
1344 s390_reload_larl_operand (operands[0], operands[1], operands[2]);
1348 ; Handles loading a PLUS (load address) expression
1350 (define_expand "reload<mode>_plus"
1351 [(parallel [(match_operand:P 0 "register_operand" "=a")
1352 (match_operand:P 1 "s390_plus_operand" "")
1353 (match_operand:P 2 "register_operand" "=&a")])]
1356 s390_expand_plus_operand (operands[0], operands[1], operands[2]);
1360 ; Handles assessing a non-offsetable memory address
1362 (define_expand "reload<mode>_nonoffmem_in"
1363 [(parallel [(match_operand 0 "register_operand" "")
1364 (match_operand 1 "" "")
1365 (match_operand:P 2 "register_operand" "=&a")])]
1368 gcc_assert (MEM_P (operands[1]));
1369 s390_load_address (operands[2], find_replacement (&XEXP (operands[1], 0)));
1370 operands[1] = replace_equiv_address (operands[1], operands[2]);
1371 emit_move_insn (operands[0], operands[1]);
1375 (define_expand "reload<mode>_nonoffmem_out"
1376 [(parallel [(match_operand 0 "" "")
1377 (match_operand 1 "register_operand" "")
1378 (match_operand:P 2 "register_operand" "=&a")])]
1381 gcc_assert (MEM_P (operands[0]));
1382 s390_load_address (operands[2], find_replacement (&XEXP (operands[0], 0)));
1383 operands[0] = replace_equiv_address (operands[0], operands[2]);
1384 emit_move_insn (operands[0], operands[1]);
1388 (define_expand "reload<mode>_PIC_addr"
1389 [(parallel [(match_operand 0 "register_operand" "=d")
1390 (match_operand 1 "larl_operand" "")
1391 (match_operand:P 2 "register_operand" "=a")])]
1394 rtx new_rtx = legitimize_pic_address (operands[1], operands[2]);
1395 emit_move_insn (operands[0], new_rtx);
1399 ; movdi instruction pattern(s).
1402 (define_expand "movdi"
1403 [(set (match_operand:DI 0 "general_operand" "")
1404 (match_operand:DI 1 "general_operand" ""))]
1407 /* Handle symbolic constants. */
1409 && (SYMBOLIC_CONST (operands[1])
1410 || (GET_CODE (operands[1]) == PLUS
1411 && XEXP (operands[1], 0) == pic_offset_table_rtx
1412 && SYMBOLIC_CONST (XEXP (operands[1], 1)))))
1413 emit_symbolic_move (operands);
1416 (define_insn "*movdi_larl"
1417 [(set (match_operand:DI 0 "register_operand" "=d")
1418 (match_operand:DI 1 "larl_operand" "X"))]
1420 && !FP_REG_P (operands[0])"
1422 [(set_attr "op_type" "RIL")
1423 (set_attr "type" "larl")
1424 (set_attr "z10prop" "z10_super_A1")])
1426 (define_insn "*movdi_64"
1427 [(set (match_operand:DI 0 "nonimmediate_operand"
1428 "=d,d,d,d,d,d,d,d,f,d,d,d,d,d,
1429 RT,!*f,!*f,!*f,!R,!T,b,Q,d,t,Q,t")
1430 (match_operand:DI 1 "general_operand"
1431 "K,N0HD0,N1HD0,N2HD0,N3HD0,Os,N0SD0,N1SD0,d,f,L,b,d,RT,
1432 d,*f,R,T,*f,*f,d,K,t,d,t,Q"))]
1461 [(set_attr "op_type" "RI,RI,RI,RI,RI,RIL,RIL,RIL,RRE,RRE,RXY,RIL,RRE,RXY,
1462 RXY,RR,RX,RXY,RX,RXY,RIL,SIL,*,*,RS,RS")
1463 (set_attr "type" "*,*,*,*,*,*,*,*,floaddf,floaddf,la,larl,lr,load,store,
1464 floaddf,floaddf,floaddf,fstoredf,fstoredf,larl,*,*,*,
1466 (set_attr "cpu_facility" "*,*,*,*,*,extimm,extimm,extimm,dfp,dfp,longdisp,
1467 z10,*,*,*,*,*,longdisp,*,longdisp,
1469 (set_attr "z10prop" "z10_fwd_A1,
1498 [(set (match_operand:DI 0 "register_operand" "")
1499 (match_operand:DI 1 "register_operand" ""))]
1500 "TARGET_ZARCH && ACCESS_REG_P (operands[1])"
1501 [(set (match_dup 2) (match_dup 3))
1502 (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 32)))
1503 (set (strict_low_part (match_dup 2)) (match_dup 4))]
1504 "operands[2] = gen_lowpart (SImode, operands[0]);
1505 s390_split_access_reg (operands[1], &operands[4], &operands[3]);")
1508 [(set (match_operand:DI 0 "register_operand" "")
1509 (match_operand:DI 1 "register_operand" ""))]
1510 "TARGET_ZARCH && ACCESS_REG_P (operands[0])
1511 && dead_or_set_p (insn, operands[1])"
1512 [(set (match_dup 3) (match_dup 2))
1513 (set (match_dup 1) (lshiftrt:DI (match_dup 1) (const_int 32)))
1514 (set (match_dup 4) (match_dup 2))]
1515 "operands[2] = gen_lowpart (SImode, operands[1]);
1516 s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
1519 [(set (match_operand:DI 0 "register_operand" "")
1520 (match_operand:DI 1 "register_operand" ""))]
1521 "TARGET_ZARCH && ACCESS_REG_P (operands[0])
1522 && !dead_or_set_p (insn, operands[1])"
1523 [(set (match_dup 3) (match_dup 2))
1524 (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))
1525 (set (match_dup 4) (match_dup 2))
1526 (set (match_dup 1) (rotate:DI (match_dup 1) (const_int 32)))]
1527 "operands[2] = gen_lowpart (SImode, operands[1]);
1528 s390_split_access_reg (operands[0], &operands[3], &operands[4]);")
1530 (define_insn "*movdi_31"
1531 [(set (match_operand:DI 0 "nonimmediate_operand"
1532 "=d,d,Q,S,d ,o,!*f,!*f,!*f,!R,!T,d")
1533 (match_operand:DI 1 "general_operand"
1534 " Q,S,d,d,dPRT,d, *f, R, T,*f,*f,b"))]
1549 [(set_attr "op_type" "RS,RSY,RS,RSY,*,*,RR,RX,RXY,RX,RXY,*")
1550 (set_attr "type" "lm,lm,stm,stm,*,*,floaddf,floaddf,floaddf,fstoredf,fstoredf,*")
1551 (set_attr "cpu_facility" "*,*,*,*,*,*,*,*,*,*,*,z10")])
1553 ; For a load from a symbol ref we can use one of the target registers
1554 ; together with larl to load the address.
1556 [(set (match_operand:DI 0 "register_operand" "")
1557 (match_operand:DI 1 "memory_operand" ""))]
1558 "!TARGET_ZARCH && reload_completed && TARGET_Z10
1559 && larl_operand (XEXP (operands[1], 0), SImode)"
1560 [(set (match_dup 2) (match_dup 3))
1561 (set (match_dup 0) (match_dup 1))]
1563 operands[2] = operand_subword (operands[0], 1, 0, DImode);
1564 operands[3] = XEXP (operands[1], 0);
1565 operands[1] = replace_equiv_address (operands[1], operands[2]);
1569 [(set (match_operand:DI 0 "nonimmediate_operand" "")
1570 (match_operand:DI 1 "general_operand" ""))]
1571 "!TARGET_ZARCH && reload_completed
1572 && s390_split_ok_p (operands[0], operands[1], DImode, 0)"
1573 [(set (match_dup 2) (match_dup 4))
1574 (set (match_dup 3) (match_dup 5))]
1576 operands[2] = operand_subword (operands[0], 0, 0, DImode);
1577 operands[3] = operand_subword (operands[0], 1, 0, DImode);
1578 operands[4] = operand_subword (operands[1], 0, 0, DImode);
1579 operands[5] = operand_subword (operands[1], 1, 0, DImode);
1583 [(set (match_operand:DI 0 "nonimmediate_operand" "")
1584 (match_operand:DI 1 "general_operand" ""))]
1585 "!TARGET_ZARCH && reload_completed
1586 && s390_split_ok_p (operands[0], operands[1], DImode, 1)"
1587 [(set (match_dup 2) (match_dup 4))
1588 (set (match_dup 3) (match_dup 5))]
1590 operands[2] = operand_subword (operands[0], 1, 0, DImode);
1591 operands[3] = operand_subword (operands[0], 0, 0, DImode);
1592 operands[4] = operand_subword (operands[1], 1, 0, DImode);
1593 operands[5] = operand_subword (operands[1], 0, 0, DImode);
1597 [(set (match_operand:DI 0 "register_operand" "")
1598 (match_operand:DI 1 "memory_operand" ""))]
1599 "!TARGET_ZARCH && reload_completed
1600 && !FP_REG_P (operands[0])
1601 && !s_operand (operands[1], VOIDmode)"
1602 [(set (match_dup 0) (match_dup 1))]
1604 rtx addr = operand_subword (operands[0], 1, 0, DImode);
1605 s390_load_address (addr, XEXP (operands[1], 0));
1606 operands[1] = replace_equiv_address (operands[1], addr);
1610 [(set (match_operand:DI 0 "register_operand" "")
1611 (mem:DI (match_operand 1 "address_operand" "")))]
1613 && !FP_REG_P (operands[0])
1614 && GET_CODE (operands[1]) == SYMBOL_REF
1615 && CONSTANT_POOL_ADDRESS_P (operands[1])
1616 && get_pool_mode (operands[1]) == DImode
1617 && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
1618 [(set (match_dup 0) (match_dup 2))]
1619 "operands[2] = get_pool_constant (operands[1]);")
1621 (define_insn "*la_64"
1622 [(set (match_operand:DI 0 "register_operand" "=d,d")
1623 (match_operand:QI 1 "address_operand" "ZQZR,ZSZT"))]
1628 [(set_attr "op_type" "RX,RXY")
1629 (set_attr "type" "la")
1630 (set_attr "z10prop" "z10_fwd_A1,z10_fwd_A1")])
1634 [(set (match_operand:DI 0 "register_operand" "")
1635 (match_operand:QI 1 "address_operand" ""))
1636 (clobber (reg:CC CC_REGNUM))])]
1638 && preferred_la_operand_p (operands[1], const0_rtx)"
1639 [(set (match_dup 0) (match_dup 1))]
1643 [(set (match_operand:DI 0 "register_operand" "")
1644 (match_operand:DI 1 "register_operand" ""))
1647 (plus:DI (match_dup 0)
1648 (match_operand:DI 2 "nonmemory_operand" "")))
1649 (clobber (reg:CC CC_REGNUM))])]
1651 && !reg_overlap_mentioned_p (operands[0], operands[2])
1652 && preferred_la_operand_p (operands[1], operands[2])"
1653 [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))]
1657 ; movsi instruction pattern(s).
1660 (define_expand "movsi"
1661 [(set (match_operand:SI 0 "general_operand" "")
1662 (match_operand:SI 1 "general_operand" ""))]
1665 /* Handle symbolic constants. */
1667 && (SYMBOLIC_CONST (operands[1])
1668 || (GET_CODE (operands[1]) == PLUS
1669 && XEXP (operands[1], 0) == pic_offset_table_rtx
1670 && SYMBOLIC_CONST (XEXP(operands[1], 1)))))
1671 emit_symbolic_move (operands);
1674 (define_insn "*movsi_larl"
1675 [(set (match_operand:SI 0 "register_operand" "=d")
1676 (match_operand:SI 1 "larl_operand" "X"))]
1677 "!TARGET_64BIT && TARGET_CPU_ZARCH
1678 && !FP_REG_P (operands[0])"
1680 [(set_attr "op_type" "RIL")
1681 (set_attr "type" "larl")
1682 (set_attr "z10prop" "z10_fwd_A1")])
1684 (define_insn "*movsi_zarch"
1685 [(set (match_operand:SI 0 "nonimmediate_operand"
1686 "=d,d,d,d,d,d,d,d,d,R,T,!*f,!*f,!*f,!R,!T,d,t,Q,b,Q,t")
1687 (match_operand:SI 1 "general_operand"
1688 "K,N0HS0,N1HS0,Os,L,b,d,R,T,d,d,*f,R,T,*f,*f,t,d,t,d,K,Q"))]
1713 [(set_attr "op_type" "RI,RI,RI,RIL,RXY,RIL,RR,RX,RXY,RX,RXY,
1714 RR,RX,RXY,RX,RXY,RRE,RRE,RS,RIL,SIL,RS")
1715 (set_attr "type" "*,
1737 (set_attr "cpu_facility" "*,*,*,extimm,longdisp,z10,*,*,longdisp,*,longdisp,
1738 *,*,longdisp,*,longdisp,*,*,*,z10,z10,*")
1739 (set_attr "z10prop" "z10_fwd_A1,
1762 (define_insn "*movsi_esa"
1763 [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,R,!*f,!*f,!R,d,t,Q,t")
1764 (match_operand:SI 1 "general_operand" "K,d,R,d,*f,R,*f,t,d,t,Q"))]
1778 [(set_attr "op_type" "RI,RR,RX,RX,RR,RX,RX,RRE,RRE,RS,RS")
1779 (set_attr "type" "*,lr,load,store,floadsf,floadsf,fstoresf,*,*,*,*")
1780 (set_attr "z10prop" "z10_fwd_A1,
1794 [(set (match_operand:SI 0 "register_operand" "")
1795 (mem:SI (match_operand 1 "address_operand" "")))]
1796 "!FP_REG_P (operands[0])
1797 && GET_CODE (operands[1]) == SYMBOL_REF
1798 && CONSTANT_POOL_ADDRESS_P (operands[1])
1799 && get_pool_mode (operands[1]) == SImode
1800 && legitimate_reload_constant_p (get_pool_constant (operands[1]))"
1801 [(set (match_dup 0) (match_dup 2))]
1802 "operands[2] = get_pool_constant (operands[1]);")
1804 (define_insn "*la_31"
1805 [(set (match_operand:SI 0 "register_operand" "=d,d")
1806 (match_operand:QI 1 "address_operand" "ZQZR,ZSZT"))]
1807 "!TARGET_64BIT && legitimate_la_operand_p (operands[1])"
1811 [(set_attr "op_type" "RX,RXY")
1812 (set_attr "type" "la")
1813 (set_attr "z10prop" "z10_fwd_A1,z10_fwd_A1")])
1817 [(set (match_operand:SI 0 "register_operand" "")
1818 (match_operand:QI 1 "address_operand" ""))
1819 (clobber (reg:CC CC_REGNUM))])]
1821 && preferred_la_operand_p (operands[1], const0_rtx)"
1822 [(set (match_dup 0) (match_dup 1))]
1826 [(set (match_operand:SI 0 "register_operand" "")
1827 (match_operand:SI 1 "register_operand" ""))
1830 (plus:SI (match_dup 0)
1831 (match_operand:SI 2 "nonmemory_operand" "")))
1832 (clobber (reg:CC CC_REGNUM))])]
1834 && !reg_overlap_mentioned_p (operands[0], operands[2])
1835 && preferred_la_operand_p (operands[1], operands[2])"
1836 [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))]
1839 (define_insn "*la_31_and"
1840 [(set (match_operand:SI 0 "register_operand" "=d,d")
1841 (and:SI (match_operand:QI 1 "address_operand" "ZQZR,ZSZT")
1842 (const_int 2147483647)))]
1847 [(set_attr "op_type" "RX,RXY")
1848 (set_attr "type" "la")
1849 (set_attr "z10prop" "z10_fwd_A1,z10_fwd_A1")])
1851 (define_insn_and_split "*la_31_and_cc"
1852 [(set (match_operand:SI 0 "register_operand" "=d")
1853 (and:SI (match_operand:QI 1 "address_operand" "p")
1854 (const_int 2147483647)))
1855 (clobber (reg:CC CC_REGNUM))]
1858 "&& reload_completed"
1860 (and:SI (match_dup 1) (const_int 2147483647)))]
1862 [(set_attr "op_type" "RX")
1863 (set_attr "type" "la")])
1865 (define_insn "force_la_31"
1866 [(set (match_operand:SI 0 "register_operand" "=d,d")
1867 (match_operand:QI 1 "address_operand" "ZQZR,ZSZT"))
1868 (use (const_int 0))]
1873 [(set_attr "op_type" "RX")
1874 (set_attr "type" "la")
1875 (set_attr "z10prop" "z10_fwd_A1,z10_fwd_A1")])
1878 ; movhi instruction pattern(s).
1881 (define_expand "movhi"
1882 [(set (match_operand:HI 0 "nonimmediate_operand" "")
1883 (match_operand:HI 1 "general_operand" ""))]
1886 /* Make it explicit that loading a register from memory
1887 always sign-extends (at least) to SImode. */
1888 if (optimize && can_create_pseudo_p ()
1889 && register_operand (operands[0], VOIDmode)
1890 && GET_CODE (operands[1]) == MEM)
1892 rtx tmp = gen_reg_rtx (SImode);
1893 rtx ext = gen_rtx_SIGN_EXTEND (SImode, operands[1]);
1894 emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1895 operands[1] = gen_lowpart (HImode, tmp);
1899 (define_insn "*movhi"
1900 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d,d,d,R,T,b,Q")
1901 (match_operand:HI 1 "general_operand" " d,n,R,T,b,d,d,d,K"))]
1913 [(set_attr "op_type" "RR,RI,RX,RXY,RIL,RX,RXY,RIL,SIL")
1914 (set_attr "type" "lr,*,*,*,larl,store,store,store,*")
1915 (set_attr "cpu_facility" "*,*,*,*,z10,*,*,z10,z10")
1916 (set_attr "z10prop" "z10_fr_E1,
1927 [(set (match_operand:HI 0 "register_operand" "")
1928 (mem:HI (match_operand 1 "address_operand" "")))]
1929 "GET_CODE (operands[1]) == SYMBOL_REF
1930 && CONSTANT_POOL_ADDRESS_P (operands[1])
1931 && get_pool_mode (operands[1]) == HImode
1932 && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1933 [(set (match_dup 0) (match_dup 2))]
1934 "operands[2] = get_pool_constant (operands[1]);")
1937 ; movqi instruction pattern(s).
1940 (define_expand "movqi"
1941 [(set (match_operand:QI 0 "nonimmediate_operand" "")
1942 (match_operand:QI 1 "general_operand" ""))]
1945 /* On z/Architecture, zero-extending from memory to register
1946 is just as fast as a QImode load. */
1947 if (TARGET_ZARCH && optimize && can_create_pseudo_p ()
1948 && register_operand (operands[0], VOIDmode)
1949 && GET_CODE (operands[1]) == MEM)
1951 rtx tmp = gen_reg_rtx (DImode);
1952 rtx ext = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
1953 emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
1954 operands[1] = gen_lowpart (QImode, tmp);
1958 (define_insn "*movqi"
1959 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,d,R,T,Q,S,?Q")
1960 (match_operand:QI 1 "general_operand" " d,n,R,T,d,d,n,n,?Q"))]
1972 [(set_attr "op_type" "RR,RI,RX,RXY,RX,RXY,SI,SIY,SS")
1973 (set_attr "type" "lr,*,*,*,store,store,store,store,*")
1974 (set_attr "z10prop" "z10_fr_E1,
1985 [(set (match_operand:QI 0 "nonimmediate_operand" "")
1986 (mem:QI (match_operand 1 "address_operand" "")))]
1987 "GET_CODE (operands[1]) == SYMBOL_REF
1988 && CONSTANT_POOL_ADDRESS_P (operands[1])
1989 && get_pool_mode (operands[1]) == QImode
1990 && GET_CODE (get_pool_constant (operands[1])) == CONST_INT"
1991 [(set (match_dup 0) (match_dup 2))]
1992 "operands[2] = get_pool_constant (operands[1]);")
1995 ; movstrictqi instruction pattern(s).
1998 (define_insn "*movstrictqi"
1999 [(set (strict_low_part (match_operand:QI 0 "register_operand" "+d,d"))
2000 (match_operand:QI 1 "memory_operand" "R,T"))]
2005 [(set_attr "op_type" "RX,RXY")
2006 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
2009 ; movstricthi instruction pattern(s).
2012 (define_insn "*movstricthi"
2013 [(set (strict_low_part (match_operand:HI 0 "register_operand" "+d,d"))
2014 (match_operand:HI 1 "memory_operand" "Q,S"))
2015 (clobber (reg:CC CC_REGNUM))]
2020 [(set_attr "op_type" "RS,RSY")
2021 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
2024 ; movstrictsi instruction pattern(s).
2027 (define_insn "movstrictsi"
2028 [(set (strict_low_part (match_operand:SI 0 "register_operand" "+d,d,d,d"))
2029 (match_operand:SI 1 "general_operand" "d,R,T,t"))]
2036 [(set_attr "op_type" "RR,RX,RXY,RRE")
2037 (set_attr "type" "lr,load,load,*")
2038 (set_attr "z10prop" "z10_fr_E1,z10_fwd_A3,z10_fwd_A3,z10_super_E1")])
2041 ; mov(tf|td) instruction pattern(s).
2044 (define_expand "mov<mode>"
2045 [(set (match_operand:TD_TF 0 "nonimmediate_operand" "")
2046 (match_operand:TD_TF 1 "general_operand" ""))]
2050 (define_insn "*mov<mode>_64"
2051 [(set (match_operand:TD_TF 0 "nonimmediate_operand" "=f,f,f,o, d,QS, d,o")
2052 (match_operand:TD_TF 1 "general_operand" " G,f,o,f,QS, d,dRT,d"))]
2063 [(set_attr "op_type" "RRE,RRE,*,*,RSY,RSY,*,*")
2064 (set_attr "type" "fsimptf,fsimptf,*,*,lm,stm,*,*")
2065 (set_attr "cpu_facility" "z196,*,*,*,*,*,*,*")])
2067 (define_insn "*mov<mode>_31"
2068 [(set (match_operand:TD_TF 0 "nonimmediate_operand" "=f,f,f,o")
2069 (match_operand:TD_TF 1 "general_operand" " G,f,o,f"))]
2076 [(set_attr "op_type" "RRE,RRE,*,*")
2077 (set_attr "type" "fsimptf,fsimptf,*,*")
2078 (set_attr "cpu_facility" "z196,*,*,*")])
2080 ; TFmode in GPRs splitters
2083 [(set (match_operand:TD_TF 0 "nonimmediate_operand" "")
2084 (match_operand:TD_TF 1 "general_operand" ""))]
2085 "TARGET_ZARCH && reload_completed
2086 && s390_split_ok_p (operands[0], operands[1], <MODE>mode, 0)"
2087 [(set (match_dup 2) (match_dup 4))
2088 (set (match_dup 3) (match_dup 5))]
2090 operands[2] = operand_subword (operands[0], 0, 0, <MODE>mode);
2091 operands[3] = operand_subword (operands[0], 1, 0, <MODE>mode);
2092 operands[4] = operand_subword (operands[1], 0, 0, <MODE>mode);
2093 operands[5] = operand_subword (operands[1], 1, 0, <MODE>mode);
2097 [(set (match_operand:TD_TF 0 "nonimmediate_operand" "")
2098 (match_operand:TD_TF 1 "general_operand" ""))]
2099 "TARGET_ZARCH && reload_completed
2100 && s390_split_ok_p (operands[0], operands[1], <MODE>mode, 1)"
2101 [(set (match_dup 2) (match_dup 4))
2102 (set (match_dup 3) (match_dup 5))]
2104 operands[2] = operand_subword (operands[0], 1, 0, <MODE>mode);
2105 operands[3] = operand_subword (operands[0], 0, 0, <MODE>mode);
2106 operands[4] = operand_subword (operands[1], 1, 0, <MODE>mode);
2107 operands[5] = operand_subword (operands[1], 0, 0, <MODE>mode);
2111 [(set (match_operand:TD_TF 0 "register_operand" "")
2112 (match_operand:TD_TF 1 "memory_operand" ""))]
2113 "TARGET_ZARCH && reload_completed
2114 && !FP_REG_P (operands[0])
2115 && !s_operand (operands[1], VOIDmode)"
2116 [(set (match_dup 0) (match_dup 1))]
2118 rtx addr = operand_subword (operands[0], 1, 0, <MODE>mode);
2119 addr = gen_lowpart (Pmode, addr);
2120 s390_load_address (addr, XEXP (operands[1], 0));
2121 operands[1] = replace_equiv_address (operands[1], addr);
2124 ; TFmode in BFPs splitters
2127 [(set (match_operand:TD_TF 0 "register_operand" "")
2128 (match_operand:TD_TF 1 "memory_operand" ""))]
2129 "reload_completed && offsettable_memref_p (operands[1])
2130 && FP_REG_P (operands[0])"
2131 [(set (match_dup 2) (match_dup 4))
2132 (set (match_dup 3) (match_dup 5))]
2134 operands[2] = simplify_gen_subreg (<HALF_TMODE>mode, operands[0],
2136 operands[3] = simplify_gen_subreg (<HALF_TMODE>mode, operands[0],
2138 operands[4] = adjust_address_nv (operands[1], <HALF_TMODE>mode, 0);
2139 operands[5] = adjust_address_nv (operands[1], <HALF_TMODE>mode, 8);
2143 [(set (match_operand:TD_TF 0 "memory_operand" "")
2144 (match_operand:TD_TF 1 "register_operand" ""))]
2145 "reload_completed && offsettable_memref_p (operands[0])
2146 && FP_REG_P (operands[1])"
2147 [(set (match_dup 2) (match_dup 4))
2148 (set (match_dup 3) (match_dup 5))]
2150 operands[2] = adjust_address_nv (operands[0], <HALF_TMODE>mode, 0);
2151 operands[3] = adjust_address_nv (operands[0], <HALF_TMODE>mode, 8);
2152 operands[4] = simplify_gen_subreg (<HALF_TMODE>mode, operands[1],
2154 operands[5] = simplify_gen_subreg (<HALF_TMODE>mode, operands[1],
2159 ; mov(df|dd) instruction pattern(s).
2162 (define_expand "mov<mode>"
2163 [(set (match_operand:DD_DF 0 "nonimmediate_operand" "")
2164 (match_operand:DD_DF 1 "general_operand" ""))]
2168 (define_insn "*mov<mode>_64dfp"
2169 [(set (match_operand:DD_DF 0 "nonimmediate_operand"
2170 "=f,f,f,d,f,f,R,T,d,d, d,RT")
2171 (match_operand:DD_DF 1 "general_operand"
2172 " G,f,d,f,R,T,f,f,G,d,RT, d"))]
2187 [(set_attr "op_type" "RRE,RR,RRE,RRE,RX,RXY,RX,RXY,RI,RRE,RXY,RXY")
2188 (set_attr "type" "fsimpdf,floaddf,floaddf,floaddf,floaddf,floaddf,
2189 fstoredf,fstoredf,*,lr,load,store")
2190 (set_attr "z10prop" "*,*,*,*,*,*,*,*,z10_fwd_A1,z10_fr_E1,z10_fwd_A3,z10_rec")
2191 (set_attr "cpu_facility" "z196,*,*,*,*,*,*,*,*,*,*,*")])
2193 (define_insn "*mov<mode>_64"
2194 [(set (match_operand:DD_DF 0 "nonimmediate_operand" "=f,f,f,f,R,T,d,d, d,RT")
2195 (match_operand:DD_DF 1 "general_operand" " G,f,R,T,f,f,G,d,RT, d"))]
2208 [(set_attr "op_type" "RRE,RR,RX,RXY,RX,RXY,RI,RRE,RXY,RXY")
2209 (set_attr "type" "fsimpdf,fload<mode>,fload<mode>,fload<mode>,
2210 fstore<mode>,fstore<mode>,*,lr,load,store")
2211 (set_attr "z10prop" "*,*,*,*,*,*,z10_fwd_A1,z10_fr_E1,z10_fwd_A3,z10_rec")
2212 (set_attr "cpu_facility" "z196,*,*,*,*,*,*,*,*,*")])
2214 (define_insn "*mov<mode>_31"
2215 [(set (match_operand:DD_DF 0 "nonimmediate_operand"
2216 "=f,f,f,f,R,T,d,d,Q,S, d,o")
2217 (match_operand:DD_DF 1 "general_operand"
2218 " G,f,R,T,f,f,Q,S,d,d,dPRT,d"))]
2233 [(set_attr "op_type" "RRE,RR,RX,RXY,RX,RXY,RS,RSY,RS,RSY,*,*")
2234 (set_attr "type" "fsimpdf,fload<mode>,fload<mode>,fload<mode>,
2235 fstore<mode>,fstore<mode>,lm,lm,stm,stm,*,*")
2236 (set_attr "cpu_facility" "z196,*,*,*,*,*,*,*,*,*,*,*")])
2239 [(set (match_operand:DD_DF 0 "nonimmediate_operand" "")
2240 (match_operand:DD_DF 1 "general_operand" ""))]
2241 "!TARGET_ZARCH && reload_completed
2242 && s390_split_ok_p (operands[0], operands[1], <MODE>mode, 0)"
2243 [(set (match_dup 2) (match_dup 4))
2244 (set (match_dup 3) (match_dup 5))]
2246 operands[2] = operand_subword (operands[0], 0, 0, <MODE>mode);
2247 operands[3] = operand_subword (operands[0], 1, 0, <MODE>mode);
2248 operands[4] = operand_subword (operands[1], 0, 0, <MODE>mode);
2249 operands[5] = operand_subword (operands[1], 1, 0, <MODE>mode);
2253 [(set (match_operand:DD_DF 0 "nonimmediate_operand" "")
2254 (match_operand:DD_DF 1 "general_operand" ""))]
2255 "!TARGET_ZARCH && reload_completed
2256 && s390_split_ok_p (operands[0], operands[1], <MODE>mode, 1)"
2257 [(set (match_dup 2) (match_dup 4))
2258 (set (match_dup 3) (match_dup 5))]
2260 operands[2] = operand_subword (operands[0], 1, 0, <MODE>mode);
2261 operands[3] = operand_subword (operands[0], 0, 0, <MODE>mode);
2262 operands[4] = operand_subword (operands[1], 1, 0, <MODE>mode);
2263 operands[5] = operand_subword (operands[1], 0, 0, <MODE>mode);
2267 [(set (match_operand:DD_DF 0 "register_operand" "")
2268 (match_operand:DD_DF 1 "memory_operand" ""))]
2269 "!TARGET_ZARCH && reload_completed
2270 && !FP_REG_P (operands[0])
2271 && !s_operand (operands[1], VOIDmode)"
2272 [(set (match_dup 0) (match_dup 1))]
2274 rtx addr = operand_subword (operands[0], 1, 0, <MODE>mode);
2275 s390_load_address (addr, XEXP (operands[1], 0));
2276 operands[1] = replace_equiv_address (operands[1], addr);
2280 ; mov(sf|sd) instruction pattern(s).
2283 (define_insn "mov<mode>"
2284 [(set (match_operand:SD_SF 0 "nonimmediate_operand"
2285 "=f,f,f,f,R,T,d,d,d,d,R,T")
2286 (match_operand:SD_SF 1 "general_operand"
2287 " G,f,R,T,f,f,G,d,R,T,d,d"))]
2302 [(set_attr "op_type" "RRE,RR,RX,RXY,RX,RXY,RI,RR,RX,RXY,RX,RXY")
2303 (set_attr "type" "fsimpsf,fload<mode>,fload<mode>,fload<mode>,
2304 fstore<mode>,fstore<mode>,*,lr,load,load,store,store")
2305 (set_attr "z10prop" "*,*,*,*,*,*,z10_fwd_A1,z10_fr_E1,z10_fwd_A3,z10_fwd_A3,z10_rec,z10_rec")
2306 (set_attr "cpu_facility" "z196,*,*,*,*,*,*,*,*,*,*,*")])
2309 ; movcc instruction pattern
2312 (define_insn "movcc"
2313 [(set (match_operand:CC 0 "nonimmediate_operand" "=d,c,d,d,d,R,T")
2314 (match_operand:CC 1 "nonimmediate_operand" " d,d,c,R,T,d,d"))]
2324 [(set_attr "op_type" "RR,RI,RRE,RX,RXY,RX,RXY")
2325 (set_attr "type" "lr,*,*,load,load,store,store")
2326 (set_attr "z10prop" "z10_fr_E1,z10_super,*,z10_fwd_A3,z10_fwd_A3,z10_rec,z10_rec")
2327 (set_attr "z196prop" "*,*,z196_ends,*,*,*,*")])
2330 ; Block move (MVC) patterns.
2334 [(set (match_operand:BLK 0 "memory_operand" "=Q")
2335 (match_operand:BLK 1 "memory_operand" "Q"))
2336 (use (match_operand 2 "const_int_operand" "n"))]
2337 "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
2338 "mvc\t%O0(%2,%R0),%S1"
2339 [(set_attr "op_type" "SS")])
2341 ; This splitter converts a QI to QI mode copy into a BLK mode copy in
2342 ; order to have it implemented with mvc.
2345 [(set (match_operand:QI 0 "memory_operand" "")
2346 (match_operand:QI 1 "memory_operand" ""))]
2349 [(set (match_dup 0) (match_dup 1))
2350 (use (const_int 1))])]
2352 operands[0] = adjust_address (operands[0], BLKmode, 0);
2353 operands[1] = adjust_address (operands[1], BLKmode, 0);
2359 [(set (match_operand:BLK 0 "memory_operand" "")
2360 (match_operand:BLK 1 "memory_operand" ""))
2361 (use (match_operand 2 "const_int_operand" ""))])
2363 [(set (match_operand:BLK 3 "memory_operand" "")
2364 (match_operand:BLK 4 "memory_operand" ""))
2365 (use (match_operand 5 "const_int_operand" ""))])]
2366 "s390_offset_p (operands[0], operands[3], operands[2])
2367 && s390_offset_p (operands[1], operands[4], operands[2])
2368 && !s390_overlap_p (operands[0], operands[1],
2369 INTVAL (operands[2]) + INTVAL (operands[5]))
2370 && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
2372 [(set (match_dup 6) (match_dup 7))
2373 (use (match_dup 8))])]
2374 "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
2375 operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
2376 operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
2380 ; load_multiple pattern(s).
2382 ; ??? Due to reload problems with replacing registers inside match_parallel
2383 ; we currently support load_multiple/store_multiple only after reload.
2386 (define_expand "load_multiple"
2387 [(match_par_dup 3 [(set (match_operand 0 "" "")
2388 (match_operand 1 "" ""))
2389 (use (match_operand 2 "" ""))])]
2392 enum machine_mode mode;
2398 /* Support only loading a constant number of fixed-point registers from
2399 memory and only bother with this if more than two */
2400 if (GET_CODE (operands[2]) != CONST_INT
2401 || INTVAL (operands[2]) < 2
2402 || INTVAL (operands[2]) > 16
2403 || GET_CODE (operands[1]) != MEM
2404 || GET_CODE (operands[0]) != REG
2405 || REGNO (operands[0]) >= 16)
2408 count = INTVAL (operands[2]);
2409 regno = REGNO (operands[0]);
2410 mode = GET_MODE (operands[0]);
2411 if (mode != SImode && (!TARGET_ZARCH || mode != DImode))
2414 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
2415 if (!can_create_pseudo_p ())
2417 if (GET_CODE (XEXP (operands[1], 0)) == REG)
2419 from = XEXP (operands[1], 0);
2422 else if (GET_CODE (XEXP (operands[1], 0)) == PLUS
2423 && GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == REG
2424 && GET_CODE (XEXP (XEXP (operands[1], 0), 1)) == CONST_INT)
2426 from = XEXP (XEXP (operands[1], 0), 0);
2427 off = INTVAL (XEXP (XEXP (operands[1], 0), 1));
2434 from = force_reg (Pmode, XEXP (operands[1], 0));
2438 for (i = 0; i < count; i++)
2439 XVECEXP (operands[3], 0, i)
2440 = gen_rtx_SET (VOIDmode, gen_rtx_REG (mode, regno + i),
2441 change_address (operands[1], mode,
2442 plus_constant (Pmode, from,
2443 off + i * GET_MODE_SIZE (mode))));
2446 (define_insn "*load_multiple_di"
2447 [(match_parallel 0 "load_multiple_operation"
2448 [(set (match_operand:DI 1 "register_operand" "=r")
2449 (match_operand:DI 2 "s_operand" "QS"))])]
2450 "reload_completed && TARGET_ZARCH"
2452 int words = XVECLEN (operands[0], 0);
2453 operands[0] = gen_rtx_REG (DImode, REGNO (operands[1]) + words - 1);
2454 return "lmg\t%1,%0,%S2";
2456 [(set_attr "op_type" "RSY")
2457 (set_attr "type" "lm")])
2459 (define_insn "*load_multiple_si"
2460 [(match_parallel 0 "load_multiple_operation"
2461 [(set (match_operand:SI 1 "register_operand" "=r,r")
2462 (match_operand:SI 2 "s_operand" "Q,S"))])]
2465 int words = XVECLEN (operands[0], 0);
2466 operands[0] = gen_rtx_REG (SImode, REGNO (operands[1]) + words - 1);
2467 return which_alternative == 0 ? "lm\t%1,%0,%S2" : "lmy\t%1,%0,%S2";
2469 [(set_attr "op_type" "RS,RSY")
2470 (set_attr "type" "lm")])
2473 ; store multiple pattern(s).
2476 (define_expand "store_multiple"
2477 [(match_par_dup 3 [(set (match_operand 0 "" "")
2478 (match_operand 1 "" ""))
2479 (use (match_operand 2 "" ""))])]
2482 enum machine_mode mode;
2488 /* Support only storing a constant number of fixed-point registers to
2489 memory and only bother with this if more than two. */
2490 if (GET_CODE (operands[2]) != CONST_INT
2491 || INTVAL (operands[2]) < 2
2492 || INTVAL (operands[2]) > 16
2493 || GET_CODE (operands[0]) != MEM
2494 || GET_CODE (operands[1]) != REG
2495 || REGNO (operands[1]) >= 16)
2498 count = INTVAL (operands[2]);
2499 regno = REGNO (operands[1]);
2500 mode = GET_MODE (operands[1]);
2501 if (mode != SImode && (!TARGET_ZARCH || mode != DImode))
2504 operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
2506 if (!can_create_pseudo_p ())
2508 if (GET_CODE (XEXP (operands[0], 0)) == REG)
2510 to = XEXP (operands[0], 0);
2513 else if (GET_CODE (XEXP (operands[0], 0)) == PLUS
2514 && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
2515 && GET_CODE (XEXP (XEXP (operands[0], 0), 1)) == CONST_INT)
2517 to = XEXP (XEXP (operands[0], 0), 0);
2518 off = INTVAL (XEXP (XEXP (operands[0], 0), 1));
2525 to = force_reg (Pmode, XEXP (operands[0], 0));
2529 for (i = 0; i < count; i++)
2530 XVECEXP (operands[3], 0, i)
2531 = gen_rtx_SET (VOIDmode,
2532 change_address (operands[0], mode,
2533 plus_constant (Pmode, to,
2534 off + i * GET_MODE_SIZE (mode))),
2535 gen_rtx_REG (mode, regno + i));
2538 (define_insn "*store_multiple_di"
2539 [(match_parallel 0 "store_multiple_operation"
2540 [(set (match_operand:DI 1 "s_operand" "=QS")
2541 (match_operand:DI 2 "register_operand" "r"))])]
2542 "reload_completed && TARGET_ZARCH"
2544 int words = XVECLEN (operands[0], 0);
2545 operands[0] = gen_rtx_REG (DImode, REGNO (operands[2]) + words - 1);
2546 return "stmg\t%2,%0,%S1";
2548 [(set_attr "op_type" "RSY")
2549 (set_attr "type" "stm")])
2552 (define_insn "*store_multiple_si"
2553 [(match_parallel 0 "store_multiple_operation"
2554 [(set (match_operand:SI 1 "s_operand" "=Q,S")
2555 (match_operand:SI 2 "register_operand" "r,r"))])]
2558 int words = XVECLEN (operands[0], 0);
2559 operands[0] = gen_rtx_REG (SImode, REGNO (operands[2]) + words - 1);
2560 return which_alternative == 0 ? "stm\t%2,%0,%S1" : "stmy\t%2,%0,%S1";
2562 [(set_attr "op_type" "RS,RSY")
2563 (set_attr "type" "stm")])
2566 ;; String instructions.
2569 (define_insn "*execute_rl"
2570 [(match_parallel 0 "execute_operation"
2571 [(unspec [(match_operand 1 "register_operand" "a")
2572 (match_operand 2 "" "")
2573 (match_operand:SI 3 "larl_operand" "X")] UNSPEC_EXECUTE)])]
2574 "TARGET_Z10 && GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
2575 && GET_MODE_SIZE (GET_MODE (operands[1])) <= UNITS_PER_WORD"
2577 [(set_attr "op_type" "RIL")
2578 (set_attr "type" "cs")])
2580 (define_insn "*execute"
2581 [(match_parallel 0 "execute_operation"
2582 [(unspec [(match_operand 1 "register_operand" "a")
2583 (match_operand:BLK 2 "memory_operand" "R")
2584 (match_operand 3 "" "")] UNSPEC_EXECUTE)])]
2585 "GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
2586 && GET_MODE_SIZE (GET_MODE (operands[1])) <= UNITS_PER_WORD"
2588 [(set_attr "op_type" "RX")
2589 (set_attr "type" "cs")])
2593 ; strlenM instruction pattern(s).
2596 (define_expand "strlen<mode>"
2597 [(set (reg:SI 0) (match_operand:SI 2 "immediate_operand" ""))
2600 (unspec:P [(const_int 0)
2601 (match_operand:BLK 1 "memory_operand" "")
2603 (match_operand 3 "immediate_operand" "")] UNSPEC_SRST))
2604 (clobber (scratch:P))
2605 (clobber (reg:CC CC_REGNUM))])
2607 [(set (match_operand:P 0 "register_operand" "")
2608 (minus:P (match_dup 4) (match_dup 5)))
2609 (clobber (reg:CC CC_REGNUM))])]
2612 operands[4] = gen_reg_rtx (Pmode);
2613 operands[5] = gen_reg_rtx (Pmode);
2614 emit_move_insn (operands[5], force_operand (XEXP (operands[1], 0), NULL_RTX));
2615 operands[1] = replace_equiv_address (operands[1], operands[5]);
2618 (define_insn "*strlen<mode>"
2619 [(set (match_operand:P 0 "register_operand" "=a")
2620 (unspec:P [(match_operand:P 2 "general_operand" "0")
2621 (mem:BLK (match_operand:P 3 "register_operand" "1"))
2623 (match_operand 4 "immediate_operand" "")] UNSPEC_SRST))
2624 (clobber (match_scratch:P 1 "=a"))
2625 (clobber (reg:CC CC_REGNUM))]
2627 "srst\t%0,%1\;jo\t.-4"
2628 [(set_attr "length" "8")
2629 (set_attr "type" "vs")])
2632 ; cmpstrM instruction pattern(s).
2635 (define_expand "cmpstrsi"
2636 [(set (reg:SI 0) (const_int 0))
2638 [(clobber (match_operand 3 "" ""))
2639 (clobber (match_dup 4))
2640 (set (reg:CCU CC_REGNUM)
2641 (compare:CCU (match_operand:BLK 1 "memory_operand" "")
2642 (match_operand:BLK 2 "memory_operand" "")))
2645 [(set (match_operand:SI 0 "register_operand" "=d")
2646 (unspec:SI [(reg:CCU CC_REGNUM)] UNSPEC_STRCMPCC_TO_INT))
2647 (clobber (reg:CC CC_REGNUM))])]
2650 /* As the result of CMPINT is inverted compared to what we need,
2651 we have to swap the operands. */
2652 rtx op1 = operands[2];
2653 rtx op2 = operands[1];
2654 rtx addr1 = gen_reg_rtx (Pmode);
2655 rtx addr2 = gen_reg_rtx (Pmode);
2657 emit_move_insn (addr1, force_operand (XEXP (op1, 0), NULL_RTX));
2658 emit_move_insn (addr2, force_operand (XEXP (op2, 0), NULL_RTX));
2659 operands[1] = replace_equiv_address_nv (op1, addr1);
2660 operands[2] = replace_equiv_address_nv (op2, addr2);
2661 operands[3] = addr1;
2662 operands[4] = addr2;
2665 (define_insn "*cmpstr<mode>"
2666 [(clobber (match_operand:P 0 "register_operand" "=d"))
2667 (clobber (match_operand:P 1 "register_operand" "=d"))
2668 (set (reg:CCU CC_REGNUM)
2669 (compare:CCU (mem:BLK (match_operand:P 2 "register_operand" "0"))
2670 (mem:BLK (match_operand:P 3 "register_operand" "1"))))
2673 "clst\t%0,%1\;jo\t.-4"
2674 [(set_attr "length" "8")
2675 (set_attr "type" "vs")])
2678 ; movstr instruction pattern.
2681 (define_expand "movstr"
2682 [(set (reg:SI 0) (const_int 0))
2684 [(clobber (match_dup 3))
2685 (set (match_operand:BLK 1 "memory_operand" "")
2686 (match_operand:BLK 2 "memory_operand" ""))
2687 (set (match_operand 0 "register_operand" "")
2688 (unspec [(match_dup 1)
2690 (reg:SI 0)] UNSPEC_MVST))
2691 (clobber (reg:CC CC_REGNUM))])]
2694 rtx addr1 = gen_reg_rtx (Pmode);
2695 rtx addr2 = gen_reg_rtx (Pmode);
2697 emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
2698 emit_move_insn (addr2, force_operand (XEXP (operands[2], 0), NULL_RTX));
2699 operands[1] = replace_equiv_address_nv (operands[1], addr1);
2700 operands[2] = replace_equiv_address_nv (operands[2], addr2);
2701 operands[3] = addr2;
2704 (define_insn "*movstr"
2705 [(clobber (match_operand:P 2 "register_operand" "=d"))
2706 (set (mem:BLK (match_operand:P 1 "register_operand" "0"))
2707 (mem:BLK (match_operand:P 3 "register_operand" "2")))
2708 (set (match_operand:P 0 "register_operand" "=d")
2709 (unspec [(mem:BLK (match_dup 1))
2710 (mem:BLK (match_dup 3))
2711 (reg:SI 0)] UNSPEC_MVST))
2712 (clobber (reg:CC CC_REGNUM))]
2714 "mvst\t%1,%2\;jo\t.-4"
2715 [(set_attr "length" "8")
2716 (set_attr "type" "vs")])
2720 ; movmemM instruction pattern(s).
2723 (define_expand "movmem<mode>"
2724 [(set (match_operand:BLK 0 "memory_operand" "") ; destination
2725 (match_operand:BLK 1 "memory_operand" "")) ; source
2726 (use (match_operand:GPR 2 "general_operand" "")) ; count
2727 (match_operand 3 "" "")]
2730 if (s390_expand_movmem (operands[0], operands[1], operands[2]))
2736 ; Move a block that is up to 256 bytes in length.
2737 ; The block length is taken as (operands[2] % 256) + 1.
2739 (define_expand "movmem_short"
2741 [(set (match_operand:BLK 0 "memory_operand" "")
2742 (match_operand:BLK 1 "memory_operand" ""))
2743 (use (match_operand 2 "nonmemory_operand" ""))
2744 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2745 (clobber (match_dup 3))])]
2747 "operands[3] = gen_rtx_SCRATCH (Pmode);")
2749 (define_insn "*movmem_short"
2750 [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q,Q")
2751 (match_operand:BLK 1 "memory_operand" "Q,Q,Q,Q"))
2752 (use (match_operand 2 "nonmemory_operand" "n,a,a,a"))
2753 (use (match_operand 3 "immediate_operand" "X,R,X,X"))
2754 (clobber (match_scratch:P 4 "=X,X,X,&a"))]
2755 "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)"
2757 [(set_attr "type" "cs")
2758 (set_attr "cpu_facility" "*,*,z10,cpu_zarch")])
2761 [(set (match_operand:BLK 0 "memory_operand" "")
2762 (match_operand:BLK 1 "memory_operand" ""))
2763 (use (match_operand 2 "const_int_operand" ""))
2764 (use (match_operand 3 "immediate_operand" ""))
2765 (clobber (scratch))]
2768 [(set (match_dup 0) (match_dup 1))
2769 (use (match_dup 2))])]
2770 "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
2773 [(set (match_operand:BLK 0 "memory_operand" "")
2774 (match_operand:BLK 1 "memory_operand" ""))
2775 (use (match_operand 2 "register_operand" ""))
2776 (use (match_operand 3 "memory_operand" ""))
2777 (clobber (scratch))]
2780 [(unspec [(match_dup 2) (match_dup 3)
2781 (const_int 0)] UNSPEC_EXECUTE)
2782 (set (match_dup 0) (match_dup 1))
2783 (use (const_int 1))])]
2787 [(set (match_operand:BLK 0 "memory_operand" "")
2788 (match_operand:BLK 1 "memory_operand" ""))
2789 (use (match_operand 2 "register_operand" ""))
2790 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2791 (clobber (scratch))]
2792 "TARGET_Z10 && reload_completed"
2794 [(unspec [(match_dup 2) (const_int 0)
2795 (label_ref (match_dup 3))] UNSPEC_EXECUTE)
2796 (set (match_dup 0) (match_dup 1))
2797 (use (const_int 1))])]
2798 "operands[3] = gen_label_rtx ();")
2801 [(set (match_operand:BLK 0 "memory_operand" "")
2802 (match_operand:BLK 1 "memory_operand" ""))
2803 (use (match_operand 2 "register_operand" ""))
2804 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2805 (clobber (match_operand 3 "register_operand" ""))]
2806 "reload_completed && TARGET_CPU_ZARCH"
2807 [(set (match_dup 3) (label_ref (match_dup 4)))
2809 [(unspec [(match_dup 2) (mem:BLK (match_dup 3))
2810 (label_ref (match_dup 4))] UNSPEC_EXECUTE)
2811 (set (match_dup 0) (match_dup 1))
2812 (use (const_int 1))])]
2813 "operands[4] = gen_label_rtx ();")
2815 ; Move a block of arbitrary length.
2817 (define_expand "movmem_long"
2819 [(clobber (match_dup 2))
2820 (clobber (match_dup 3))
2821 (set (match_operand:BLK 0 "memory_operand" "")
2822 (match_operand:BLK 1 "memory_operand" ""))
2823 (use (match_operand 2 "general_operand" ""))
2825 (clobber (reg:CC CC_REGNUM))])]
2828 enum machine_mode sreg_mode = TARGET_ZARCH ? DImode : SImode;
2829 enum machine_mode dreg_mode = TARGET_ZARCH ? TImode : DImode;
2830 rtx reg0 = gen_reg_rtx (dreg_mode);
2831 rtx reg1 = gen_reg_rtx (dreg_mode);
2832 rtx addr0 = gen_lowpart (Pmode, gen_highpart (sreg_mode, reg0));
2833 rtx addr1 = gen_lowpart (Pmode, gen_highpart (sreg_mode, reg1));
2834 rtx len0 = gen_lowpart (Pmode, reg0);
2835 rtx len1 = gen_lowpart (Pmode, reg1);
2837 emit_clobber (reg0);
2838 emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
2839 emit_move_insn (len0, operands[2]);
2841 emit_clobber (reg1);
2842 emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
2843 emit_move_insn (len1, operands[2]);
2845 operands[0] = replace_equiv_address_nv (operands[0], addr0);
2846 operands[1] = replace_equiv_address_nv (operands[1], addr1);
2851 (define_insn "*movmem_long"
2852 [(clobber (match_operand:<DBL> 0 "register_operand" "=d"))
2853 (clobber (match_operand:<DBL> 1 "register_operand" "=d"))
2854 (set (mem:BLK (subreg:P (match_operand:<DBL> 2 "register_operand" "0") 0))
2855 (mem:BLK (subreg:P (match_operand:<DBL> 3 "register_operand" "1") 0)))
2858 (clobber (reg:CC CC_REGNUM))]
2859 "TARGET_64BIT || !TARGET_ZARCH"
2860 "mvcle\t%0,%1,0\;jo\t.-4"
2861 [(set_attr "length" "8")
2862 (set_attr "type" "vs")])
2864 (define_insn "*movmem_long_31z"
2865 [(clobber (match_operand:TI 0 "register_operand" "=d"))
2866 (clobber (match_operand:TI 1 "register_operand" "=d"))
2867 (set (mem:BLK (subreg:SI (match_operand:TI 2 "register_operand" "0") 4))
2868 (mem:BLK (subreg:SI (match_operand:TI 3 "register_operand" "1") 4)))
2871 (clobber (reg:CC CC_REGNUM))]
2872 "!TARGET_64BIT && TARGET_ZARCH"
2873 "mvcle\t%0,%1,0\;jo\t.-4"
2874 [(set_attr "length" "8")
2875 (set_attr "type" "vs")])
2882 (define_expand "signbit<mode>2"
2883 [(set (reg:CCZ CC_REGNUM)
2884 (unspec:CCZ [(match_operand:FP_ALL 1 "register_operand" "f")
2887 (set (match_operand:SI 0 "register_operand" "=d")
2888 (unspec:SI [(reg:CCZ CC_REGNUM)] UNSPEC_CC_TO_INT))]
2891 operands[2] = GEN_INT (S390_TDC_SIGNBIT_SET);
2894 (define_expand "isinf<mode>2"
2895 [(set (reg:CCZ CC_REGNUM)
2896 (unspec:CCZ [(match_operand:FP_ALL 1 "register_operand" "f")
2899 (set (match_operand:SI 0 "register_operand" "=d")
2900 (unspec:SI [(reg:CCZ CC_REGNUM)] UNSPEC_CC_TO_INT))]
2903 operands[2] = GEN_INT (S390_TDC_INFINITY);
2906 (define_insn_and_split "*cc_to_int"
2907 [(set (match_operand:SI 0 "register_operand" "=d")
2908 (unspec:SI [(match_operand 1 "register_operand" "0")]
2913 [(set (match_dup 0) (lshiftrt:SI (match_dup 0) (const_int 28)))])
2915 ; This insn is used to generate all variants of the Test Data Class
2916 ; instruction, namely tcxb, tcdb, and tceb. The insn's first operand
2917 ; is the register to be tested and the second one is the bit mask
2918 ; specifying the required test(s).
2920 ; tcxb, tcdb, tceb, tdcxt, tdcdt, tdcet
2921 (define_insn "*TDC_insn_<mode>"
2922 [(set (reg:CCZ CC_REGNUM)
2923 (unspec:CCZ [(match_operand:FP_ALL 0 "register_operand" "f")
2924 (match_operand:SI 1 "const_int_operand")] UNSPEC_TDC_INSN))]
2926 "t<_d>c<xde><bt>\t%0,%1"
2927 [(set_attr "op_type" "RXE")
2928 (set_attr "type" "fsimp<mode>")])
2933 ; setmemM instruction pattern(s).
2936 (define_expand "setmem<mode>"
2937 [(set (match_operand:BLK 0 "memory_operand" "")
2938 (match_operand:QI 2 "general_operand" ""))
2939 (use (match_operand:GPR 1 "general_operand" ""))
2940 (match_operand 3 "" "")]
2942 "s390_expand_setmem (operands[0], operands[1], operands[2]); DONE;")
2944 ; Clear a block that is up to 256 bytes in length.
2945 ; The block length is taken as (operands[1] % 256) + 1.
2947 (define_expand "clrmem_short"
2949 [(set (match_operand:BLK 0 "memory_operand" "")
2951 (use (match_operand 1 "nonmemory_operand" ""))
2952 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
2953 (clobber (match_dup 2))
2954 (clobber (reg:CC CC_REGNUM))])]
2956 "operands[2] = gen_rtx_SCRATCH (Pmode);")
2958 (define_insn "*clrmem_short"
2959 [(set (match_operand:BLK 0 "memory_operand" "=Q,Q,Q,Q")
2961 (use (match_operand 1 "nonmemory_operand" "n,a,a,a"))
2962 (use (match_operand 2 "immediate_operand" "X,R,X,X"))
2963 (clobber (match_scratch:P 3 "=X,X,X,&a"))
2964 (clobber (reg:CC CC_REGNUM))]
2965 "(GET_MODE (operands[1]) == Pmode || GET_MODE (operands[1]) == VOIDmode)"
2967 [(set_attr "type" "cs")
2968 (set_attr "cpu_facility" "*,*,z10,cpu_zarch")])
2971 [(set (match_operand:BLK 0 "memory_operand" "")
2973 (use (match_operand 1 "const_int_operand" ""))
2974 (use (match_operand 2 "immediate_operand" ""))
2976 (clobber (reg:CC CC_REGNUM))]
2979 [(set (match_dup 0) (const_int 0))
2981 (clobber (reg:CC CC_REGNUM))])]
2982 "operands[1] = GEN_INT ((INTVAL (operands[1]) & 0xff) + 1);")
2985 [(set (match_operand:BLK 0 "memory_operand" "")
2987 (use (match_operand 1 "register_operand" ""))
2988 (use (match_operand 2 "memory_operand" ""))
2990 (clobber (reg:CC CC_REGNUM))]
2993 [(unspec [(match_dup 1) (match_dup 2)
2994 (const_int 0)] UNSPEC_EXECUTE)
2995 (set (match_dup 0) (const_int 0))
2997 (clobber (reg:CC CC_REGNUM))])]
3001 [(set (match_operand:BLK 0 "memory_operand" "")
3003 (use (match_operand 1 "register_operand" ""))
3004 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
3006 (clobber (reg:CC CC_REGNUM))]
3007 "TARGET_Z10 && reload_completed"
3009 [(unspec [(match_dup 1) (const_int 0)
3010 (label_ref (match_dup 3))] UNSPEC_EXECUTE)
3011 (set (match_dup 0) (const_int 0))
3013 (clobber (reg:CC CC_REGNUM))])]
3014 "operands[3] = gen_label_rtx ();")
3017 [(set (match_operand:BLK 0 "memory_operand" "")
3019 (use (match_operand 1 "register_operand" ""))
3020 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
3021 (clobber (match_operand 2 "register_operand" ""))
3022 (clobber (reg:CC CC_REGNUM))]
3023 "reload_completed && TARGET_CPU_ZARCH"
3024 [(set (match_dup 2) (label_ref (match_dup 3)))
3026 [(unspec [(match_dup 1) (mem:BLK (match_dup 2))
3027 (label_ref (match_dup 3))] UNSPEC_EXECUTE)
3028 (set (match_dup 0) (const_int 0))
3030 (clobber (reg:CC CC_REGNUM))])]
3031 "operands[3] = gen_label_rtx ();")
3033 ; Initialize a block of arbitrary length with (operands[2] % 256).
3035 (define_expand "setmem_long"
3037 [(clobber (match_dup 1))
3038 (set (match_operand:BLK 0 "memory_operand" "")
3039 (match_operand 2 "shift_count_or_setmem_operand" ""))
3040 (use (match_operand 1 "general_operand" ""))
3042 (clobber (reg:CC CC_REGNUM))])]
3045 enum machine_mode sreg_mode = TARGET_ZARCH ? DImode : SImode;
3046 enum machine_mode dreg_mode = TARGET_ZARCH ? TImode : DImode;
3047 rtx reg0 = gen_reg_rtx (dreg_mode);
3048 rtx reg1 = gen_reg_rtx (dreg_mode);
3049 rtx addr0 = gen_lowpart (Pmode, gen_highpart (sreg_mode, reg0));
3050 rtx len0 = gen_lowpart (Pmode, reg0);
3052 emit_clobber (reg0);
3053 emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
3054 emit_move_insn (len0, operands[1]);
3056 emit_move_insn (reg1, const0_rtx);
3058 operands[0] = replace_equiv_address_nv (operands[0], addr0);
3063 (define_insn "*setmem_long"
3064 [(clobber (match_operand:<DBL> 0 "register_operand" "=d"))
3065 (set (mem:BLK (subreg:P (match_operand:<DBL> 3 "register_operand" "0") 0))
3066 (match_operand 2 "shift_count_or_setmem_operand" "Y"))
3068 (use (match_operand:<DBL> 1 "register_operand" "d"))
3069 (clobber (reg:CC CC_REGNUM))]
3070 "TARGET_64BIT || !TARGET_ZARCH"
3071 "mvcle\t%0,%1,%Y2\;jo\t.-4"
3072 [(set_attr "length" "8")
3073 (set_attr "type" "vs")])
3075 (define_insn "*setmem_long_and"
3076 [(clobber (match_operand:<DBL> 0 "register_operand" "=d"))
3077 (set (mem:BLK (subreg:P (match_operand:<DBL> 3 "register_operand" "0") 0))
3078 (and (match_operand 2 "shift_count_or_setmem_operand" "Y")
3079 (match_operand 4 "const_int_operand" "n")))
3081 (use (match_operand:<DBL> 1 "register_operand" "d"))
3082 (clobber (reg:CC CC_REGNUM))]
3083 "(TARGET_64BIT || !TARGET_ZARCH) &&
3084 (INTVAL (operands[4]) & 255) == 255"
3085 "mvcle\t%0,%1,%Y2\;jo\t.-4"
3086 [(set_attr "length" "8")
3087 (set_attr "type" "vs")])
3089 (define_insn "*setmem_long_31z"
3090 [(clobber (match_operand:TI 0 "register_operand" "=d"))
3091 (set (mem:BLK (subreg:SI (match_operand:TI 3 "register_operand" "0") 4))
3092 (match_operand 2 "shift_count_or_setmem_operand" "Y"))
3094 (use (match_operand:TI 1 "register_operand" "d"))
3095 (clobber (reg:CC CC_REGNUM))]
3096 "!TARGET_64BIT && TARGET_ZARCH"
3097 "mvcle\t%0,%1,%Y2\;jo\t.-4"
3098 [(set_attr "length" "8")
3099 (set_attr "type" "vs")])
3102 ; cmpmemM instruction pattern(s).
3105 (define_expand "cmpmemsi"
3106 [(set (match_operand:SI 0 "register_operand" "")
3107 (compare:SI (match_operand:BLK 1 "memory_operand" "")
3108 (match_operand:BLK 2 "memory_operand" "") ) )
3109 (use (match_operand:SI 3 "general_operand" ""))
3110 (use (match_operand:SI 4 "" ""))]
3113 if (s390_expand_cmpmem (operands[0], operands[1],
3114 operands[2], operands[3]))
3120 ; Compare a block that is up to 256 bytes in length.
3121 ; The block length is taken as (operands[2] % 256) + 1.
3123 (define_expand "cmpmem_short"
3125 [(set (reg:CCU CC_REGNUM)
3126 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3127 (match_operand:BLK 1 "memory_operand" "")))
3128 (use (match_operand 2 "nonmemory_operand" ""))
3129 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
3130 (clobber (match_dup 3))])]
3132 "operands[3] = gen_rtx_SCRATCH (Pmode);")
3134 (define_insn "*cmpmem_short"
3135 [(set (reg:CCU CC_REGNUM)
3136 (compare:CCU (match_operand:BLK 0 "memory_operand" "Q,Q,Q,Q")
3137 (match_operand:BLK 1 "memory_operand" "Q,Q,Q,Q")))
3138 (use (match_operand 2 "nonmemory_operand" "n,a,a,a"))
3139 (use (match_operand 3 "immediate_operand" "X,R,X,X"))
3140 (clobber (match_scratch:P 4 "=X,X,X,&a"))]
3141 "(GET_MODE (operands[2]) == Pmode || GET_MODE (operands[2]) == VOIDmode)"
3143 [(set_attr "type" "cs")
3144 (set_attr "cpu_facility" "*,*,z10,cpu_zarch")])
3147 [(set (reg:CCU CC_REGNUM)
3148 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3149 (match_operand:BLK 1 "memory_operand" "")))
3150 (use (match_operand 2 "const_int_operand" ""))
3151 (use (match_operand 3 "immediate_operand" ""))
3152 (clobber (scratch))]
3155 [(set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
3156 (use (match_dup 2))])]
3157 "operands[2] = GEN_INT ((INTVAL (operands[2]) & 0xff) + 1);")
3160 [(set (reg:CCU CC_REGNUM)
3161 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3162 (match_operand:BLK 1 "memory_operand" "")))
3163 (use (match_operand 2 "register_operand" ""))
3164 (use (match_operand 3 "memory_operand" ""))
3165 (clobber (scratch))]
3168 [(unspec [(match_dup 2) (match_dup 3)
3169 (const_int 0)] UNSPEC_EXECUTE)
3170 (set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
3171 (use (const_int 1))])]
3175 [(set (reg:CCU CC_REGNUM)
3176 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3177 (match_operand:BLK 1 "memory_operand" "")))
3178 (use (match_operand 2 "register_operand" ""))
3179 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
3180 (clobber (scratch))]
3181 "TARGET_Z10 && reload_completed"
3183 [(unspec [(match_dup 2) (const_int 0)
3184 (label_ref (match_dup 4))] UNSPEC_EXECUTE)
3185 (set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
3186 (use (const_int 1))])]
3187 "operands[4] = gen_label_rtx ();")
3190 [(set (reg:CCU CC_REGNUM)
3191 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3192 (match_operand:BLK 1 "memory_operand" "")))
3193 (use (match_operand 2 "register_operand" ""))
3194 (use (const:BLK (unspec:BLK [(const_int 0)] UNSPEC_INSN)))
3195 (clobber (match_operand 3 "register_operand" ""))]
3196 "reload_completed && TARGET_CPU_ZARCH"
3197 [(set (match_dup 3) (label_ref (match_dup 4)))
3199 [(unspec [(match_dup 2) (mem:BLK (match_dup 3))
3200 (label_ref (match_dup 4))] UNSPEC_EXECUTE)
3201 (set (reg:CCU CC_REGNUM) (compare:CCU (match_dup 0) (match_dup 1)))
3202 (use (const_int 1))])]
3203 "operands[4] = gen_label_rtx ();")
3205 ; Compare a block of arbitrary length.
3207 (define_expand "cmpmem_long"
3209 [(clobber (match_dup 2))
3210 (clobber (match_dup 3))
3211 (set (reg:CCU CC_REGNUM)
3212 (compare:CCU (match_operand:BLK 0 "memory_operand" "")
3213 (match_operand:BLK 1 "memory_operand" "")))
3214 (use (match_operand 2 "general_operand" ""))
3215 (use (match_dup 3))])]
3218 enum machine_mode sreg_mode = TARGET_ZARCH ? DImode : SImode;
3219 enum machine_mode dreg_mode = TARGET_ZARCH ? TImode : DImode;
3220 rtx reg0 = gen_reg_rtx (dreg_mode);
3221 rtx reg1 = gen_reg_rtx (dreg_mode);
3222 rtx addr0 = gen_lowpart (Pmode, gen_highpart (sreg_mode, reg0));
3223 rtx addr1 = gen_lowpart (Pmode, gen_highpart (sreg_mode, reg1));
3224 rtx len0 = gen_lowpart (Pmode, reg0);
3225 rtx len1 = gen_lowpart (Pmode, reg1);
3227 emit_clobber (reg0);
3228 emit_move_insn (addr0, force_operand (XEXP (operands[0], 0), NULL_RTX));
3229 emit_move_insn (len0, operands[2]);
3231 emit_clobber (reg1);
3232 emit_move_insn (addr1, force_operand (XEXP (operands[1], 0), NULL_RTX));
3233 emit_move_insn (len1, operands[2]);
3235 operands[0] = replace_equiv_address_nv (operands[0], addr0);
3236 operands[1] = replace_equiv_address_nv (operands[1], addr1);
3241 (define_insn "*cmpmem_long"
3242 [(clobber (match_operand:<DBL> 0 "register_operand" "=d"))
3243 (clobber (match_operand:<DBL> 1 "register_operand" "=d"))
3244 (set (reg:CCU CC_REGNUM)
3245 (compare:CCU (mem:BLK (subreg:P (match_operand:<DBL> 2 "register_operand" "0") 0))
3246 (mem:BLK (subreg:P (match_operand:<DBL> 3 "register_operand" "1") 0))))
3248 (use (match_dup 3))]
3249 "TARGET_64BIT || !TARGET_ZARCH"
3250 "clcle\t%0,%1,0\;jo\t.-4"
3251 [(set_attr "length" "8")
3252 (set_attr "type" "vs")])
3254 (define_insn "*cmpmem_long_31z"
3255 [(clobber (match_operand:TI 0 "register_operand" "=d"))
3256 (clobber (match_operand:TI 1 "register_operand" "=d"))
3257 (set (reg:CCU CC_REGNUM)
3258 (compare:CCU (mem:BLK (subreg:SI (match_operand:TI 2 "register_operand" "0") 4))
3259 (mem:BLK (subreg:SI (match_operand:TI 3 "register_operand" "1") 4))))
3261 (use (match_dup 3))]
3262 "!TARGET_64BIT && TARGET_ZARCH"
3263 "clcle\t%0,%1,0\;jo\t.-4"
3264 [(set_attr "op_type" "NN")
3265 (set_attr "type" "vs")
3266 (set_attr "length" "8")])
3268 ; Convert CCUmode condition code to integer.
3269 ; Result is zero if EQ, positive if LTU, negative if GTU.
3271 (define_insn_and_split "cmpint"
3272 [(set (match_operand:SI 0 "register_operand" "=d")
3273 (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
3274 UNSPEC_STRCMPCC_TO_INT))
3275 (clobber (reg:CC CC_REGNUM))]
3279 [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
3281 [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))
3282 (clobber (reg:CC CC_REGNUM))])])
3284 (define_insn_and_split "*cmpint_cc"
3285 [(set (reg CC_REGNUM)
3286 (compare (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
3287 UNSPEC_STRCMPCC_TO_INT)
3289 (set (match_operand:SI 0 "register_operand" "=d")
3290 (unspec:SI [(match_dup 1)] UNSPEC_STRCMPCC_TO_INT))]
3291 "s390_match_ccmode (insn, CCSmode)"
3293 "&& reload_completed"
3294 [(set (match_dup 0) (ashift:SI (match_dup 0) (const_int 2)))
3296 [(set (match_dup 2) (match_dup 3))
3297 (set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 30)))])]
3299 rtx result = gen_rtx_ASHIFTRT (SImode, operands[0], GEN_INT (30));
3300 operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
3301 operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
3304 (define_insn_and_split "*cmpint_sign"
3305 [(set (match_operand:DI 0 "register_operand" "=d")
3306 (sign_extend:DI (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
3307 UNSPEC_STRCMPCC_TO_INT)))
3308 (clobber (reg:CC CC_REGNUM))]
3311 "&& reload_completed"
3312 [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
3314 [(set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))
3315 (clobber (reg:CC CC_REGNUM))])])
3317 (define_insn_and_split "*cmpint_sign_cc"
3318 [(set (reg CC_REGNUM)
3319 (compare (ashiftrt:DI (ashift:DI (subreg:DI
3320 (unspec:SI [(match_operand:CCU 1 "register_operand" "0")]
3321 UNSPEC_STRCMPCC_TO_INT) 0)
3322 (const_int 32)) (const_int 32))
3324 (set (match_operand:DI 0 "register_operand" "=d")
3325 (sign_extend:DI (unspec:SI [(match_dup 1)] UNSPEC_STRCMPCC_TO_INT)))]
3326 "s390_match_ccmode (insn, CCSmode) && TARGET_ZARCH"
3328 "&& reload_completed"
3329 [(set (match_dup 0) (ashift:DI (match_dup 0) (const_int 34)))
3331 [(set (match_dup 2) (match_dup 3))
3332 (set (match_dup 0) (ashiftrt:DI (match_dup 0) (const_int 62)))])]
3334 rtx result = gen_rtx_ASHIFTRT (DImode, operands[0], GEN_INT (62));
3335 operands[2] = SET_DEST (XVECEXP (PATTERN (curr_insn), 0, 0));
3336 operands[3] = gen_rtx_COMPARE (GET_MODE (operands[2]), result, const0_rtx);
3341 ;;- Conversion instructions.
3344 (define_insn "*sethighpartsi"
3345 [(set (match_operand:SI 0 "register_operand" "=d,d")
3346 (unspec:SI [(match_operand:BLK 1 "s_operand" "Q,S")
3347 (match_operand 2 "const_int_operand" "n,n")] UNSPEC_ICM))
3348 (clobber (reg:CC CC_REGNUM))]
3353 [(set_attr "op_type" "RS,RSY")
3354 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3356 (define_insn "*sethighpartdi_64"
3357 [(set (match_operand:DI 0 "register_operand" "=d")
3358 (unspec:DI [(match_operand:BLK 1 "s_operand" "QS")
3359 (match_operand 2 "const_int_operand" "n")] UNSPEC_ICM))
3360 (clobber (reg:CC CC_REGNUM))]
3363 [(set_attr "op_type" "RSY")
3364 (set_attr "z10prop" "z10_super")])
3366 (define_insn "*sethighpartdi_31"
3367 [(set (match_operand:DI 0 "register_operand" "=d,d")
3368 (unspec:DI [(match_operand:BLK 1 "s_operand" "Q,S")
3369 (match_operand 2 "const_int_operand" "n,n")] UNSPEC_ICM))
3370 (clobber (reg:CC CC_REGNUM))]
3375 [(set_attr "op_type" "RS,RSY")
3376 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3379 ; extv instruction patterns
3382 ; FIXME: This expander needs to be converted from DI to GPR as well
3383 ; after resolving some issues with it.
3385 (define_expand "extzv"
3387 [(set (match_operand:DI 0 "register_operand" "=d")
3389 (match_operand:DI 1 "register_operand" "d")
3390 (match_operand 2 "const_int_operand" "") ; size
3391 (match_operand 3 "const_int_operand" ""))) ; start
3392 (clobber (reg:CC CC_REGNUM))])]
3395 /* Starting with zEC12 there is risbgn not clobbering CC. */
3398 emit_move_insn (operands[0],
3399 gen_rtx_ZERO_EXTRACT (DImode,
3407 (define_insn "*extzv<mode>_zEC12"
3408 [(set (match_operand:GPR 0 "register_operand" "=d")
3410 (match_operand:GPR 1 "register_operand" "d")
3411 (match_operand 2 "const_int_operand" "") ; size
3412 (match_operand 3 "const_int_operand" "")))] ; start]
3414 "risbgn\t%0,%1,64-%2,128+63,<bitsize>+%3+%2" ; dst, src, start, end, shift
3415 [(set_attr "op_type" "RIE")])
3417 (define_insn "*extzv<mode>_z10"
3418 [(set (match_operand:GPR 0 "register_operand" "=d")
3420 (match_operand:GPR 1 "register_operand" "d")
3421 (match_operand 2 "const_int_operand" "") ; size
3422 (match_operand 3 "const_int_operand" ""))) ; start
3423 (clobber (reg:CC CC_REGNUM))]
3425 "risbg\t%0,%1,64-%2,128+63,<bitsize>+%3+%2" ; dst, src, start, end, shift
3426 [(set_attr "op_type" "RIE")
3427 (set_attr "z10prop" "z10_super_E1")])
3429 (define_insn_and_split "*pre_z10_extzv<mode>"
3430 [(set (match_operand:GPR 0 "register_operand" "=d")
3431 (zero_extract:GPR (match_operand:QI 1 "s_operand" "QS")
3432 (match_operand 2 "nonzero_shift_count_operand" "")
3434 (clobber (reg:CC CC_REGNUM))]
3437 "&& reload_completed"
3439 [(set (match_dup 0) (unspec:GPR [(match_dup 1) (match_dup 3)] UNSPEC_ICM))
3440 (clobber (reg:CC CC_REGNUM))])
3441 (set (match_dup 0) (lshiftrt:GPR (match_dup 0) (match_dup 2)))]
3443 int bitsize = INTVAL (operands[2]);
3444 int size = (bitsize - 1) / BITS_PER_UNIT + 1; /* round up */
3445 int mask = ((1ul << size) - 1) << (GET_MODE_SIZE (SImode) - size);
3447 operands[1] = adjust_address (operands[1], BLKmode, 0);
3448 set_mem_size (operands[1], size);
3449 operands[2] = GEN_INT (<GPR:bitsize> - bitsize);
3450 operands[3] = GEN_INT (mask);
3453 (define_insn_and_split "*pre_z10_extv<mode>"
3454 [(set (match_operand:GPR 0 "register_operand" "=d")
3455 (sign_extract:GPR (match_operand:QI 1 "s_operand" "QS")
3456 (match_operand 2 "nonzero_shift_count_operand" "")
3458 (clobber (reg:CC CC_REGNUM))]
3461 "&& reload_completed"
3463 [(set (match_dup 0) (unspec:GPR [(match_dup 1) (match_dup 3)] UNSPEC_ICM))
3464 (clobber (reg:CC CC_REGNUM))])
3466 [(set (match_dup 0) (ashiftrt:GPR (match_dup 0) (match_dup 2)))
3467 (clobber (reg:CC CC_REGNUM))])]
3469 int bitsize = INTVAL (operands[2]);
3470 int size = (bitsize - 1) / BITS_PER_UNIT + 1; /* round up */
3471 int mask = ((1ul << size) - 1) << (GET_MODE_SIZE (SImode) - size);
3473 operands[1] = adjust_address (operands[1], BLKmode, 0);
3474 set_mem_size (operands[1], size);
3475 operands[2] = GEN_INT (<GPR:bitsize> - bitsize);
3476 operands[3] = GEN_INT (mask);
3480 ; insv instruction patterns
3483 (define_expand "insv"
3484 [(set (zero_extract (match_operand 0 "nonimmediate_operand" "")
3485 (match_operand 1 "const_int_operand" "")
3486 (match_operand 2 "const_int_operand" ""))
3487 (match_operand 3 "general_operand" ""))]
3490 if (s390_expand_insv (operands[0], operands[1], operands[2], operands[3]))
3496 ; The normal RTL expansion will never generate a zero_extract where
3497 ; the location operand isn't word mode. However, we do this in the
3498 ; back-end when generating atomic operations. See s390_two_part_insv.
3499 (define_insn "*insv<mode>_zEC12"
3500 [(set (zero_extract:GPR (match_operand:GPR 0 "nonimmediate_operand" "+d")
3501 (match_operand 1 "const_int_operand" "I") ; size
3502 (match_operand 2 "const_int_operand" "I")) ; pos
3503 (match_operand:GPR 3 "nonimmediate_operand" "d"))]
3505 && (INTVAL (operands[1]) + INTVAL (operands[2])) <= <bitsize>"
3506 "risbgn\t%0,%3,64-<bitsize>+%2,64-<bitsize>+%2+%1-1,<bitsize>-%2-%1"
3507 [(set_attr "op_type" "RIE")])
3509 (define_insn "*insv<mode>_z10"
3510 [(set (zero_extract:GPR (match_operand:GPR 0 "nonimmediate_operand" "+d")
3511 (match_operand 1 "const_int_operand" "I") ; size
3512 (match_operand 2 "const_int_operand" "I")) ; pos
3513 (match_operand:GPR 3 "nonimmediate_operand" "d"))
3514 (clobber (reg:CC CC_REGNUM))]
3516 && (INTVAL (operands[1]) + INTVAL (operands[2])) <= <bitsize>"
3517 "risbg\t%0,%3,64-<bitsize>+%2,64-<bitsize>+%2+%1-1,<bitsize>-%2-%1"
3518 [(set_attr "op_type" "RIE")
3519 (set_attr "z10prop" "z10_super_E1")])
3521 ; and op1 with a mask being 1 for the selected bits and 0 for the rest
3522 ; and op3=op0 with a mask being 0 for the selected bits and 1 for the rest
3523 (define_insn "*insv<mode>_zEC12_noshift"
3524 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d")
3525 (ior:GPR (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "d")
3526 (match_operand:GPR 2 "contiguous_bitmask_operand" ""))
3527 (and:GPR (match_operand:GPR 3 "nonimmediate_operand" "0")
3528 (match_operand:GPR 4 "const_int_operand" ""))))]
3529 "TARGET_ZEC12 && INTVAL (operands[2]) == ~INTVAL (operands[4])"
3530 "risbgn\t%0,%1,%<bfstart>2,%<bfend>2,0"
3531 [(set_attr "op_type" "RIE")])
3533 (define_insn "*insv<mode>_z10_noshift"
3534 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d")
3535 (ior:GPR (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "d")
3536 (match_operand:GPR 2 "contiguous_bitmask_operand" ""))
3537 (and:GPR (match_operand:GPR 3 "nonimmediate_operand" "0")
3538 (match_operand:GPR 4 "const_int_operand" ""))))
3539 (clobber (reg:CC CC_REGNUM))]
3540 "TARGET_Z10 && INTVAL (operands[2]) == ~INTVAL (operands[4])"
3541 "risbg\t%0,%1,%<bfstart>2,%<bfend>2,0"
3542 [(set_attr "op_type" "RIE")
3543 (set_attr "z10prop" "z10_super_E1")])
3545 (define_insn "*r<noxa>sbg_<mode>_noshift"
3546 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d")
3548 (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "d")
3549 (match_operand:GPR 2 "contiguous_bitmask_operand" ""))
3550 (match_operand:GPR 3 "nonimmediate_operand" "0")))
3551 (clobber (reg:CC CC_REGNUM))]
3553 "r<noxa>sbg\t%0,%1,%<bfstart>2,%<bfend>2,0"
3554 [(set_attr "op_type" "RIE")])
3556 (define_insn "*r<noxa>sbg_di_rotl"
3557 [(set (match_operand:DI 0 "nonimmediate_operand" "=d")
3561 (match_operand:DI 1 "nonimmediate_operand" "d")
3562 (match_operand:DI 3 "const_int_operand" ""))
3563 (match_operand:DI 2 "contiguous_bitmask_operand" ""))
3564 (match_operand:DI 4 "nonimmediate_operand" "0")))
3565 (clobber (reg:CC CC_REGNUM))]
3567 "r<noxa>sbg\t%0,%1,%<bfstart>2,%<bfend>2,%b3"
3568 [(set_attr "op_type" "RIE")])
3570 (define_insn "*r<noxa>sbg_<mode>_srl"
3571 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d")
3575 (match_operand:GPR 1 "nonimmediate_operand" "d")
3576 (match_operand:GPR 3 "nonzero_shift_count_operand" ""))
3577 (match_operand:GPR 2 "contiguous_bitmask_operand" ""))
3578 (match_operand:GPR 4 "nonimmediate_operand" "0")))
3579 (clobber (reg:CC CC_REGNUM))]
3581 && s390_extzv_shift_ok (<bitsize>, 64 - INTVAL (operands[3]),
3582 INTVAL (operands[2]))"
3583 "r<noxa>sbg\t%0,%1,%<bfstart>2,%<bfend>2,64-%3"
3584 [(set_attr "op_type" "RIE")])
3586 (define_insn "*r<noxa>sbg_<mode>_sll"
3587 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d")
3591 (match_operand:GPR 1 "nonimmediate_operand" "d")
3592 (match_operand:GPR 3 "nonzero_shift_count_operand" ""))
3593 (match_operand:GPR 2 "contiguous_bitmask_operand" ""))
3594 (match_operand:GPR 4 "nonimmediate_operand" "0")))
3595 (clobber (reg:CC CC_REGNUM))]
3597 && s390_extzv_shift_ok (<bitsize>, INTVAL (operands[3]),
3598 INTVAL (operands[2]))"
3599 "r<noxa>sbg\t%0,%1,%<bfstart>2,%<bfend>2,%3"
3600 [(set_attr "op_type" "RIE")])
3602 ;; These two are generated by combine for s.bf &= val.
3603 ;; ??? For bitfields smaller than 32-bits, we wind up with SImode
3604 ;; shifts and ands, which results in some truly awful patterns
3605 ;; including subregs of operations. Rather unnecessisarily, IMO.
3608 ;; (set (zero_extract:DI (reg/v:DI 50 [ s ])
3609 ;; (const_int 24 [0x18])
3610 ;; (const_int 0 [0]))
3611 ;; (subreg:DI (and:SI (subreg:SI (lshiftrt:DI (reg/v:DI 50 [ s ])
3612 ;; (const_int 40 [0x28])) 4)
3613 ;; (reg:SI 4 %r4 [ y+4 ])) 0))
3615 ;; we should instead generate
3617 ;; (set (zero_extract:DI (reg/v:DI 50 [ s ])
3618 ;; (const_int 24 [0x18])
3619 ;; (const_int 0 [0]))
3620 ;; (and:DI (lshiftrt:DI (reg/v:DI 50 [ s ])
3621 ;; (const_int 40 [0x28]))
3622 ;; (subreg:DI (reg:SI 4 %r4 [ y+4 ]) 0)))
3624 ;; by noticing that we can push down the outer paradoxical subreg
3625 ;; into the operation.
3627 (define_insn "*insv_rnsbg_noshift"
3628 [(set (zero_extract:DI
3629 (match_operand:DI 0 "nonimmediate_operand" "+d")
3630 (match_operand 1 "const_int_operand" "")
3631 (match_operand 2 "const_int_operand" ""))
3634 (match_operand:DI 3 "nonimmediate_operand" "d")))
3635 (clobber (reg:CC CC_REGNUM))]
3637 && INTVAL (operands[1]) + INTVAL (operands[2]) == 64"
3638 "rnsbg\t%0,%3,%2,63,0"
3639 [(set_attr "op_type" "RIE")])
3641 (define_insn "*insv_rnsbg_srl"
3642 [(set (zero_extract:DI
3643 (match_operand:DI 0 "nonimmediate_operand" "+d")
3644 (match_operand 1 "const_int_operand" "")
3645 (match_operand 2 "const_int_operand" ""))
3649 (match_operand 3 "const_int_operand" ""))
3650 (match_operand:DI 4 "nonimmediate_operand" "d")))
3651 (clobber (reg:CC CC_REGNUM))]
3653 && INTVAL (operands[3]) == 64 - INTVAL (operands[1]) - INTVAL (operands[2])"
3654 "rnsbg\t%0,%4,%2,%2+%1-1,%3"
3655 [(set_attr "op_type" "RIE")])
3657 (define_insn "*insv<mode>_mem_reg"
3658 [(set (zero_extract:W (match_operand:QI 0 "memory_operand" "+Q,S")
3659 (match_operand 1 "const_int_operand" "n,n")
3661 (match_operand:W 2 "register_operand" "d,d"))]
3662 "INTVAL (operands[1]) > 0
3663 && INTVAL (operands[1]) <= GET_MODE_BITSIZE (SImode)
3664 && INTVAL (operands[1]) % BITS_PER_UNIT == 0"
3666 int size = INTVAL (operands[1]) / BITS_PER_UNIT;
3668 operands[1] = GEN_INT ((1ul << size) - 1);
3669 return (which_alternative == 0) ? "stcm\t%2,%1,%S0"
3670 : "stcmy\t%2,%1,%S0";
3672 [(set_attr "op_type" "RS,RSY")
3673 (set_attr "z10prop" "z10_super,z10_super")])
3675 (define_insn "*insvdi_mem_reghigh"
3676 [(set (zero_extract:DI (match_operand:QI 0 "memory_operand" "+QS")
3677 (match_operand 1 "const_int_operand" "n")
3679 (lshiftrt:DI (match_operand:DI 2 "register_operand" "d")
3682 && INTVAL (operands[1]) > 0
3683 && INTVAL (operands[1]) <= GET_MODE_BITSIZE (SImode)
3684 && INTVAL (operands[1]) % BITS_PER_UNIT == 0"
3686 int size = INTVAL (operands[1]) / BITS_PER_UNIT;
3688 operands[1] = GEN_INT ((1ul << size) - 1);
3689 return "stcmh\t%2,%1,%S0";
3691 [(set_attr "op_type" "RSY")
3692 (set_attr "z10prop" "z10_super")])
3694 (define_insn "*insvdi_reg_imm"
3695 [(set (zero_extract:DI (match_operand:DI 0 "register_operand" "+d")
3697 (match_operand 1 "const_int_operand" "n"))
3698 (match_operand:DI 2 "const_int_operand" "n"))]
3700 && INTVAL (operands[1]) >= 0
3701 && INTVAL (operands[1]) < BITS_PER_WORD
3702 && INTVAL (operands[1]) % 16 == 0"
3704 switch (BITS_PER_WORD - INTVAL (operands[1]))
3706 case 64: return "iihh\t%0,%x2"; break;
3707 case 48: return "iihl\t%0,%x2"; break;
3708 case 32: return "iilh\t%0,%x2"; break;
3709 case 16: return "iill\t%0,%x2"; break;
3710 default: gcc_unreachable();
3713 [(set_attr "op_type" "RI")
3714 (set_attr "z10prop" "z10_super_E1")])
3716 ; Update the left-most 32 bit of a DI.
3717 (define_insn "*insv_h_di_reg_extimm"
3718 [(set (zero_extract:DI (match_operand:DI 0 "register_operand" "+d")
3721 (match_operand:DI 1 "const_int_operand" "n"))]
3724 [(set_attr "op_type" "RIL")
3725 (set_attr "z10prop" "z10_fwd_E1")])
3727 ; Update the right-most 32 bit of a DI.
3728 (define_insn "*insv_l_di_reg_extimm"
3729 [(set (zero_extract:DI (match_operand:DI 0 "register_operand" "+d")
3732 (match_operand:DI 1 "const_int_operand" "n"))]
3735 [(set_attr "op_type" "RIL")
3736 (set_attr "z10prop" "z10_fwd_A1")])
3739 ; extendsidi2 instruction pattern(s).
3742 (define_expand "extendsidi2"
3743 [(set (match_operand:DI 0 "register_operand" "")
3744 (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
3749 emit_clobber (operands[0]);
3750 emit_move_insn (gen_highpart (SImode, operands[0]), operands[1]);
3751 emit_move_insn (gen_lowpart (SImode, operands[0]), const0_rtx);
3752 emit_insn (gen_ashrdi3 (operands[0], operands[0], GEN_INT (32)));
3757 (define_insn "*extendsidi2"
3758 [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3759 (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,RT,b")))]
3765 [(set_attr "op_type" "RRE,RXY,RIL")
3766 (set_attr "type" "*,*,larl")
3767 (set_attr "cpu_facility" "*,*,z10")
3768 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super_E1")])
3771 ; extend(hi|qi)(si|di)2 instruction pattern(s).
3774 (define_expand "extend<HQI:mode><DSI:mode>2"
3775 [(set (match_operand:DSI 0 "register_operand" "")
3776 (sign_extend:DSI (match_operand:HQI 1 "nonimmediate_operand" "")))]
3779 if (<DSI:MODE>mode == DImode && !TARGET_ZARCH)
3781 rtx tmp = gen_reg_rtx (SImode);
3782 emit_insn (gen_extend<HQI:mode>si2 (tmp, operands[1]));
3783 emit_insn (gen_extendsidi2 (operands[0], tmp));
3786 else if (!TARGET_EXTIMM)
3788 rtx bitcount = GEN_INT (<DSI:bitsize> - <HQI:bitsize>);
3790 operands[1] = gen_lowpart (<DSI:MODE>mode, operands[1]);
3791 emit_insn (gen_ashl<DSI:mode>3 (operands[0], operands[1], bitcount));
3792 emit_insn (gen_ashr<DSI:mode>3 (operands[0], operands[0], bitcount));
3798 ; extendhidi2 instruction pattern(s).
3801 (define_insn "*extendhidi2_extimm"
3802 [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3803 (sign_extend:DI (match_operand:HI 1 "general_operand" "d,RT,b")))]
3804 "TARGET_ZARCH && TARGET_EXTIMM"
3809 [(set_attr "op_type" "RRE,RXY,RIL")
3810 (set_attr "type" "*,*,larl")
3811 (set_attr "cpu_facility" "extimm,extimm,z10")
3812 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super_E1")])
3814 (define_insn "*extendhidi2"
3815 [(set (match_operand:DI 0 "register_operand" "=d")
3816 (sign_extend:DI (match_operand:HI 1 "memory_operand" "RT")))]
3819 [(set_attr "op_type" "RXY")
3820 (set_attr "z10prop" "z10_super_E1")])
3823 ; extendhisi2 instruction pattern(s).
3826 (define_insn "*extendhisi2_extimm"
3827 [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
3828 (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" " d,R,T,b")))]
3835 [(set_attr "op_type" "RRE,RX,RXY,RIL")
3836 (set_attr "type" "*,*,*,larl")
3837 (set_attr "cpu_facility" "extimm,extimm,extimm,z10")
3838 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super_E1,z10_super_E1")])
3840 (define_insn "*extendhisi2"
3841 [(set (match_operand:SI 0 "register_operand" "=d,d")
3842 (sign_extend:SI (match_operand:HI 1 "memory_operand" "R,T")))]
3847 [(set_attr "op_type" "RX,RXY")
3848 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3851 ; extendqi(si|di)2 instruction pattern(s).
3854 ; lbr, lgbr, lb, lgb
3855 (define_insn "*extendqi<mode>2_extimm"
3856 [(set (match_operand:GPR 0 "register_operand" "=d,d")
3857 (sign_extend:GPR (match_operand:QI 1 "nonimmediate_operand" "d,RT")))]
3862 [(set_attr "op_type" "RRE,RXY")
3863 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3866 (define_insn "*extendqi<mode>2"
3867 [(set (match_operand:GPR 0 "register_operand" "=d")
3868 (sign_extend:GPR (match_operand:QI 1 "memory_operand" "RT")))]
3869 "!TARGET_EXTIMM && TARGET_LONG_DISPLACEMENT"
3871 [(set_attr "op_type" "RXY")
3872 (set_attr "z10prop" "z10_super_E1")])
3874 (define_insn_and_split "*extendqi<mode>2_short_displ"
3875 [(set (match_operand:GPR 0 "register_operand" "=d")
3876 (sign_extend:GPR (match_operand:QI 1 "s_operand" "Q")))
3877 (clobber (reg:CC CC_REGNUM))]
3878 "!TARGET_EXTIMM && !TARGET_LONG_DISPLACEMENT"
3880 "&& reload_completed"
3882 [(set (match_dup 0) (unspec:GPR [(match_dup 1) (const_int 8)] UNSPEC_ICM))
3883 (clobber (reg:CC CC_REGNUM))])
3885 [(set (match_dup 0) (ashiftrt:GPR (match_dup 0) (match_dup 2)))
3886 (clobber (reg:CC CC_REGNUM))])]
3888 operands[1] = adjust_address (operands[1], BLKmode, 0);
3889 set_mem_size (operands[1], GET_MODE_SIZE (QImode));
3890 operands[2] = GEN_INT (<GPR:bitsize> - BITS_PER_UNIT);
3894 ; zero_extendsidi2 instruction pattern(s).
3897 (define_expand "zero_extendsidi2"
3898 [(set (match_operand:DI 0 "register_operand" "")
3899 (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "")))]
3904 emit_clobber (operands[0]);
3905 emit_move_insn (gen_lowpart (SImode, operands[0]), operands[1]);
3906 emit_move_insn (gen_highpart (SImode, operands[0]), const0_rtx);
3911 (define_insn "*zero_extendsidi2"
3912 [(set (match_operand:DI 0 "register_operand" "=d,d,d")
3913 (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,RT,b")))]
3919 [(set_attr "op_type" "RRE,RXY,RIL")
3920 (set_attr "type" "*,*,larl")
3921 (set_attr "cpu_facility" "*,*,z10")
3922 (set_attr "z10prop" "z10_fwd_E1,z10_fwd_A3,z10_fwd_A3")])
3925 ; LLGT-type instructions (zero-extend from 31 bit to 64 bit).
3928 (define_insn "*llgt_sidi"
3929 [(set (match_operand:DI 0 "register_operand" "=d")
3930 (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "RT") 0)
3931 (const_int 2147483647)))]
3934 [(set_attr "op_type" "RXE")
3935 (set_attr "z10prop" "z10_super_E1")])
3937 (define_insn_and_split "*llgt_sidi_split"
3938 [(set (match_operand:DI 0 "register_operand" "=d")
3939 (and:DI (subreg:DI (match_operand:SI 1 "memory_operand" "RT") 0)
3940 (const_int 2147483647)))
3941 (clobber (reg:CC CC_REGNUM))]
3944 "&& reload_completed"
3946 (and:DI (subreg:DI (match_dup 1) 0)
3947 (const_int 2147483647)))]
3950 (define_insn "*llgt_sisi"
3951 [(set (match_operand:SI 0 "register_operand" "=d,d")
3952 (and:SI (match_operand:SI 1 "nonimmediate_operand" "d,RT")
3953 (const_int 2147483647)))]
3958 [(set_attr "op_type" "RRE,RXE")
3959 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3961 (define_insn "*llgt_didi"
3962 [(set (match_operand:DI 0 "register_operand" "=d,d")
3963 (and:DI (match_operand:DI 1 "nonimmediate_operand" "d,o")
3964 (const_int 2147483647)))]
3969 [(set_attr "op_type" "RRE,RXE")
3970 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
3973 [(set (match_operand:DSI 0 "register_operand" "")
3974 (and:DSI (match_operand:DSI 1 "nonimmediate_operand" "")
3975 (const_int 2147483647)))
3976 (clobber (reg:CC CC_REGNUM))]
3977 "TARGET_ZARCH && reload_completed"
3979 (and:DSI (match_dup 1)
3980 (const_int 2147483647)))]
3984 ; zero_extend(hi|qi)(si|di)2 instruction pattern(s).
3987 (define_expand "zero_extend<mode>di2"
3988 [(set (match_operand:DI 0 "register_operand" "")
3989 (zero_extend:DI (match_operand:HQI 1 "nonimmediate_operand" "")))]
3994 rtx tmp = gen_reg_rtx (SImode);
3995 emit_insn (gen_zero_extend<mode>si2 (tmp, operands[1]));
3996 emit_insn (gen_zero_extendsidi2 (operands[0], tmp));
3999 else if (!TARGET_EXTIMM)
4001 rtx bitcount = GEN_INT (64 - <HQI:bitsize>);
4002 operands[1] = gen_lowpart (DImode, operands[1]);
4003 emit_insn (gen_ashldi3 (operands[0], operands[1], bitcount));
4004 emit_insn (gen_lshrdi3 (operands[0], operands[0], bitcount));
4009 (define_expand "zero_extend<mode>si2"
4010 [(set (match_operand:SI 0 "register_operand" "")
4011 (zero_extend:SI (match_operand:HQI 1 "nonimmediate_operand" "")))]
4016 operands[1] = gen_lowpart (SImode, operands[1]);
4017 emit_insn (gen_andsi3 (operands[0], operands[1],
4018 GEN_INT ((1 << <HQI:bitsize>) - 1)));
4024 (define_insn "*zero_extendhi<mode>2_z10"
4025 [(set (match_operand:GPR 0 "register_operand" "=d,d,d")
4026 (zero_extend:GPR (match_operand:HI 1 "nonimmediate_operand" "d,RT,b")))]
4032 [(set_attr "op_type" "RXY,RRE,RIL")
4033 (set_attr "type" "*,*,larl")
4034 (set_attr "cpu_facility" "*,*,z10")
4035 (set_attr "z10prop" "z10_super_E1,z10_fwd_A3,z10_fwd_A3")])
4037 ; llhr, llcr, llghr, llgcr, llh, llc, llgh, llgc
4038 (define_insn "*zero_extend<HQI:mode><GPR:mode>2_extimm"
4039 [(set (match_operand:GPR 0 "register_operand" "=d,d")
4040 (zero_extend:GPR (match_operand:HQI 1 "nonimmediate_operand" "d,RT")))]
4045 [(set_attr "op_type" "RRE,RXY")
4046 (set_attr "z10prop" "z10_super_E1,z10_fwd_A3")])
4049 (define_insn "*zero_extend<HQI:mode><GPR:mode>2"
4050 [(set (match_operand:GPR 0 "register_operand" "=d")
4051 (zero_extend:GPR (match_operand:HQI 1 "memory_operand" "RT")))]
4052 "TARGET_ZARCH && !TARGET_EXTIMM"
4054 [(set_attr "op_type" "RXY")
4055 (set_attr "z10prop" "z10_fwd_A3")])
4057 (define_insn_and_split "*zero_extendhisi2_31"
4058 [(set (match_operand:SI 0 "register_operand" "=&d")
4059 (zero_extend:SI (match_operand:HI 1 "s_operand" "QS")))
4060 (clobber (reg:CC CC_REGNUM))]
4063 "&& reload_completed"
4064 [(set (match_dup 0) (const_int 0))
4066 [(set (strict_low_part (match_dup 2)) (match_dup 1))
4067 (clobber (reg:CC CC_REGNUM))])]
4068 "operands[2] = gen_lowpart (HImode, operands[0]);")
4070 (define_insn_and_split "*zero_extendqisi2_31"
4071 [(set (match_operand:SI 0 "register_operand" "=&d")
4072 (zero_extend:SI (match_operand:QI 1 "memory_operand" "RT")))]
4075 "&& reload_completed"
4076 [(set (match_dup 0) (const_int 0))
4077 (set (strict_low_part (match_dup 2)) (match_dup 1))]
4078 "operands[2] = gen_lowpart (QImode, operands[0]);")
4081 ; zero_extendqihi2 instruction pattern(s).
4084 (define_expand "zero_extendqihi2"
4085 [(set (match_operand:HI 0 "register_operand" "")
4086 (zero_extend:HI (match_operand:QI 1 "register_operand" "")))]
4087 "TARGET_ZARCH && !TARGET_EXTIMM"
4089 operands[1] = gen_lowpart (HImode, operands[1]);
4090 emit_insn (gen_andhi3 (operands[0], operands[1], GEN_INT (0xff)));
4094 (define_insn "*zero_extendqihi2_64"
4095 [(set (match_operand:HI 0 "register_operand" "=d")
4096 (zero_extend:HI (match_operand:QI 1 "memory_operand" "RT")))]
4097 "TARGET_ZARCH && !TARGET_EXTIMM"
4099 [(set_attr "op_type" "RXY")
4100 (set_attr "z10prop" "z10_fwd_A3")])
4102 (define_insn_and_split "*zero_extendqihi2_31"
4103 [(set (match_operand:HI 0 "register_operand" "=&d")
4104 (zero_extend:HI (match_operand:QI 1 "memory_operand" "RT")))]
4107 "&& reload_completed"
4108 [(set (match_dup 0) (const_int 0))
4109 (set (strict_low_part (match_dup 2)) (match_dup 1))]
4110 "operands[2] = gen_lowpart (QImode, operands[0]);")
4113 ; fixuns_trunc(dd|td)di2 instruction pattern(s).
4116 (define_expand "fixuns_truncdddi2"
4118 [(set (match_operand:DI 0 "register_operand" "")
4119 (unsigned_fix:DI (match_operand:DD 1 "register_operand" "")))
4120 (unspec:DI [(const_int 5)] UNSPEC_ROUND)
4121 (clobber (reg:CC CC_REGNUM))])]
4127 rtx label1 = gen_label_rtx ();
4128 rtx label2 = gen_label_rtx ();
4129 rtx temp = gen_reg_rtx (TDmode);
4130 REAL_VALUE_TYPE cmp, sub;
4132 decimal_real_from_string (&cmp, "9223372036854775808.0"); /* 2^63 */
4133 decimal_real_from_string (&sub, "18446744073709551616.0"); /* 2^64 */
4135 /* 2^63 can't be represented as 64bit DFP number with full precision. The
4136 solution is doing the check and the subtraction in TD mode and using a
4137 TD -> DI convert afterwards. */
4138 emit_insn (gen_extendddtd2 (temp, operands[1]));
4139 temp = force_reg (TDmode, temp);
4140 emit_cmp_and_jump_insns (temp,
4141 CONST_DOUBLE_FROM_REAL_VALUE (cmp, TDmode),
4142 LT, NULL_RTX, VOIDmode, 0, label1);
4143 emit_insn (gen_subtd3 (temp, temp,
4144 CONST_DOUBLE_FROM_REAL_VALUE (sub, TDmode)));
4145 emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, GEN_INT (11)));
4148 emit_label (label1);
4149 emit_insn (gen_fix_truncdddi2_dfp (operands[0], operands[1], GEN_INT (9)));
4150 emit_label (label2);
4155 (define_expand "fixuns_trunctddi2"
4157 [(set (match_operand:DI 0 "register_operand" "")
4158 (unsigned_fix:DI (match_operand:TD 1 "register_operand" "")))
4159 (unspec:DI [(const_int 5)] UNSPEC_ROUND)
4160 (clobber (reg:CC CC_REGNUM))])]
4166 rtx label1 = gen_label_rtx ();
4167 rtx label2 = gen_label_rtx ();
4168 rtx temp = gen_reg_rtx (TDmode);
4169 REAL_VALUE_TYPE cmp, sub;
4171 operands[1] = force_reg (TDmode, operands[1]);
4172 decimal_real_from_string (&cmp, "9223372036854775808.0"); /* 2^63 */
4173 decimal_real_from_string (&sub, "18446744073709551616.0"); /* 2^64 */
4175 emit_cmp_and_jump_insns (operands[1],
4176 CONST_DOUBLE_FROM_REAL_VALUE (cmp, TDmode),
4177 LT, NULL_RTX, VOIDmode, 0, label1);
4178 emit_insn (gen_subtd3 (temp, operands[1],
4179 CONST_DOUBLE_FROM_REAL_VALUE (sub, TDmode)));
4180 emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, GEN_INT (11)));
4183 emit_label (label1);
4184 emit_insn (gen_fix_trunctddi2_dfp (operands[0], operands[1], GEN_INT (9)));
4185 emit_label (label2);
4191 ; fixuns_trunc(sf|df|tf)(si|di)2 and fix_trunc(sf|df|tf)(si|di)2
4192 ; instruction pattern(s).
4195 (define_expand "fixuns_trunc<BFP:mode><GPR:mode>2"
4197 [(set (match_operand:GPR 0 "register_operand" "")
4198 (unsigned_fix:GPR (match_operand:BFP 1 "register_operand" "")))
4199 (unspec:GPR [(const_int 5)] UNSPEC_ROUND)
4200 (clobber (reg:CC CC_REGNUM))])]
4205 rtx label1 = gen_label_rtx ();
4206 rtx label2 = gen_label_rtx ();
4207 rtx temp = gen_reg_rtx (<BFP:MODE>mode);
4208 REAL_VALUE_TYPE cmp, sub;
4210 operands[1] = force_reg (<BFP:MODE>mode, operands[1]);
4211 real_2expN (&cmp, <GPR:bitsize> - 1, <BFP:MODE>mode);
4212 real_2expN (&sub, <GPR:bitsize>, <BFP:MODE>mode);
4214 emit_cmp_and_jump_insns (operands[1],
4215 CONST_DOUBLE_FROM_REAL_VALUE (cmp, <BFP:MODE>mode),
4216 LT, NULL_RTX, VOIDmode, 0, label1);
4217 emit_insn (gen_sub<BFP:mode>3 (temp, operands[1],
4218 CONST_DOUBLE_FROM_REAL_VALUE (sub, <BFP:MODE>mode)));
4219 emit_insn (gen_fix_trunc<BFP:mode><GPR:mode>2_bfp (operands[0], temp,
4223 emit_label (label1);
4224 emit_insn (gen_fix_trunc<BFP:mode><GPR:mode>2_bfp (operands[0],
4225 operands[1], GEN_INT (5)));
4226 emit_label (label2);
4231 ; fixuns_trunc(td|dd)si2 expander
4232 (define_expand "fixuns_trunc<mode>si2"
4234 [(set (match_operand:SI 0 "register_operand" "")
4235 (unsigned_fix:SI (match_operand:DFP 1 "register_operand" "")))
4236 (unspec:SI [(const_int 5)] UNSPEC_ROUND)
4237 (clobber (reg:CC CC_REGNUM))])]
4238 "TARGET_Z196 && TARGET_HARD_DFP"
4241 ; fixuns_trunc(tf|df|sf|td|dd)(di|si)2 instruction patterns.
4243 ; clfebr, clfdbr, clfxbr, clgebr, clgdbr, clgxbr
4244 ; clfdtr, clfxtr, clgdtr, clgxtr
4245 (define_insn "*fixuns_trunc<FP:mode><GPR:mode>2_z196"
4246 [(set (match_operand:GPR 0 "register_operand" "=r")
4247 (unsigned_fix:GPR (match_operand:FP 1 "register_operand" "f")))
4248 (unspec:GPR [(match_operand:GPR 2 "immediate_operand" "K")] UNSPEC_ROUND)
4249 (clobber (reg:CC CC_REGNUM))]
4251 "cl<GPR:gf><FP:xde><FP:bt>r\t%0,%h2,%1,0"
4252 [(set_attr "op_type" "RRF")
4253 (set_attr "type" "ftoi")])
4255 (define_expand "fix_trunc<DSF:mode><GPR:mode>2"
4256 [(set (match_operand:GPR 0 "register_operand" "")
4257 (fix:GPR (match_operand:DSF 1 "register_operand" "")))]
4260 emit_insn (gen_fix_trunc<DSF:mode><GPR:mode>2_bfp (operands[0], operands[1],
4265 ; cgxbr, cgdbr, cgebr, cfxbr, cfdbr, cfebr
4266 (define_insn "fix_trunc<BFP:mode><GPR:mode>2_bfp"
4267 [(set (match_operand:GPR 0 "register_operand" "=d")
4268 (fix:GPR (match_operand:BFP 1 "register_operand" "f")))
4269 (unspec:GPR [(match_operand:GPR 2 "immediate_operand" "K")] UNSPEC_ROUND)
4270 (clobber (reg:CC CC_REGNUM))]
4272 "c<GPR:gf><BFP:xde>br\t%0,%h2,%1"
4273 [(set_attr "op_type" "RRE")
4274 (set_attr "type" "ftoi")])
4278 ; fix_trunc(td|dd)di2 instruction pattern(s).
4281 (define_expand "fix_trunc<mode>di2"
4282 [(set (match_operand:DI 0 "register_operand" "")
4283 (fix:DI (match_operand:DFP 1 "nonimmediate_operand" "")))]
4284 "TARGET_ZARCH && TARGET_HARD_DFP"
4286 operands[1] = force_reg (<MODE>mode, operands[1]);
4287 emit_insn (gen_fix_trunc<mode>di2_dfp (operands[0], operands[1],
4293 (define_insn "fix_trunc<DFP:mode>di2_dfp"
4294 [(set (match_operand:DI 0 "register_operand" "=d")
4295 (fix:DI (match_operand:DFP 1 "register_operand" "f")))
4296 (unspec:DI [(match_operand:DI 2 "immediate_operand" "K")] UNSPEC_ROUND)
4297 (clobber (reg:CC CC_REGNUM))]
4298 "TARGET_ZARCH && TARGET_HARD_DFP"
4299 "cg<DFP:xde>tr\t%0,%h2,%1"
4300 [(set_attr "op_type" "RRF")
4301 (set_attr "type" "ftoidfp")])
4305 ; fix_trunctf(si|di)2 instruction pattern(s).
4308 (define_expand "fix_trunctf<mode>2"
4309 [(parallel [(set (match_operand:GPR 0 "register_operand" "")
4310 (fix:GPR (match_operand:TF 1 "register_operand" "")))
4311 (unspec:GPR [(const_int 5)] UNSPEC_ROUND)
4312 (clobber (reg:CC CC_REGNUM))])]
4318 ; float(si|di)(tf|df|sf|td|dd)2 instruction pattern(s).
4321 ; cxgbr, cdgbr, cegbr, cxgtr, cdgtr
4322 (define_insn "floatdi<mode>2"
4323 [(set (match_operand:FP 0 "register_operand" "=f")
4324 (float:FP (match_operand:DI 1 "register_operand" "d")))]
4325 "TARGET_ZARCH && TARGET_HARD_FLOAT"
4326 "c<xde>g<bt>r\t%0,%1"
4327 [(set_attr "op_type" "RRE")
4328 (set_attr "type" "itof<mode>" )])
4330 ; cxfbr, cdfbr, cefbr
4331 (define_insn "floatsi<mode>2"
4332 [(set (match_operand:BFP 0 "register_operand" "=f")
4333 (float:BFP (match_operand:SI 1 "register_operand" "d")))]
4336 [(set_attr "op_type" "RRE")
4337 (set_attr "type" "itof<mode>" )])
4340 (define_insn "floatsi<mode>2"
4341 [(set (match_operand:DFP 0 "register_operand" "=f")
4342 (float:DFP (match_operand:SI 1 "register_operand" "d")))]
4343 "TARGET_Z196 && TARGET_HARD_FLOAT"
4344 "c<xde>ftr\t%0,0,%1,0"
4345 [(set_attr "op_type" "RRE")
4346 (set_attr "type" "itof<mode>" )])
4349 ; floatuns(si|di)(tf|df|sf|td|dd)2 instruction pattern(s).
4352 ; cxlgbr, cdlgbr, celgbr, cxlgtr, cdlgtr
4353 ; cxlfbr, cdlfbr, celfbr, cxlftr, cdlftr
4354 (define_insn "floatuns<GPR:mode><FP:mode>2"
4355 [(set (match_operand:FP 0 "register_operand" "=f")
4356 (unsigned_float:FP (match_operand:GPR 1 "register_operand" "d")))]
4357 "TARGET_Z196 && TARGET_HARD_FLOAT"
4358 "c<FP:xde>l<GPR:gf><FP:bt>r\t%0,0,%1,0"
4359 [(set_attr "op_type" "RRE")
4360 (set_attr "type" "itof<FP:mode>" )])
4363 ; truncdfsf2 instruction pattern(s).
4366 (define_insn "truncdfsf2"
4367 [(set (match_operand:SF 0 "register_operand" "=f")
4368 (float_truncate:SF (match_operand:DF 1 "register_operand" "f")))]
4371 [(set_attr "op_type" "RRE")
4372 (set_attr "type" "ftruncdf")])
4375 ; trunctf(df|sf)2 instruction pattern(s).
4379 (define_insn "trunctf<mode>2"
4380 [(set (match_operand:DSF 0 "register_operand" "=f")
4381 (float_truncate:DSF (match_operand:TF 1 "register_operand" "f")))
4382 (clobber (match_scratch:TF 2 "=f"))]
4384 "l<xde>xbr\t%2,%1\;l<xde>r\t%0,%2"
4385 [(set_attr "length" "6")
4386 (set_attr "type" "ftrunctf")])
4389 ; trunctddd2 and truncddsd2 instruction pattern(s).
4392 (define_insn "trunctddd2"
4393 [(set (match_operand:DD 0 "register_operand" "=f")
4394 (float_truncate:DD (match_operand:TD 1 "register_operand" "f")))
4395 (clobber (match_scratch:TD 2 "=f"))]
4397 "ldxtr\t%2,0,%1,0\;ldr\t%0,%2"
4398 [(set_attr "length" "6")
4399 (set_attr "type" "ftruncdd")])
4401 (define_insn "truncddsd2"
4402 [(set (match_operand:SD 0 "register_operand" "=f")
4403 (float_truncate:SD (match_operand:DD 1 "register_operand" "f")))]
4406 [(set_attr "op_type" "RRF")
4407 (set_attr "type" "ftruncsd")])
4410 ; extend(sf|df)(df|tf)2 instruction pattern(s).
4413 ; ldebr, ldeb, lxdbr, lxdb, lxebr, lxeb
4414 (define_insn "extend<DSF:mode><BFP:mode>2"
4415 [(set (match_operand:BFP 0 "register_operand" "=f,f")
4416 (float_extend:BFP (match_operand:DSF 1 "nonimmediate_operand" "f,R")))]
4418 && GET_MODE_SIZE (<BFP:MODE>mode) > GET_MODE_SIZE (<DSF:MODE>mode)"
4420 l<BFP:xde><DSF:xde>br\t%0,%1
4421 l<BFP:xde><DSF:xde>b\t%0,%1"
4422 [(set_attr "op_type" "RRE,RXE")
4423 (set_attr "type" "fsimp<BFP:mode>, fload<BFP:mode>")])
4426 ; extendddtd2 and extendsddd2 instruction pattern(s).
4429 (define_insn "extendddtd2"
4430 [(set (match_operand:TD 0 "register_operand" "=f")
4431 (float_extend:TD (match_operand:DD 1 "register_operand" "f")))]
4434 [(set_attr "op_type" "RRF")
4435 (set_attr "type" "fsimptf")])
4437 (define_insn "extendsddd2"
4438 [(set (match_operand:DD 0 "register_operand" "=f")
4439 (float_extend:DD (match_operand:SD 1 "register_operand" "f")))]
4442 [(set_attr "op_type" "RRF")
4443 (set_attr "type" "fsimptf")])
4445 ; Binary Floating Point - load fp integer
4447 ; Expanders for: floor, btrunc, round, ceil, and nearbyint
4448 ; For all of them the inexact exceptions are suppressed.
4450 ; fiebra, fidbra, fixbra
4451 (define_insn "<FPINT:fpint_name><BFP:mode>2"
4452 [(set (match_operand:BFP 0 "register_operand" "=f")
4453 (unspec:BFP [(match_operand:BFP 1 "register_operand" "f")]
4456 "fi<BFP:xde>bra\t%0,<FPINT:fpint_roundingmode>,%1,4"
4457 [(set_attr "op_type" "RRF")
4458 (set_attr "type" "fsimp<BFP:mode>")])
4460 ; rint is supposed to raise an inexact exception so we can use the
4461 ; older instructions.
4463 ; fiebr, fidbr, fixbr
4464 (define_insn "rint<BFP:mode>2"
4465 [(set (match_operand:BFP 0 "register_operand" "=f")
4466 (unspec:BFP [(match_operand:BFP 1 "register_operand" "f")]
4467 UNSPEC_FPINT_RINT))]
4469 "fi<BFP:xde>br\t%0,0,%1"
4470 [(set_attr "op_type" "RRF")
4471 (set_attr "type" "fsimp<BFP:mode>")])
4474 ; Decimal Floating Point - load fp integer
4477 (define_insn "<FPINT:fpint_name><DFP:mode>2"
4478 [(set (match_operand:DFP 0 "register_operand" "=f")
4479 (unspec:DFP [(match_operand:DFP 1 "register_operand" "f")]
4482 "fi<DFP:xde>tr\t%0,<FPINT:fpint_roundingmode>,%1,4"
4483 [(set_attr "op_type" "RRF")
4484 (set_attr "type" "fsimp<DFP:mode>")])
4487 (define_insn "rint<DFP:mode>2"
4488 [(set (match_operand:DFP 0 "register_operand" "=f")
4489 (unspec:DFP [(match_operand:DFP 1 "register_operand" "f")]
4490 UNSPEC_FPINT_RINT))]
4492 "fi<DFP:xde>tr\t%0,0,%1,0"
4493 [(set_attr "op_type" "RRF")
4494 (set_attr "type" "fsimp<DFP:mode>")])
4497 ; Binary <-> Decimal floating point trunc patterns
4500 (define_insn "*trunc<BFP:mode><DFP_ALL:mode>2"
4501 [(set (reg:DFP_ALL FPR0_REGNUM)
4502 (float_truncate:DFP_ALL (reg:BFP FPR4_REGNUM)))
4503 (use (reg:SI GPR0_REGNUM))
4504 (clobber (reg:CC CC_REGNUM))]
4508 (define_insn "*trunc<DFP_ALL:mode><BFP:mode>2"
4509 [(set (reg:BFP FPR0_REGNUM)
4510 (float_truncate:BFP (reg:DFP_ALL FPR4_REGNUM)))
4511 (use (reg:SI GPR0_REGNUM))
4512 (clobber (reg:CC CC_REGNUM))]
4516 (define_expand "trunc<BFP:mode><DFP_ALL:mode>2"
4517 [(set (reg:BFP FPR4_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" ""))
4518 (set (reg:SI GPR0_REGNUM) (match_dup 2))
4520 [(set (reg:DFP_ALL FPR0_REGNUM)
4521 (float_truncate:DFP_ALL (reg:BFP FPR4_REGNUM)))
4522 (use (reg:SI GPR0_REGNUM))
4523 (clobber (reg:CC CC_REGNUM))])
4524 (set (match_operand:DFP_ALL 0 "nonimmediate_operand" "")
4525 (reg:DFP_ALL FPR0_REGNUM))]
4527 && GET_MODE_SIZE (<BFP:MODE>mode) > GET_MODE_SIZE (<DFP_ALL:MODE>mode)"
4529 HOST_WIDE_INT flags;
4531 flags = (PFPO_CONVERT |
4532 PFPO_OP_TYPE_<DFP_ALL:MODE> << PFPO_OP0_TYPE_SHIFT |
4533 PFPO_OP_TYPE_<BFP:MODE> << PFPO_OP1_TYPE_SHIFT);
4535 operands[2] = GEN_INT (flags);
4538 (define_expand "trunc<DFP_ALL:mode><BFP:mode>2"
4539 [(set (reg:DFP_ALL FPR4_REGNUM)
4540 (match_operand:DFP_ALL 1 "nonimmediate_operand" ""))
4541 (set (reg:SI GPR0_REGNUM) (match_dup 2))
4543 [(set (reg:BFP FPR0_REGNUM) (float_truncate:BFP (reg:DFP_ALL FPR4_REGNUM)))
4544 (use (reg:SI GPR0_REGNUM))
4545 (clobber (reg:CC CC_REGNUM))])
4546 (set (match_operand:BFP 0 "nonimmediate_operand" "") (reg:BFP FPR0_REGNUM))]
4548 && GET_MODE_SIZE (<DFP_ALL:MODE>mode) >= GET_MODE_SIZE (<BFP:MODE>mode)"
4550 HOST_WIDE_INT flags;
4552 flags = (PFPO_CONVERT |
4553 PFPO_OP_TYPE_<BFP:MODE> << PFPO_OP0_TYPE_SHIFT |
4554 PFPO_OP_TYPE_<DFP_ALL:MODE> << PFPO_OP1_TYPE_SHIFT);
4556 operands[2] = GEN_INT (flags);
4560 ; Binary <-> Decimal floating point extend patterns
4563 (define_insn "*extend<BFP:mode><DFP_ALL:mode>2"
4564 [(set (reg:DFP_ALL FPR0_REGNUM) (float_extend:DFP_ALL (reg:BFP FPR4_REGNUM)))
4565 (use (reg:SI GPR0_REGNUM))
4566 (clobber (reg:CC CC_REGNUM))]
4570 (define_insn "*extend<DFP_ALL:mode><BFP:mode>2"
4571 [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR4_REGNUM)))
4572 (use (reg:SI GPR0_REGNUM))
4573 (clobber (reg:CC CC_REGNUM))]
4577 (define_expand "extend<BFP:mode><DFP_ALL:mode>2"
4578 [(set (reg:BFP FPR4_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" ""))
4579 (set (reg:SI GPR0_REGNUM) (match_dup 2))
4581 [(set (reg:DFP_ALL FPR0_REGNUM)
4582 (float_extend:DFP_ALL (reg:BFP FPR4_REGNUM)))
4583 (use (reg:SI GPR0_REGNUM))
4584 (clobber (reg:CC CC_REGNUM))])
4585 (set (match_operand:DFP_ALL 0 "nonimmediate_operand" "")
4586 (reg:DFP_ALL FPR0_REGNUM))]
4588 && GET_MODE_SIZE (<BFP:MODE>mode) <= GET_MODE_SIZE (<DFP_ALL:MODE>mode)"
4590 HOST_WIDE_INT flags;
4592 flags = (PFPO_CONVERT |
4593 PFPO_OP_TYPE_<DFP_ALL:MODE> << PFPO_OP0_TYPE_SHIFT |
4594 PFPO_OP_TYPE_<BFP:MODE> << PFPO_OP1_TYPE_SHIFT);
4596 operands[2] = GEN_INT (flags);
4599 (define_expand "extend<DFP_ALL:mode><BFP:mode>2"
4600 [(set (reg:DFP_ALL FPR4_REGNUM)
4601 (match_operand:DFP_ALL 1 "nonimmediate_operand" ""))
4602 (set (reg:SI GPR0_REGNUM) (match_dup 2))
4604 [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR4_REGNUM)))
4605 (use (reg:SI GPR0_REGNUM))
4606 (clobber (reg:CC CC_REGNUM))])
4607 (set (match_operand:BFP 0 "nonimmediate_operand" "") (reg:BFP FPR0_REGNUM))]
4609 && GET_MODE_SIZE (<DFP_ALL:MODE>mode) < GET_MODE_SIZE (<BFP:MODE>mode)"
4611 HOST_WIDE_INT flags;
4613 flags = (PFPO_CONVERT |
4614 PFPO_OP_TYPE_<BFP:MODE> << PFPO_OP0_TYPE_SHIFT |
4615 PFPO_OP_TYPE_<DFP_ALL:MODE> << PFPO_OP1_TYPE_SHIFT);
4617 operands[2] = GEN_INT (flags);
4622 ;; ARITHMETIC OPERATIONS
4624 ; arithmetic operations set the ConditionCode,
4625 ; because of unpredictable Bits in Register for Halfword and Byte
4626 ; the ConditionCode can be set wrong in operations for Halfword and Byte
4629 ;;- Add instructions.
4633 ; addti3 instruction pattern(s).
4636 (define_insn_and_split "addti3"
4637 [(set (match_operand:TI 0 "register_operand" "=&d")
4638 (plus:TI (match_operand:TI 1 "nonimmediate_operand" "%0")
4639 (match_operand:TI 2 "general_operand" "do") ) )
4640 (clobber (reg:CC CC_REGNUM))]
4643 "&& reload_completed"
4645 [(set (reg:CCL1 CC_REGNUM)
4646 (compare:CCL1 (plus:DI (match_dup 7) (match_dup 8))
4648 (set (match_dup 6) (plus:DI (match_dup 7) (match_dup 8)))])
4650 [(set (match_dup 3) (plus:DI
4651 (plus:DI (ltu:DI (reg:CCL1 CC_REGNUM) (const_int 0))
4652 (match_dup 4)) (match_dup 5)))
4653 (clobber (reg:CC CC_REGNUM))])]
4654 "operands[3] = operand_subword (operands[0], 0, 0, TImode);
4655 operands[4] = operand_subword (operands[1], 0, 0, TImode);
4656 operands[5] = operand_subword (operands[2], 0, 0, TImode);
4657 operands[6] = operand_subword (operands[0], 1, 0, TImode);
4658 operands[7] = operand_subword (operands[1], 1, 0, TImode);
4659 operands[8] = operand_subword (operands[2], 1, 0, TImode);")
4662 ; adddi3 instruction pattern(s).
4665 (define_expand "adddi3"
4667 [(set (match_operand:DI 0 "nonimmediate_operand" "")
4668 (plus:DI (match_operand:DI 1 "nonimmediate_operand" "")
4669 (match_operand:DI 2 "general_operand" "")))
4670 (clobber (reg:CC CC_REGNUM))])]
4674 (define_insn "*adddi3_sign"
4675 [(set (match_operand:DI 0 "register_operand" "=d,d")
4676 (plus:DI (sign_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))
4677 (match_operand:DI 1 "register_operand" "0,0")))
4678 (clobber (reg:CC CC_REGNUM))]
4683 [(set_attr "op_type" "RRE,RXY")
4684 (set_attr "z196prop" "z196_cracked,z196_cracked")])
4686 (define_insn "*adddi3_zero_cc"
4687 [(set (reg CC_REGNUM)
4688 (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))
4689 (match_operand:DI 1 "register_operand" "0,0"))
4691 (set (match_operand:DI 0 "register_operand" "=d,d")
4692 (plus:DI (zero_extend:DI (match_dup 2)) (match_dup 1)))]
4693 "s390_match_ccmode (insn, CCLmode) && TARGET_ZARCH"
4697 [(set_attr "op_type" "RRE,RXY")
4698 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
4700 (define_insn "*adddi3_zero_cconly"
4701 [(set (reg CC_REGNUM)
4702 (compare (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))
4703 (match_operand:DI 1 "register_operand" "0,0"))
4705 (clobber (match_scratch:DI 0 "=d,d"))]
4706 "s390_match_ccmode (insn, CCLmode) && TARGET_ZARCH"
4710 [(set_attr "op_type" "RRE,RXY")
4711 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
4713 (define_insn "*adddi3_zero"
4714 [(set (match_operand:DI 0 "register_operand" "=d,d")
4715 (plus:DI (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))
4716 (match_operand:DI 1 "register_operand" "0,0")))
4717 (clobber (reg:CC CC_REGNUM))]
4722 [(set_attr "op_type" "RRE,RXY")
4723 (set_attr "z10prop" "z10_super_E1,z10_super_E1")])
4725 (define_insn_and_split "*adddi3_31z"
4726 [(set (match_operand:DI 0 "nonimmediate_operand" "=&d")
4727 (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
4728 (match_operand:DI 2 "general_operand" "do") ) )
4729 (clobber (reg:CC CC_REGNUM))]
4730 "!TARGET_ZARCH && TARGET_CPU_ZARCH"
4732 "&& reload_completed"
4734 [(set (reg:CCL1 CC_REGNUM)
4735 (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
4737 (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
4739 [(set (match_dup 3) (plus:SI
4740 (plus:SI (ltu:SI (reg:CCL1 CC_REGNUM) (const_int 0))
4741 (match_dup 4)) (match_dup 5)))
4742 (clobber (reg:CC CC_REGNUM))])]
4743 "operands[3] = operand_subword (operands[0], 0, 0, DImode);
4744 operands[4] = operand_subword (operands[1], 0, 0, DImode);
4745 operands[5] = operand_subword (operands[2], 0, 0, DImode);
4746 operands[6] = operand_subword (operands[0], 1, 0, DImode);
4747 operands[7] = operand_subword (operands[1], 1, 0, DImode);
4748 operands[8] = operand_subword (operands[2], 1, 0, DImode);")
4750 (define_insn_and_split "*adddi3_31"
4751 [(set (match_operand:DI 0 "nonimmediate_operand" "=&d")
4752 (plus:DI (match_operand:DI 1 "nonimmediate_operand" "%0")
4753 (match_operand:DI 2 "general_operand" "do") ) )
4754 (clobber (reg:CC CC_REGNUM))]
4757 "&& reload_completed"
4759 [(set (match_dup 3) (plus:SI (match_dup 4) (match_dup 5)))
4760 (clobber (reg:CC CC_REGNUM))])
4762 [(set (reg:CCL1 CC_REGNUM)
4763 (compare:CCL1 (plus:SI (match_dup 7) (match_dup 8))
4765 (set (match_dup 6) (plus:SI (match_dup 7) (match_dup 8)))])
4767 (if_then_else (ltu (reg:CCL1 CC_REGNUM) (const_int 0))
4769 (label_ref (match_dup 9))))
4771 [(set (match_dup 3) (plus:SI (match_dup 3) (const_int 1)))
4772 (clobber (reg:CC CC_REGNUM))])
4774 "operands[3] = operand_subword (operands[0], 0, 0, DImode);
4775 operands[4] = operand_subword (operands[1], 0, 0, DImode);
4776 operands[5] = operand_subword (operands[2], 0, 0, DImode);
4777 operands[6] = operand_subword (operands[0], 1, 0, DImode);
4778 operands[7] = operand_subword (operands[1], 1, 0, DImode);
4779 operands[8] = operand_subword (operands[2], 1, 0, DImode);
4780 operands[9] = gen_label_rtx ();")
4783 ; addsi3 instruction pattern(s).
4786 (define_expand "addsi3"
4788 [(set (match_operand:SI 0 "nonimmediate_operand" "")
4789 (plus:SI (match_operand:SI 1 "nonimmediate_operand" "")
4790 (match_operand:SI 2 "general_operand" "")))
4791 (clobber (reg:CC CC_REGNUM))])]
4795 (define_insn "*addsi3_sign"
4796 [(set (match_operand:SI 0 "register_operand" "=d,d")
4797 (plus:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))
4798 (match_operand:SI 1 "register_operand" "0,0")))
4799 (clobber (reg:CC CC_REGNUM))]
4804 [(set_attr "op_type" "RX,RXY")
4805 (set_attr "z196prop" "z196_cracked,z196_cracked")])
4808 ; add(di|si)3 instruction pattern(s).
4811 ; ark, agrk, ar, ahi, ahik, aghik, alfi, slfi, a, ay, agr, aghi, algfi, slgfi, ag, asi, agsi
4812 (define_insn "*add<mode>3"
4813 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d,d,d,d, d, d,d,d,QS")
4814 (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d,0,d, 0, 0,0,0, 0")
4815 (match_operand:GPR 2 "general_operand" " d,d,K,K,Op,On,R,T, C") ) )
4816 (clobber (reg:CC CC_REGNUM))]
4828 [(set_attr "op_type" "RR<E>,RRF,RI,RIE,RIL,RIL,RX<Y>,RXY,SIY")
4829 (set_attr "cpu_facility" "*,z196,*,z196,extimm,extimm,*,*,z10")
4830 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,*,z10_super_E1,z10_super_E1,
4831 z10_super_E1,z10_super_E1,z10_super_E1")])
4833 ; alr, alfi, slfi, al, aly, alrk, alhsik, algr, algfi, slgfi, alg, alsi, algsi, algrk, alghsik
4834 (define_insn "*add<mode>3_carry1_cc"
4835 [(set (reg CC_REGNUM)
4836 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d, 0, 0,d,0,0,0")
4837 (match_operand:GPR 2 "general_operand" " d,d,Op,On,K,R,T,C"))
4839 (set (match_operand:GPR 0 "nonimmediate_operand" "=d,d, d, d,d,d,d,d")
4840 (plus:GPR (match_dup 1) (match_dup 2)))]
4841 "s390_match_ccmode (insn, CCL1mode)"
4847 al<g>hsik\t%0,%1,%h2
4851 [(set_attr "op_type" "RR<E>,RRF,RIL,RIL,RIE,RX<Y>,RXY,SIY")
4852 (set_attr "cpu_facility" "*,z196,extimm,extimm,z196,*,*,z10")
4853 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1,*,
4854 z10_super_E1,z10_super_E1,z10_super_E1")])
4856 ; alr, al, aly, algr, alg, alrk, algrk
4857 (define_insn "*add<mode>3_carry1_cconly"
4858 [(set (reg CC_REGNUM)
4859 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d,0,0")
4860 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
4862 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
4863 "s390_match_ccmode (insn, CCL1mode)"
4869 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
4870 (set_attr "cpu_facility" "*,z196,*,*")
4871 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
4873 ; alr, alfi, slfi, al, aly, algr, algfi, slgfi, alg, alsi, algsi, alrk, algrk, alhsik, alghsik
4874 (define_insn "*add<mode>3_carry2_cc"
4875 [(set (reg CC_REGNUM)
4876 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d, 0, 0,d,0,0, 0")
4877 (match_operand:GPR 2 "general_operand" " d,d,Op,On,K,R,T, C"))
4879 (set (match_operand:GPR 0 "nonimmediate_operand" "=d,d, d, d,d,d,d,RS")
4880 (plus:GPR (match_dup 1) (match_dup 2)))]
4881 "s390_match_ccmode (insn, CCL1mode)"
4887 al<g>hsik\t%0,%1,%h2
4891 [(set_attr "op_type" "RR<E>,RRF,RIL,RIL,RIE,RX<Y>,RXY,SIY")
4892 (set_attr "cpu_facility" "*,z196,extimm,extimm,z196,*,*,z10")
4893 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1,*,
4894 z10_super_E1,z10_super_E1,z10_super_E1")])
4896 ; alr, al, aly, algr, alg, alrk, algrk
4897 (define_insn "*add<mode>3_carry2_cconly"
4898 [(set (reg CC_REGNUM)
4899 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d,0,0")
4900 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
4902 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
4903 "s390_match_ccmode (insn, CCL1mode)"
4909 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
4910 (set_attr "cpu_facility" "*,z196,*,*")
4911 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
4913 ; alr, alfi, slfi, al, aly, algr, algfi, slgfi, alg, alsi, algsi, alrk, algrk, alhsik, alghsik
4914 (define_insn "*add<mode>3_cc"
4915 [(set (reg CC_REGNUM)
4916 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d, 0, 0,d,0,0, 0")
4917 (match_operand:GPR 2 "general_operand" " d,d,Op,On,K,R,T, C"))
4919 (set (match_operand:GPR 0 "nonimmediate_operand" "=d,d, d, d,d,d,d,RS")
4920 (plus:GPR (match_dup 1) (match_dup 2)))]
4921 "s390_match_ccmode (insn, CCLmode)"
4927 al<g>hsik\t%0,%1,%h2
4931 [(set_attr "op_type" "RR<E>,RRF,RIL,RIL,RIE,RX<Y>,RXY,SIY")
4932 (set_attr "cpu_facility" "*,z196,extimm,extimm,z196,*,*,z10")
4933 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1,
4934 *,z10_super_E1,z10_super_E1,z10_super_E1")])
4936 ; alr, al, aly, algr, alg, alrk, algrk
4937 (define_insn "*add<mode>3_cconly"
4938 [(set (reg CC_REGNUM)
4939 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" "%0,d,0,0")
4940 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
4942 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
4943 "s390_match_ccmode (insn, CCLmode)"
4949 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
4950 (set_attr "cpu_facility" "*,z196,*,*")
4951 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
4953 ; alr, al, aly, algr, alg, alrk, algrk
4954 (define_insn "*add<mode>3_cconly2"
4955 [(set (reg CC_REGNUM)
4956 (compare (match_operand:GPR 1 "nonimmediate_operand" "%0,d,0,0")
4957 (neg:GPR (match_operand:GPR 2 "general_operand" "d,d,R,T"))))
4958 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
4959 "s390_match_ccmode(insn, CCLmode)"
4965 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
4966 (set_attr "cpu_facility" "*,z196,*,*")
4967 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
4969 ; ahi, afi, aghi, agfi, asi, agsi
4970 (define_insn "*add<mode>3_imm_cc"
4971 [(set (reg CC_REGNUM)
4972 (compare (plus:GPR (match_operand:GPR 1 "nonimmediate_operand" " 0, d,0, 0")
4973 (match_operand:GPR 2 "const_int_operand" " K, K,Os, C"))
4975 (set (match_operand:GPR 0 "nonimmediate_operand" "=d, d,d,QS")
4976 (plus:GPR (match_dup 1) (match_dup 2)))]
4977 "s390_match_ccmode (insn, CCAmode)
4978 && (CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'K', \"K\")
4979 || (CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[2]), 'O', \"Os\")
4980 /* Avoid INT32_MIN on 32 bit. */
4981 && (!TARGET_ZARCH || INTVAL (operands[2]) != -0x7fffffff - 1)))"
4987 [(set_attr "op_type" "RI,RIE,RIL,SIY")
4988 (set_attr "cpu_facility" "*,z196,extimm,z10")
4989 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
4992 ; add(tf|df|sf|td|dd)3 instruction pattern(s).
4995 ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr
4996 (define_insn "add<mode>3"
4997 [(set (match_operand:FP 0 "register_operand" "=f, f")
4998 (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%<f0>,0")
4999 (match_operand:FP 2 "general_operand" " f,<Rf>")))
5000 (clobber (reg:CC CC_REGNUM))]
5003 a<xde><bt>r\t%0,<op1>%2
5005 [(set_attr "op_type" "<RRer>,RXE")
5006 (set_attr "type" "fsimp<mode>")])
5008 ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr
5009 (define_insn "*add<mode>3_cc"
5010 [(set (reg CC_REGNUM)
5011 (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%<f0>,0")
5012 (match_operand:FP 2 "general_operand" " f,<Rf>"))
5013 (match_operand:FP 3 "const0_operand" "")))
5014 (set (match_operand:FP 0 "register_operand" "=f,f")
5015 (plus:FP (match_dup 1) (match_dup 2)))]
5016 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
5018 a<xde><bt>r\t%0,<op1>%2
5020 [(set_attr "op_type" "<RRer>,RXE")
5021 (set_attr "type" "fsimp<mode>")])
5023 ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr
5024 (define_insn "*add<mode>3_cconly"
5025 [(set (reg CC_REGNUM)
5026 (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%<f0>,0")
5027 (match_operand:FP 2 "general_operand" " f,<Rf>"))
5028 (match_operand:FP 3 "const0_operand" "")))
5029 (clobber (match_scratch:FP 0 "=f,f"))]
5030 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
5032 a<xde><bt>r\t%0,<op1>%2
5034 [(set_attr "op_type" "<RRer>,RXE")
5035 (set_attr "type" "fsimp<mode>")])
5038 ; Pointer add instruction patterns
5041 ; This will match "*la_64"
5042 (define_expand "addptrdi3"
5043 [(set (match_operand:DI 0 "register_operand" "")
5044 (plus:DI (match_operand:DI 1 "register_operand" "")
5045 (match_operand:DI 2 "nonmemory_operand" "")))]
5048 if (GET_CODE (operands[2]) == CONST_INT)
5050 HOST_WIDE_INT c = INTVAL (operands[2]);
5052 if (!CONST_OK_FOR_CONSTRAINT_P (c, 'K', "K")
5053 && !CONST_OK_FOR_CONSTRAINT_P (c, 'O', "Os"))
5055 operands[2] = force_const_mem (DImode, operands[2]);
5056 operands[2] = force_reg (DImode, operands[2]);
5058 else if (!DISP_IN_RANGE (INTVAL (operands[2])))
5059 operands[2] = force_reg (DImode, operands[2]);
5063 ; For 31 bit we have to prevent the generated pattern from matching
5064 ; normal ADDs since la only does a 31 bit add. This is supposed to
5065 ; match "force_la_31".
5066 (define_expand "addptrsi3"
5068 [(set (match_operand:SI 0 "register_operand" "")
5069 (plus:SI (match_operand:SI 1 "register_operand" "")
5070 (match_operand:SI 2 "nonmemory_operand" "")))
5071 (use (const_int 0))])]
5074 if (GET_CODE (operands[2]) == CONST_INT)
5076 HOST_WIDE_INT c = INTVAL (operands[2]);
5078 if (!CONST_OK_FOR_CONSTRAINT_P (c, 'K', "K")
5079 && !CONST_OK_FOR_CONSTRAINT_P (c, 'O', "Os"))
5081 operands[2] = force_const_mem (SImode, operands[2]);
5082 operands[2] = force_reg (SImode, operands[2]);
5084 else if (!DISP_IN_RANGE (INTVAL (operands[2])))
5085 operands[2] = force_reg (SImode, operands[2]);
5090 ;;- Subtract instructions.
5094 ; subti3 instruction pattern(s).
5097 (define_insn_and_split "subti3"
5098 [(set (match_operand:TI 0 "register_operand" "=&d")
5099 (minus:TI (match_operand:TI 1 "register_operand" "0")
5100 (match_operand:TI 2 "general_operand" "do") ) )
5101 (clobber (reg:CC CC_REGNUM))]
5104 "&& reload_completed"
5106 [(set (reg:CCL2 CC_REGNUM)
5107 (compare:CCL2 (minus:DI (match_dup 7) (match_dup 8))
5109 (set (match_dup 6) (minus:DI (match_dup 7) (match_dup 8)))])
5111 [(set (match_dup 3) (minus:DI (minus:DI (match_dup 4) (match_dup 5))
5112 (gtu:DI (reg:CCL2 CC_REGNUM) (const_int 0))))
5113 (clobber (reg:CC CC_REGNUM))])]
5114 "operands[3] = operand_subword (operands[0], 0, 0, TImode);
5115 operands[4] = operand_subword (operands[1], 0, 0, TImode);
5116 operands[5] = operand_subword (operands[2], 0, 0, TImode);
5117 operands[6] = operand_subword (operands[0], 1, 0, TImode);
5118 operands[7] = operand_subword (operands[1], 1, 0, TImode);
5119 operands[8] = operand_subword (operands[2], 1, 0, TImode);")
5122 ; subdi3 instruction pattern(s).
5125 (define_expand "subdi3"
5127 [(set (match_operand:DI 0 "register_operand" "")
5128 (minus:DI (match_operand:DI 1 "register_operand" "")
5129 (match_operand:DI 2 "general_operand" "")))
5130 (clobber (reg:CC CC_REGNUM))])]
5134 (define_insn "*subdi3_sign"
5135 [(set (match_operand:DI 0 "register_operand" "=d,d")
5136 (minus:DI (match_operand:DI 1 "register_operand" "0,0")
5137 (sign_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))))
5138 (clobber (reg:CC CC_REGNUM))]
5143 [(set_attr "op_type" "RRE,RXY")
5144 (set_attr "z10prop" "z10_c,*")
5145 (set_attr "z196prop" "z196_cracked")])
5147 (define_insn "*subdi3_zero_cc"
5148 [(set (reg CC_REGNUM)
5149 (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
5150 (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT")))
5152 (set (match_operand:DI 0 "register_operand" "=d,d")
5153 (minus:DI (match_dup 1) (zero_extend:DI (match_dup 2))))]
5154 "s390_match_ccmode (insn, CCLmode) && TARGET_ZARCH"
5158 [(set_attr "op_type" "RRE,RXY")
5159 (set_attr "z10prop" "z10_super_c_E1,z10_super_E1")])
5161 (define_insn "*subdi3_zero_cconly"
5162 [(set (reg CC_REGNUM)
5163 (compare (minus:DI (match_operand:DI 1 "register_operand" "0,0")
5164 (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT")))
5166 (clobber (match_scratch:DI 0 "=d,d"))]
5167 "s390_match_ccmode (insn, CCLmode) && TARGET_ZARCH"
5171 [(set_attr "op_type" "RRE,RXY")
5172 (set_attr "z10prop" "z10_super_c_E1,z10_super_E1")])
5174 (define_insn "*subdi3_zero"
5175 [(set (match_operand:DI 0 "register_operand" "=d,d")
5176 (minus:DI (match_operand:DI 1 "register_operand" "0,0")
5177 (zero_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))))
5178 (clobber (reg:CC CC_REGNUM))]
5183 [(set_attr "op_type" "RRE,RXY")
5184 (set_attr "z10prop" "z10_super_c_E1,z10_super_E1")])
5186 (define_insn_and_split "*subdi3_31z"
5187 [(set (match_operand:DI 0 "register_operand" "=&d")
5188 (minus:DI (match_operand:DI 1 "register_operand" "0")
5189 (match_operand:DI 2 "general_operand" "do") ) )
5190 (clobber (reg:CC CC_REGNUM))]
5191 "!TARGET_ZARCH && TARGET_CPU_ZARCH"
5193 "&& reload_completed"
5195 [(set (reg:CCL2 CC_REGNUM)
5196 (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
5198 (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
5200 [(set (match_dup 3) (minus:SI (minus:SI (match_dup 4) (match_dup 5))
5201 (gtu:SI (reg:CCL2 CC_REGNUM) (const_int 0))))
5202 (clobber (reg:CC CC_REGNUM))])]
5203 "operands[3] = operand_subword (operands[0], 0, 0, DImode);
5204 operands[4] = operand_subword (operands[1], 0, 0, DImode);
5205 operands[5] = operand_subword (operands[2], 0, 0, DImode);
5206 operands[6] = operand_subword (operands[0], 1, 0, DImode);
5207 operands[7] = operand_subword (operands[1], 1, 0, DImode);
5208 operands[8] = operand_subword (operands[2], 1, 0, DImode);")
5210 (define_insn_and_split "*subdi3_31"
5211 [(set (match_operand:DI 0 "register_operand" "=&d")
5212 (minus:DI (match_operand:DI 1 "register_operand" "0")
5213 (match_operand:DI 2 "general_operand" "do") ) )
5214 (clobber (reg:CC CC_REGNUM))]
5217 "&& reload_completed"
5219 [(set (match_dup 3) (minus:SI (match_dup 4) (match_dup 5)))
5220 (clobber (reg:CC CC_REGNUM))])
5222 [(set (reg:CCL2 CC_REGNUM)
5223 (compare:CCL2 (minus:SI (match_dup 7) (match_dup 8))
5225 (set (match_dup 6) (minus:SI (match_dup 7) (match_dup 8)))])
5227 (if_then_else (gtu (reg:CCL2 CC_REGNUM) (const_int 0))
5229 (label_ref (match_dup 9))))
5231 [(set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))
5232 (clobber (reg:CC CC_REGNUM))])
5234 "operands[3] = operand_subword (operands[0], 0, 0, DImode);
5235 operands[4] = operand_subword (operands[1], 0, 0, DImode);
5236 operands[5] = operand_subword (operands[2], 0, 0, DImode);
5237 operands[6] = operand_subword (operands[0], 1, 0, DImode);
5238 operands[7] = operand_subword (operands[1], 1, 0, DImode);
5239 operands[8] = operand_subword (operands[2], 1, 0, DImode);
5240 operands[9] = gen_label_rtx ();")
5243 ; subsi3 instruction pattern(s).
5246 (define_expand "subsi3"
5248 [(set (match_operand:SI 0 "register_operand" "")
5249 (minus:SI (match_operand:SI 1 "register_operand" "")
5250 (match_operand:SI 2 "general_operand" "")))
5251 (clobber (reg:CC CC_REGNUM))])]
5255 (define_insn "*subsi3_sign"
5256 [(set (match_operand:SI 0 "register_operand" "=d,d")
5257 (minus:SI (match_operand:SI 1 "register_operand" "0,0")
5258 (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))))
5259 (clobber (reg:CC CC_REGNUM))]
5264 [(set_attr "op_type" "RX,RXY")
5265 (set_attr "z196prop" "z196_cracked,z196_cracked")])
5268 ; sub(di|si)3 instruction pattern(s).
5271 ; sr, s, sy, sgr, sg, srk, sgrk
5272 (define_insn "*sub<mode>3"
5273 [(set (match_operand:GPR 0 "register_operand" "=d,d,d,d")
5274 (minus:GPR (match_operand:GPR 1 "register_operand" "0,d,0,0")
5275 (match_operand:GPR 2 "general_operand" "d,d,R,T") ) )
5276 (clobber (reg:CC CC_REGNUM))]
5283 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5284 (set_attr "cpu_facility" "*,z196,*,*")
5285 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5287 ; slr, sl, sly, slgr, slg, slrk, slgrk
5288 (define_insn "*sub<mode>3_borrow_cc"
5289 [(set (reg CC_REGNUM)
5290 (compare (minus:GPR (match_operand:GPR 1 "register_operand" "0,d,0,0")
5291 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
5293 (set (match_operand:GPR 0 "register_operand" "=d,d,d,d")
5294 (minus:GPR (match_dup 1) (match_dup 2)))]
5295 "s390_match_ccmode (insn, CCL2mode)"
5301 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5302 (set_attr "cpu_facility" "*,z196,*,*")
5303 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5305 ; slr, sl, sly, slgr, slg, slrk, slgrk
5306 (define_insn "*sub<mode>3_borrow_cconly"
5307 [(set (reg CC_REGNUM)
5308 (compare (minus:GPR (match_operand:GPR 1 "register_operand" "0,d,0,0")
5309 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
5311 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
5312 "s390_match_ccmode (insn, CCL2mode)"
5318 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5319 (set_attr "cpu_facility" "*,z196,*,*")
5320 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5322 ; slr, sl, sly, slgr, slg, slrk, slgrk
5323 (define_insn "*sub<mode>3_cc"
5324 [(set (reg CC_REGNUM)
5325 (compare (minus:GPR (match_operand:GPR 1 "register_operand" "0,d,0,0")
5326 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
5328 (set (match_operand:GPR 0 "register_operand" "=d,d,d,d")
5329 (minus:GPR (match_dup 1) (match_dup 2)))]
5330 "s390_match_ccmode (insn, CCLmode)"
5336 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5337 (set_attr "cpu_facility" "*,z196,*,*")
5338 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5340 ; slr, sl, sly, slgr, slg, slrk, slgrk
5341 (define_insn "*sub<mode>3_cc2"
5342 [(set (reg CC_REGNUM)
5343 (compare (match_operand:GPR 1 "register_operand" "0,d,0,0")
5344 (match_operand:GPR 2 "general_operand" "d,d,R,T")))
5345 (set (match_operand:GPR 0 "register_operand" "=d,d,d,d")
5346 (minus:GPR (match_dup 1) (match_dup 2)))]
5347 "s390_match_ccmode (insn, CCL3mode)"
5353 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5354 (set_attr "cpu_facility" "*,z196,*,*")
5355 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5357 ; slr, sl, sly, slgr, slg, slrk, slgrk
5358 (define_insn "*sub<mode>3_cconly"
5359 [(set (reg CC_REGNUM)
5360 (compare (minus:GPR (match_operand:GPR 1 "register_operand" "0,d,0,0")
5361 (match_operand:GPR 2 "general_operand" "d,d,R,T"))
5363 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
5364 "s390_match_ccmode (insn, CCLmode)"
5370 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5371 (set_attr "cpu_facility" "*,z196,*,*")
5372 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5375 ; slr, sl, sly, slgr, slg, slrk, slgrk
5376 (define_insn "*sub<mode>3_cconly2"
5377 [(set (reg CC_REGNUM)
5378 (compare (match_operand:GPR 1 "register_operand" "0,d,0,0")
5379 (match_operand:GPR 2 "general_operand" "d,d,R,T")))
5380 (clobber (match_scratch:GPR 0 "=d,d,d,d"))]
5381 "s390_match_ccmode (insn, CCL3mode)"
5387 [(set_attr "op_type" "RR<E>,RRF,RX<Y>,RXY")
5388 (set_attr "cpu_facility" "*,z196,*,*")
5389 (set_attr "z10prop" "z10_super_c_E1,*,z10_super_E1,z10_super_E1")])
5393 ; sub(tf|df|sf|td|dd)3 instruction pattern(s).
5396 ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr
5397 (define_insn "sub<mode>3"
5398 [(set (match_operand:FP 0 "register_operand" "=f, f")
5399 (minus:FP (match_operand:FP 1 "register_operand" "<f0>,0")
5400 (match_operand:FP 2 "general_operand" "f,<Rf>")))
5401 (clobber (reg:CC CC_REGNUM))]
5404 s<xde><bt>r\t%0,<op1>%2
5406 [(set_attr "op_type" "<RRer>,RXE")
5407 (set_attr "type" "fsimp<mode>")])
5409 ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr
5410 (define_insn "*sub<mode>3_cc"
5411 [(set (reg CC_REGNUM)
5412 (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" "<f0>,0")
5413 (match_operand:FP 2 "general_operand" "f,<Rf>"))
5414 (match_operand:FP 3 "const0_operand" "")))
5415 (set (match_operand:FP 0 "register_operand" "=f,f")
5416 (minus:FP (match_dup 1) (match_dup 2)))]
5417 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
5419 s<xde><bt>r\t%0,<op1>%2
5421 [(set_attr "op_type" "<RRer>,RXE")
5422 (set_attr "type" "fsimp<mode>")])
5424 ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr
5425 (define_insn "*sub<mode>3_cconly"
5426 [(set (reg CC_REGNUM)
5427 (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" "<f0>,0")
5428 (match_operand:FP 2 "general_operand" "f,<Rf>"))
5429 (match_operand:FP 3 "const0_operand" "")))
5430 (clobber (match_scratch:FP 0 "=f,f"))]
5431 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
5433 s<xde><bt>r\t%0,<op1>%2
5435 [(set_attr "op_type" "<RRer>,RXE")
5436 (set_attr "type" "fsimp<mode>")])
5440 ;;- Conditional add/subtract instructions.
5444 ; add(di|si)cc instruction pattern(s).
5447 ; the following 4 patterns are used when the result of an add with
5448 ; carry is checked for an overflow condition
5450 ; op1 + op2 + c < op1
5452 ; alcr, alc, alcgr, alcg
5453 (define_insn "*add<mode>3_alc_carry1_cc"
5454 [(set (reg CC_REGNUM)
5456 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5457 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5458 (match_operand:GPR 2 "general_operand" "d,RT"))
5460 (set (match_operand:GPR 0 "register_operand" "=d,d")
5461 (plus:GPR (plus:GPR (match_dup 3) (match_dup 1)) (match_dup 2)))]
5462 "s390_match_ccmode (insn, CCL1mode) && TARGET_CPU_ZARCH"
5466 [(set_attr "op_type" "RRE,RXY")
5467 (set_attr "z196prop" "z196_alone,z196_alone")])
5469 ; alcr, alc, alcgr, alcg
5470 (define_insn "*add<mode>3_alc_carry1_cconly"
5471 [(set (reg CC_REGNUM)
5473 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5474 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5475 (match_operand:GPR 2 "general_operand" "d,RT"))
5477 (clobber (match_scratch:GPR 0 "=d,d"))]
5478 "s390_match_ccmode (insn, CCL1mode) && TARGET_CPU_ZARCH"
5482 [(set_attr "op_type" "RRE,RXY")
5483 (set_attr "z196prop" "z196_alone,z196_alone")])
5485 ; op1 + op2 + c < op2
5487 ; alcr, alc, alcgr, alcg
5488 (define_insn "*add<mode>3_alc_carry2_cc"
5489 [(set (reg CC_REGNUM)
5491 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5492 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5493 (match_operand:GPR 2 "general_operand" "d,RT"))
5495 (set (match_operand:GPR 0 "register_operand" "=d,d")
5496 (plus:GPR (plus:GPR (match_dup 3) (match_dup 1)) (match_dup 2)))]
5497 "s390_match_ccmode (insn, CCL1mode) && TARGET_CPU_ZARCH"
5501 [(set_attr "op_type" "RRE,RXY")])
5503 ; alcr, alc, alcgr, alcg
5504 (define_insn "*add<mode>3_alc_carry2_cconly"
5505 [(set (reg CC_REGNUM)
5507 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5508 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5509 (match_operand:GPR 2 "general_operand" "d,RT"))
5511 (clobber (match_scratch:GPR 0 "=d,d"))]
5512 "s390_match_ccmode (insn, CCL1mode) && TARGET_CPU_ZARCH"
5516 [(set_attr "op_type" "RRE,RXY")])
5518 ; alcr, alc, alcgr, alcg
5519 (define_insn "*add<mode>3_alc_cc"
5520 [(set (reg CC_REGNUM)
5522 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5523 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5524 (match_operand:GPR 2 "general_operand" "d,RT"))
5526 (set (match_operand:GPR 0 "register_operand" "=d,d")
5527 (plus:GPR (plus:GPR (match_dup 3) (match_dup 1)) (match_dup 2)))]
5528 "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
5532 [(set_attr "op_type" "RRE,RXY")])
5534 ; alcr, alc, alcgr, alcg
5535 (define_insn "*add<mode>3_alc"
5536 [(set (match_operand:GPR 0 "register_operand" "=d,d")
5537 (plus:GPR (plus:GPR (match_operand:GPR 3 "s390_alc_comparison" "")
5538 (match_operand:GPR 1 "nonimmediate_operand" "%0,0"))
5539 (match_operand:GPR 2 "general_operand" "d,RT")))
5540 (clobber (reg:CC CC_REGNUM))]
5545 [(set_attr "op_type" "RRE,RXY")])
5547 ; slbr, slb, slbgr, slbg
5548 (define_insn "*sub<mode>3_slb_cc"
5549 [(set (reg CC_REGNUM)
5551 (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
5552 (match_operand:GPR 2 "general_operand" "d,RT"))
5553 (match_operand:GPR 3 "s390_slb_comparison" ""))
5555 (set (match_operand:GPR 0 "register_operand" "=d,d")
5556 (minus:GPR (minus:GPR (match_dup 1) (match_dup 2)) (match_dup 3)))]
5557 "s390_match_ccmode (insn, CCLmode) && TARGET_CPU_ZARCH"
5561 [(set_attr "op_type" "RRE,RXY")
5562 (set_attr "z10prop" "z10_c,*")])
5564 ; slbr, slb, slbgr, slbg
5565 (define_insn "*sub<mode>3_slb"
5566 [(set (match_operand:GPR 0 "register_operand" "=d,d")
5567 (minus:GPR (minus:GPR (match_operand:GPR 1 "nonimmediate_operand" "0,0")
5568 (match_operand:GPR 2 "general_operand" "d,RT"))
5569 (match_operand:GPR 3 "s390_slb_comparison" "")))
5570 (clobber (reg:CC CC_REGNUM))]
5575 [(set_attr "op_type" "RRE,RXY")
5576 (set_attr "z10prop" "z10_c,*")])
5578 (define_expand "add<mode>cc"
5579 [(match_operand:GPR 0 "register_operand" "")
5580 (match_operand 1 "comparison_operator" "")
5581 (match_operand:GPR 2 "register_operand" "")
5582 (match_operand:GPR 3 "const_int_operand" "")]
5584 "if (!s390_expand_addcc (GET_CODE (operands[1]),
5585 XEXP (operands[1], 0), XEXP (operands[1], 1),
5586 operands[0], operands[2],
5587 operands[3])) FAIL; DONE;")
5590 ; scond instruction pattern(s).
5593 (define_insn_and_split "*scond<mode>"
5594 [(set (match_operand:GPR 0 "register_operand" "=&d")
5595 (match_operand:GPR 1 "s390_alc_comparison" ""))
5596 (clobber (reg:CC CC_REGNUM))]
5599 "&& reload_completed"
5600 [(set (match_dup 0) (const_int 0))
5602 [(set (match_dup 0) (plus:GPR (plus:GPR (match_dup 1) (match_dup 0))
5604 (clobber (reg:CC CC_REGNUM))])]
5607 (define_insn_and_split "*scond<mode>_neg"
5608 [(set (match_operand:GPR 0 "register_operand" "=&d")
5609 (match_operand:GPR 1 "s390_slb_comparison" ""))
5610 (clobber (reg:CC CC_REGNUM))]
5613 "&& reload_completed"
5614 [(set (match_dup 0) (const_int 0))
5616 [(set (match_dup 0) (minus:GPR (minus:GPR (match_dup 0) (match_dup 0))
5618 (clobber (reg:CC CC_REGNUM))])
5620 [(set (match_dup 0) (neg:GPR (match_dup 0)))
5621 (clobber (reg:CC CC_REGNUM))])]
5625 (define_expand "cstore<mode>4"
5626 [(set (match_operand:SI 0 "register_operand" "")
5627 (match_operator:SI 1 "s390_scond_operator"
5628 [(match_operand:GPR 2 "register_operand" "")
5629 (match_operand:GPR 3 "general_operand" "")]))]
5631 "if (!s390_expand_addcc (GET_CODE (operands[1]), operands[2], operands[3],
5632 operands[0], const0_rtx, const1_rtx)) FAIL; DONE;")
5634 (define_expand "cstorecc4"
5636 [(set (match_operand:SI 0 "register_operand" "")
5637 (match_operator:SI 1 "s390_eqne_operator"
5638 [(match_operand:CCZ1 2 "register_operand")
5639 (match_operand 3 "const0_operand")]))
5640 (clobber (reg:CC CC_REGNUM))])]
5642 "emit_insn (gen_sne (operands[0], operands[2]));
5643 if (GET_CODE (operands[1]) == EQ)
5644 emit_insn (gen_xorsi3 (operands[0], operands[0], const1_rtx));
5647 (define_insn_and_split "sne"
5648 [(set (match_operand:SI 0 "register_operand" "=d")
5649 (ne:SI (match_operand:CCZ1 1 "register_operand" "0")
5651 (clobber (reg:CC CC_REGNUM))]
5656 [(set (match_dup 0) (ashiftrt:SI (match_dup 0) (const_int 28)))
5657 (clobber (reg:CC CC_REGNUM))])])
5661 ;; - Conditional move instructions (introduced with z196)
5664 (define_expand "mov<mode>cc"
5665 [(set (match_operand:GPR 0 "nonimmediate_operand" "")
5666 (if_then_else:GPR (match_operand 1 "comparison_operator" "")
5667 (match_operand:GPR 2 "nonimmediate_operand" "")
5668 (match_operand:GPR 3 "nonimmediate_operand" "")))]
5670 "operands[1] = s390_emit_compare (GET_CODE (operands[1]),
5671 XEXP (operands[1], 0), XEXP (operands[1], 1));")
5673 ; locr, loc, stoc, locgr, locg, stocg
5674 (define_insn_and_split "*mov<mode>cc"
5675 [(set (match_operand:GPR 0 "nonimmediate_operand" "=d,d, d, d,QS,QS,&d")
5677 (match_operator 1 "s390_comparison"
5678 [(match_operand 2 "cc_reg_operand" " c,c, c, c, c, c, c")
5679 (match_operand 5 "const_int_operand" "")])
5680 (match_operand:GPR 3 "nonimmediate_operand" " d,0,QS, 0, d, 0,QS")
5681 (match_operand:GPR 4 "nonimmediate_operand" " 0,d, 0,QS, 0, d,QS")))]
5691 "&& reload_completed
5692 && MEM_P (operands[3]) && MEM_P (operands[4])"
5695 (match_op_dup 1 [(match_dup 2) (const_int 0)])
5700 (match_op_dup 1 [(match_dup 2) (const_int 0)])
5704 [(set_attr "op_type" "RRF,RRF,RSY,RSY,RSY,RSY,*")])
5707 ;;- Multiply instructions.
5711 ; muldi3 instruction pattern(s).
5714 (define_insn "*muldi3_sign"
5715 [(set (match_operand:DI 0 "register_operand" "=d,d")
5716 (mult:DI (sign_extend:DI (match_operand:SI 2 "general_operand" "d,RT"))
5717 (match_operand:DI 1 "register_operand" "0,0")))]
5722 [(set_attr "op_type" "RRE,RXY")
5723 (set_attr "type" "imuldi")])
5725 (define_insn "muldi3"
5726 [(set (match_operand:DI 0 "register_operand" "=d,d,d,d")
5727 (mult:DI (match_operand:DI 1 "nonimmediate_operand" "%0,0,0,0")
5728 (match_operand:DI 2 "general_operand" "d,K,RT,Os")))]
5735 [(set_attr "op_type" "RRE,RI,RXY,RIL")
5736 (set_attr "type" "imuldi")
5737 (set_attr "cpu_facility" "*,*,*,z10")])
5740 ; mulsi3 instruction pattern(s).
5743 (define_insn "*mulsi3_sign"
5744 [(set (match_operand:SI 0 "register_operand" "=d,d")
5745 (mult:SI (sign_extend:SI (match_operand:HI 2 "memory_operand" "R,T"))
5746 (match_operand:SI 1 "register_operand" "0,0")))]
5751 [(set_attr "op_type" "RX,RXY")
5752 (set_attr "type" "imulhi")
5753 (set_attr "cpu_facility" "*,z10")])
5755 (define_insn "mulsi3"
5756 [(set (match_operand:SI 0 "register_operand" "=d,d,d,d,d")
5757 (mult:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0,0")
5758 (match_operand:SI 2 "general_operand" "d,K,R,T,Os")))]
5766 [(set_attr "op_type" "RRE,RI,RX,RXY,RIL")
5767 (set_attr "type" "imulsi,imulhi,imulsi,imulsi,imulsi")
5768 (set_attr "cpu_facility" "*,*,*,*,z10")])
5771 ; mulsidi3 instruction pattern(s).
5774 (define_insn "mulsidi3"
5775 [(set (match_operand:DI 0 "register_operand" "=d,d,d")
5776 (mult:DI (sign_extend:DI
5777 (match_operand:SI 1 "register_operand" "%0,0,0"))
5779 (match_operand:SI 2 "nonimmediate_operand" "d,R,T"))))]
5785 [(set_attr "op_type" "RR,RX,RXY")
5786 (set_attr "type" "imulsi")
5787 (set_attr "cpu_facility" "*,*,z10")])
5790 ; umul instruction pattern(s).
5793 ; mlr, ml, mlgr, mlg
5794 (define_insn "umul<dwh><mode>3"
5795 [(set (match_operand:DW 0 "register_operand" "=d, d")
5796 (mult:DW (zero_extend:DW
5797 (match_operand:<DWH> 1 "register_operand" "%0, 0"))
5799 (match_operand:<DWH> 2 "nonimmediate_operand" " d,RT"))))]
5804 [(set_attr "op_type" "RRE,RXY")
5805 (set_attr "type" "imul<dwh>")])
5808 ; mul(tf|df|sf|td|dd)3 instruction pattern(s).
5811 ; mxbr, mdbr, meebr, mxb, mxb, meeb, mdtr, mxtr
5812 (define_insn "mul<mode>3"
5813 [(set (match_operand:FP 0 "register_operand" "=f,f")
5814 (mult:FP (match_operand:FP 1 "nonimmediate_operand" "%<f0>,0")
5815 (match_operand:FP 2 "general_operand" "f,<Rf>")))]
5818 m<xdee><bt>r\t%0,<op1>%2
5820 [(set_attr "op_type" "<RRer>,RXE")
5821 (set_attr "type" "fmul<mode>")])
5823 ; madbr, maebr, maxb, madb, maeb
5824 (define_insn "fma<mode>4"
5825 [(set (match_operand:DSF 0 "register_operand" "=f,f")
5826 (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f")
5827 (match_operand:DSF 2 "nonimmediate_operand" "f,R")
5828 (match_operand:DSF 3 "register_operand" "0,0")))]
5833 [(set_attr "op_type" "RRE,RXE")
5834 (set_attr "type" "fmadd<mode>")])
5836 ; msxbr, msdbr, msebr, msxb, msdb, mseb
5837 (define_insn "fms<mode>4"
5838 [(set (match_operand:DSF 0 "register_operand" "=f,f")
5839 (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f")
5840 (match_operand:DSF 2 "nonimmediate_operand" "f,R")
5841 (neg:DSF (match_operand:DSF 3 "register_operand" "0,0"))))]
5846 [(set_attr "op_type" "RRE,RXE")
5847 (set_attr "type" "fmadd<mode>")])
5850 ;;- Divide and modulo instructions.
5854 ; divmoddi4 instruction pattern(s).
5857 (define_expand "divmoddi4"
5858 [(parallel [(set (match_operand:DI 0 "general_operand" "")
5859 (div:DI (match_operand:DI 1 "register_operand" "")
5860 (match_operand:DI 2 "general_operand" "")))
5861 (set (match_operand:DI 3 "general_operand" "")
5862 (mod:DI (match_dup 1) (match_dup 2)))])
5863 (clobber (match_dup 4))]
5866 rtx insn, div_equal, mod_equal;
5868 div_equal = gen_rtx_DIV (DImode, operands[1], operands[2]);
5869 mod_equal = gen_rtx_MOD (DImode, operands[1], operands[2]);
5871 operands[4] = gen_reg_rtx(TImode);
5872 emit_insn (gen_divmodtidi3 (operands[4], operands[1], operands[2]));
5874 insn = emit_move_insn (operands[0], gen_lowpart (DImode, operands[4]));
5875 set_unique_reg_note (insn, REG_EQUAL, div_equal);
5877 insn = emit_move_insn (operands[3], gen_highpart (DImode, operands[4]));
5878 set_unique_reg_note (insn, REG_EQUAL, mod_equal);
5883 (define_insn "divmodtidi3"
5884 [(set (match_operand:TI 0 "register_operand" "=d,d")
5888 (mod:DI (match_operand:DI 1 "register_operand" "0,0")
5889 (match_operand:DI 2 "general_operand" "d,RT")))
5891 (zero_extend:TI (div:DI (match_dup 1) (match_dup 2)))))]
5896 [(set_attr "op_type" "RRE,RXY")
5897 (set_attr "type" "idiv")])
5899 (define_insn "divmodtisi3"
5900 [(set (match_operand:TI 0 "register_operand" "=d,d")
5904 (mod:DI (match_operand:DI 1 "register_operand" "0,0")
5906 (match_operand:SI 2 "nonimmediate_operand" "d,RT"))))
5909 (div:DI (match_dup 1) (sign_extend:DI (match_dup 2))))))]
5914 [(set_attr "op_type" "RRE,RXY")
5915 (set_attr "type" "idiv")])
5918 ; udivmoddi4 instruction pattern(s).
5921 (define_expand "udivmoddi4"
5922 [(parallel [(set (match_operand:DI 0 "general_operand" "")
5923 (udiv:DI (match_operand:DI 1 "general_operand" "")
5924 (match_operand:DI 2 "nonimmediate_operand" "")))
5925 (set (match_operand:DI 3 "general_operand" "")
5926 (umod:DI (match_dup 1) (match_dup 2)))])
5927 (clobber (match_dup 4))]
5930 rtx insn, div_equal, mod_equal, equal;
5932 div_equal = gen_rtx_UDIV (DImode, operands[1], operands[2]);
5933 mod_equal = gen_rtx_UMOD (DImode, operands[1], operands[2]);
5934 equal = gen_rtx_IOR (TImode,
5935 gen_rtx_ASHIFT (TImode,
5936 gen_rtx_ZERO_EXTEND (TImode, mod_equal),
5938 gen_rtx_ZERO_EXTEND (TImode, div_equal));
5940 operands[4] = gen_reg_rtx(TImode);
5941 emit_clobber (operands[4]);
5942 emit_move_insn (gen_lowpart (DImode, operands[4]), operands[1]);
5943 emit_move_insn (gen_highpart (DImode, operands[4]), const0_rtx);
5945 insn = emit_insn (gen_udivmodtidi3 (operands[4], operands[4], operands[2]));
5946 set_unique_reg_note (insn, REG_EQUAL, equal);
5948 insn = emit_move_insn (operands[0], gen_lowpart (DImode, operands[4]));
5949 set_unique_reg_note (insn, REG_EQUAL, div_equal);
5951 insn = emit_move_insn (operands[3], gen_highpart (DImode, operands[4]));
5952 set_unique_reg_note (insn, REG_EQUAL, mod_equal);
5957 (define_insn "udivmodtidi3"
5958 [(set (match_operand:TI 0 "register_operand" "=d,d")
5963 (umod:TI (match_operand:TI 1 "register_operand" "0,0")
5965 (match_operand:DI 2 "nonimmediate_operand" "d,RT")))))
5969 (udiv:TI (match_dup 1) (zero_extend:TI (match_dup 2)))))))]
5974 [(set_attr "op_type" "RRE,RXY")
5975 (set_attr "type" "idiv")])
5978 ; divmodsi4 instruction pattern(s).
5981 (define_expand "divmodsi4"
5982 [(parallel [(set (match_operand:SI 0 "general_operand" "")
5983 (div:SI (match_operand:SI 1 "general_operand" "")
5984 (match_operand:SI 2 "nonimmediate_operand" "")))
5985 (set (match_operand:SI 3 "general_operand" "")
5986 (mod:SI (match_dup 1) (match_dup 2)))])
5987 (clobber (match_dup 4))]
5990 rtx insn, div_equal, mod_equal, equal;
5992 div_equal = gen_rtx_DIV (SImode, operands[1], operands[2]);
5993 mod_equal = gen_rtx_MOD (SImode, operands[1], operands[2]);
5994 equal = gen_rtx_IOR (DImode,
5995 gen_rtx_ASHIFT (DImode,
5996 gen_rtx_ZERO_EXTEND (DImode, mod_equal),
5998 gen_rtx_ZERO_EXTEND (DImode, div_equal));
6000 operands[4] = gen_reg_rtx(DImode);
6001 emit_insn (gen_extendsidi2 (operands[4], operands[1]));
6003 insn = emit_insn (gen_divmoddisi3 (operands[4], operands[4], operands[2]));
6004 set_unique_reg_note (insn, REG_EQUAL, equal);
6006 insn = emit_move_insn (operands[0], gen_lowpart (SImode, operands[4]));
6007 set_unique_reg_note (insn, REG_EQUAL, div_equal);
6009 insn = emit_move_insn (operands[3], gen_highpart (SImode, operands[4]));
6010 set_unique_reg_note (insn, REG_EQUAL, mod_equal);
6015 (define_insn "divmoddisi3"
6016 [(set (match_operand:DI 0 "register_operand" "=d,d")
6021 (mod:DI (match_operand:DI 1 "register_operand" "0,0")
6023 (match_operand:SI 2 "nonimmediate_operand" "d,R")))))
6027 (div:DI (match_dup 1) (sign_extend:DI (match_dup 2)))))))]
6032 [(set_attr "op_type" "RR,RX")
6033 (set_attr "type" "idiv")])
6036 ; udivsi3 and umodsi3 instruction pattern(s).
6039 (define_expand "udivmodsi4"
6040 [(parallel [(set (match_operand:SI 0 "general_operand" "")
6041 (udiv:SI (match_operand:SI 1 "general_operand" "")
6042 (match_operand:SI 2 "nonimmediate_operand" "")))
6043 (set (match_operand:SI 3 "general_operand" "")
6044 (umod:SI (match_dup 1) (match_dup 2)))])
6045 (clobber (match_dup 4))]
6046 "!TARGET_ZARCH && TARGET_CPU_ZARCH"
6048 rtx insn, div_equal, mod_equal, equal;
6050 div_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
6051 mod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
6052 equal = gen_rtx_IOR (DImode,
6053 gen_rtx_ASHIFT (DImode,
6054 gen_rtx_ZERO_EXTEND (DImode, mod_equal),
6056 gen_rtx_ZERO_EXTEND (DImode, div_equal));
6058 operands[4] = gen_reg_rtx(DImode);
6059 emit_clobber (operands[4]);
6060 emit_move_insn (gen_lowpart (SImode, operands[4]), operands[1]);
6061 emit_move_insn (gen_highpart (SImode, operands[4]), const0_rtx);
6063 insn = emit_insn (gen_udivmoddisi3 (operands[4], operands[4], operands[2]));
6064 set_unique_reg_note (insn, REG_EQUAL, equal);
6066 insn = emit_move_insn (operands[0], gen_lowpart (SImode, operands[4]));
6067 set_unique_reg_note (insn, REG_EQUAL, div_equal);
6069 insn = emit_move_insn (operands[3], gen_highpart (SImode, operands[4]));
6070 set_unique_reg_note (insn, REG_EQUAL, mod_equal);
6075 (define_insn "udivmoddisi3"
6076 [(set (match_operand:DI 0 "register_operand" "=d,d")
6081 (umod:DI (match_operand:DI 1 "register_operand" "0,0")
6083 (match_operand:SI 2 "nonimmediate_operand" "d,RT")))))
6087 (udiv:DI (match_dup 1) (zero_extend:DI (match_dup 2)))))))]
6088 "!TARGET_ZARCH && TARGET_CPU_ZARCH"
6092 [(set_attr "op_type" "RRE,RXY")
6093 (set_attr "type" "idiv")])
6095 (define_expand "udivsi3"
6096 [(set (match_operand:SI 0 "register_operand" "=d")
6097 (udiv:SI (match_operand:SI 1 "general_operand" "")
6098 (match_operand:SI 2 "general_operand" "")))
6099 (clobber (match_dup 3))]
6100 "!TARGET_ZARCH && !TARGET_CPU_ZARCH"
6102 rtx insn, udiv_equal, umod_equal, equal;
6104 udiv_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
6105 umod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
6106 equal = gen_rtx_IOR (DImode,
6107 gen_rtx_ASHIFT (DImode,
6108 gen_rtx_ZERO_EXTEND (DImode, umod_equal),
6110 gen_rtx_ZERO_EXTEND (DImode, udiv_equal));
6112 operands[3] = gen_reg_rtx (DImode);
6114 if (CONSTANT_P (operands[2]))
6116 if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 0)
6118 rtx label1 = gen_label_rtx ();
6120 operands[1] = make_safe_from (operands[1], operands[0]);
6121 emit_move_insn (operands[0], const0_rtx);
6122 emit_cmp_and_jump_insns (operands[1], operands[2], LT, NULL_RTX,
6124 emit_move_insn (operands[0], const1_rtx);
6125 emit_label (label1);
6129 operands[2] = force_reg (SImode, operands[2]);
6130 operands[2] = make_safe_from (operands[2], operands[0]);
6132 emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
6133 insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
6135 set_unique_reg_note (insn, REG_EQUAL, equal);
6137 insn = emit_move_insn (operands[0],
6138 gen_lowpart (SImode, operands[3]));
6139 set_unique_reg_note (insn, REG_EQUAL, udiv_equal);
6144 rtx label1 = gen_label_rtx ();
6145 rtx label2 = gen_label_rtx ();
6146 rtx label3 = gen_label_rtx ();
6148 operands[1] = force_reg (SImode, operands[1]);
6149 operands[1] = make_safe_from (operands[1], operands[0]);
6150 operands[2] = force_reg (SImode, operands[2]);
6151 operands[2] = make_safe_from (operands[2], operands[0]);
6153 emit_move_insn (operands[0], const0_rtx);
6154 emit_cmp_and_jump_insns (operands[2], operands[1], GT, NULL_RTX,
6156 emit_cmp_and_jump_insns (operands[2], const0_rtx, LT, NULL_RTX,
6158 emit_cmp_and_jump_insns (operands[2], const1_rtx, EQ, NULL_RTX,
6160 emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
6161 insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
6163 set_unique_reg_note (insn, REG_EQUAL, equal);
6165 insn = emit_move_insn (operands[0],
6166 gen_lowpart (SImode, operands[3]));
6167 set_unique_reg_note (insn, REG_EQUAL, udiv_equal);
6170 emit_label (label1);
6171 emit_move_insn (operands[0], operands[1]);
6173 emit_label (label2);
6174 emit_move_insn (operands[0], const1_rtx);
6175 emit_label (label3);
6177 emit_move_insn (operands[0], operands[0]);
6181 (define_expand "umodsi3"
6182 [(set (match_operand:SI 0 "register_operand" "=d")
6183 (umod:SI (match_operand:SI 1 "nonimmediate_operand" "")
6184 (match_operand:SI 2 "nonimmediate_operand" "")))
6185 (clobber (match_dup 3))]
6186 "!TARGET_ZARCH && !TARGET_CPU_ZARCH"
6188 rtx insn, udiv_equal, umod_equal, equal;
6190 udiv_equal = gen_rtx_UDIV (SImode, operands[1], operands[2]);
6191 umod_equal = gen_rtx_UMOD (SImode, operands[1], operands[2]);
6192 equal = gen_rtx_IOR (DImode,
6193 gen_rtx_ASHIFT (DImode,
6194 gen_rtx_ZERO_EXTEND (DImode, umod_equal),
6196 gen_rtx_ZERO_EXTEND (DImode, udiv_equal));
6198 operands[3] = gen_reg_rtx (DImode);
6200 if (CONSTANT_P (operands[2]))
6202 if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) <= 0)
6204 rtx label1 = gen_label_rtx ();
6206 operands[1] = make_safe_from (operands[1], operands[0]);
6207 emit_move_insn (operands[0], operands[1]);
6208 emit_cmp_and_jump_insns (operands[0], operands[2], LT, NULL_RTX,
6210 emit_insn (gen_abssi2 (operands[0], operands[2]));
6211 emit_insn (gen_addsi3 (operands[0], operands[0], operands[1]));
6212 emit_label (label1);
6216 operands[2] = force_reg (SImode, operands[2]);
6217 operands[2] = make_safe_from (operands[2], operands[0]);
6219 emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
6220 insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
6222 set_unique_reg_note (insn, REG_EQUAL, equal);
6224 insn = emit_move_insn (operands[0],
6225 gen_highpart (SImode, operands[3]));
6226 set_unique_reg_note (insn, REG_EQUAL, umod_equal);
6231 rtx label1 = gen_label_rtx ();
6232 rtx label2 = gen_label_rtx ();
6233 rtx label3 = gen_label_rtx ();
6235 operands[1] = force_reg (SImode, operands[1]);
6236 operands[1] = make_safe_from (operands[1], operands[0]);
6237 operands[2] = force_reg (SImode, operands[2]);
6238 operands[2] = make_safe_from (operands[2], operands[0]);
6240 emit_move_insn(operands[0], operands[1]);
6241 emit_cmp_and_jump_insns (operands[2], operands[1], GT, NULL_RTX,
6243 emit_cmp_and_jump_insns (operands[2], const0_rtx, LT, NULL_RTX,
6245 emit_cmp_and_jump_insns (operands[2], const1_rtx, EQ, NULL_RTX,
6247 emit_insn (gen_zero_extendsidi2 (operands[3], operands[1]));
6248 insn = emit_insn (gen_divmoddisi3 (operands[3], operands[3],
6250 set_unique_reg_note (insn, REG_EQUAL, equal);
6252 insn = emit_move_insn (operands[0],
6253 gen_highpart (SImode, operands[3]));
6254 set_unique_reg_note (insn, REG_EQUAL, umod_equal);
6257 emit_label (label1);
6258 emit_move_insn (operands[0], const0_rtx);
6260 emit_label (label2);
6261 emit_insn (gen_subsi3 (operands[0], operands[0], operands[2]));
6262 emit_label (label3);
6268 ; div(df|sf)3 instruction pattern(s).
6271 ; dxbr, ddbr, debr, dxb, ddb, deb, ddtr, dxtr
6272 (define_insn "div<mode>3"
6273 [(set (match_operand:FP 0 "register_operand" "=f,f")
6274 (div:FP (match_operand:FP 1 "register_operand" "<f0>,0")
6275 (match_operand:FP 2 "general_operand" "f,<Rf>")))]
6278 d<xde><bt>r\t%0,<op1>%2
6280 [(set_attr "op_type" "<RRer>,RXE")
6281 (set_attr "type" "fdiv<mode>")])
6285 ;;- And instructions.
6288 (define_expand "and<mode>3"
6289 [(set (match_operand:INT 0 "nonimmediate_operand" "")
6290 (and:INT (match_operand:INT 1 "nonimmediate_operand" "")
6291 (match_operand:INT 2 "general_operand" "")))
6292 (clobber (reg:CC CC_REGNUM))]
6294 "s390_expand_logical_operator (AND, <MODE>mode, operands); DONE;")
6297 ; anddi3 instruction pattern(s).
6300 (define_insn "*anddi3_cc"
6301 [(set (reg CC_REGNUM)
6303 (and:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d, 0, d")
6304 (match_operand:DI 2 "general_operand" " d,d,RT,NxxDq"))
6306 (set (match_operand:DI 0 "register_operand" "=d,d, d, d")
6307 (and:DI (match_dup 1) (match_dup 2)))]
6308 "TARGET_ZARCH && s390_match_ccmode(insn, CCTmode)"
6313 risbg\t%0,%1,%s2,128+%e2,0"
6314 [(set_attr "op_type" "RRE,RRF,RXY,RIE")
6315 (set_attr "cpu_facility" "*,z196,*,z10")
6316 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
6318 (define_insn "*anddi3_cconly"
6319 [(set (reg CC_REGNUM)
6321 (and:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d, 0, d")
6322 (match_operand:DI 2 "general_operand" " d,d,RT,NxxDq"))
6324 (clobber (match_scratch:DI 0 "=d,d, d, d"))]
6326 && s390_match_ccmode(insn, CCTmode)
6327 /* Do not steal TM patterns. */
6328 && s390_single_part (operands[2], DImode, HImode, 0) < 0"
6333 risbg\t%0,%1,%s2,128+%e2,0"
6334 [(set_attr "op_type" "RRE,RRF,RXY,RIE")
6335 (set_attr "cpu_facility" "*,z196,*,z10")
6336 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super_E1")])
6338 (define_insn "*anddi3"
6339 [(set (match_operand:DI 0 "nonimmediate_operand"
6340 "=d,d, d, d, d, d, d, d,d,d, d, d, AQ,Q")
6342 (match_operand:DI 1 "nonimmediate_operand"
6343 "%d,o, 0, 0, 0, 0, 0, 0,0,d, 0, d, 0,0")
6344 (match_operand:DI 2 "general_operand"
6345 "M, M,N0HDF,N1HDF,N2HDF,N3HDF,N0SDF,N1SDF,d,d,RT,NxxDq,NxQDF,Q")))
6346 (clobber (reg:CC CC_REGNUM))]
6347 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6360 risbg\t%0,%1,%s2,128+%e2,0
6363 [(set_attr "op_type" "RRE,RXE,RI,RI,RI,RI,RIL,RIL,RRE,RRF,RXY,RIE,SI,SS")
6364 (set_attr "cpu_facility" "*,*,*,*,*,*,extimm,extimm,*,z196,*,z10,*,*")
6365 (set_attr "z10prop" "*,
6381 [(set (match_operand:DI 0 "s_operand" "")
6382 (and:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
6383 (clobber (reg:CC CC_REGNUM))]
6386 [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
6387 (clobber (reg:CC CC_REGNUM))])]
6388 "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
6390 ;; These two are what combine generates for (ashift (zero_extract)).
6391 (define_insn "*extzv_<mode>_srl"
6392 [(set (match_operand:GPR 0 "register_operand" "=d")
6393 (and:GPR (lshiftrt:GPR
6394 (match_operand:GPR 1 "register_operand" "d")
6395 (match_operand:GPR 2 "nonzero_shift_count_operand" ""))
6396 (match_operand:GPR 3 "contiguous_bitmask_operand" "")))
6397 (clobber (reg:CC CC_REGNUM))]
6399 /* Note that even for the SImode pattern, the rotate is always DImode. */
6400 && s390_extzv_shift_ok (<bitsize>, -INTVAL (operands[2]),
6401 INTVAL (operands[3]))"
6402 "risbg\t%0,%1,%<bfstart>3,128+%<bfend>3,64-%2"
6403 [(set_attr "op_type" "RIE")
6404 (set_attr "z10prop" "z10_super_E1")])
6406 (define_insn "*extzv_<mode>_sll"
6407 [(set (match_operand:GPR 0 "register_operand" "=d")
6408 (and:GPR (ashift:GPR
6409 (match_operand:GPR 1 "register_operand" "d")
6410 (match_operand:GPR 2 "nonzero_shift_count_operand" ""))
6411 (match_operand:GPR 3 "contiguous_bitmask_operand" "")))
6412 (clobber (reg:CC CC_REGNUM))]
6414 && s390_extzv_shift_ok (<bitsize>, INTVAL (operands[2]),
6415 INTVAL (operands[3]))"
6416 "risbg\t%0,%1,%<bfstart>3,128+%<bfend>3,%2"
6417 [(set_attr "op_type" "RIE")
6418 (set_attr "z10prop" "z10_super_E1")])
6422 ; andsi3 instruction pattern(s).
6425 (define_insn "*andsi3_cc"
6426 [(set (reg CC_REGNUM)
6429 (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0, d")
6430 (match_operand:SI 2 "general_operand" "Os,d,d,R,T,NxxSq"))
6432 (set (match_operand:SI 0 "register_operand" "=d,d,d,d,d, d")
6433 (and:SI (match_dup 1) (match_dup 2)))]
6434 "s390_match_ccmode(insn, CCTmode)"
6441 risbg\t%0,%1,%t2,128+%f2,0"
6442 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY,RIE")
6443 (set_attr "cpu_facility" "*,*,z196,*,*,z10")
6444 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,
6445 z10_super_E1,z10_super_E1,z10_super_E1")])
6447 (define_insn "*andsi3_cconly"
6448 [(set (reg CC_REGNUM)
6451 (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0, d")
6452 (match_operand:SI 2 "general_operand" "Os,d,d,R,T,NxxSq"))
6454 (clobber (match_scratch:SI 0 "=d,d,d,d,d, d"))]
6455 "s390_match_ccmode(insn, CCTmode)
6456 /* Do not steal TM patterns. */
6457 && s390_single_part (operands[2], SImode, HImode, 0) < 0"
6464 risbg\t%0,%1,%t2,128+%f2,0"
6465 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY,RIE")
6466 (set_attr "cpu_facility" "*,*,z196,*,*,z10")
6467 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,
6468 z10_super_E1,z10_super_E1,z10_super_E1")])
6470 (define_insn "*andsi3_zarch"
6471 [(set (match_operand:SI 0 "nonimmediate_operand"
6472 "=d,d, d, d, d,d,d,d,d, d, AQ,Q")
6473 (and:SI (match_operand:SI 1 "nonimmediate_operand"
6474 "%d,o, 0, 0, 0,0,d,0,0, d, 0,0")
6475 (match_operand:SI 2 "general_operand"
6476 " M,M,N0HSF,N1HSF,Os,d,d,R,T,NxxSq,NxQSF,Q")))
6477 (clobber (reg:CC CC_REGNUM))]
6478 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6489 risbg\t%0,%1,%t2,128+%f2,0
6492 [(set_attr "op_type" "RRE,RXE,RI,RI,RIL,RR,RRF,RX,RXY,RIE,SI,SS")
6493 (set_attr "cpu_facility" "*,*,*,*,*,*,z196,*,*,z10,*,*")
6494 (set_attr "z10prop" "*,
6507 (define_insn "*andsi3_esa"
6508 [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d, AQ,Q")
6509 (and:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0, 0,0")
6510 (match_operand:SI 2 "general_operand" " d,R,NxQSF,Q")))
6511 (clobber (reg:CC CC_REGNUM))]
6512 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6518 [(set_attr "op_type" "RR,RX,SI,SS")
6519 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,*")])
6523 [(set (match_operand:SI 0 "s_operand" "")
6524 (and:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
6525 (clobber (reg:CC CC_REGNUM))]
6528 [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
6529 (clobber (reg:CC CC_REGNUM))])]
6530 "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
6533 ; andhi3 instruction pattern(s).
6536 (define_insn "*andhi3_zarch"
6537 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d, AQ,Q")
6538 (and:HI (match_operand:HI 1 "nonimmediate_operand" "%0,d,0, 0,0")
6539 (match_operand:HI 2 "general_operand" " d,d,n,NxQHF,Q")))
6540 (clobber (reg:CC CC_REGNUM))]
6541 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6548 [(set_attr "op_type" "RR,RRF,RI,SI,SS")
6549 (set_attr "cpu_facility" "*,z196,*,*,*")
6550 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,*,*")
6553 (define_insn "*andhi3_esa"
6554 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,AQ,Q")
6555 (and:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0")
6556 (match_operand:HI 2 "general_operand" "d,NxQHF,Q")))
6557 (clobber (reg:CC CC_REGNUM))]
6558 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6563 [(set_attr "op_type" "RR,SI,SS")
6564 (set_attr "z10prop" "z10_super_E1,*,*")
6568 [(set (match_operand:HI 0 "s_operand" "")
6569 (and:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
6570 (clobber (reg:CC CC_REGNUM))]
6573 [(set (match_dup 0) (and:QI (match_dup 0) (match_dup 1)))
6574 (clobber (reg:CC CC_REGNUM))])]
6575 "s390_narrow_logical_operator (AND, &operands[0], &operands[1]);")
6578 ; andqi3 instruction pattern(s).
6581 (define_insn "*andqi3_zarch"
6582 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,Q,S,Q")
6583 (and:QI (match_operand:QI 1 "nonimmediate_operand" "%0,d,0,0,0,0")
6584 (match_operand:QI 2 "general_operand" " d,d,n,n,n,Q")))
6585 (clobber (reg:CC CC_REGNUM))]
6586 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6594 [(set_attr "op_type" "RR,RRF,RI,SI,SIY,SS")
6595 (set_attr "cpu_facility" "*,z196,*,*,*,*")
6596 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,z10_super,z10_super,*")])
6598 (define_insn "*andqi3_esa"
6599 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,Q,Q")
6600 (and:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0")
6601 (match_operand:QI 2 "general_operand" "d,n,Q")))
6602 (clobber (reg:CC CC_REGNUM))]
6603 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6608 [(set_attr "op_type" "RR,SI,SS")
6609 (set_attr "z10prop" "z10_super_E1,z10_super,*")])
6612 ; Block and (NC) patterns.
6616 [(set (match_operand:BLK 0 "memory_operand" "=Q")
6617 (and:BLK (match_dup 0)
6618 (match_operand:BLK 1 "memory_operand" "Q")))
6619 (use (match_operand 2 "const_int_operand" "n"))
6620 (clobber (reg:CC CC_REGNUM))]
6621 "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
6622 "nc\t%O0(%2,%R0),%S1"
6623 [(set_attr "op_type" "SS")
6624 (set_attr "z196prop" "z196_cracked")])
6627 [(set (match_operand 0 "memory_operand" "")
6629 (match_operand 1 "memory_operand" "")))
6630 (clobber (reg:CC CC_REGNUM))]
6632 && GET_MODE (operands[0]) == GET_MODE (operands[1])
6633 && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
6635 [(set (match_dup 0) (and:BLK (match_dup 0) (match_dup 1)))
6637 (clobber (reg:CC CC_REGNUM))])]
6639 operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
6640 operands[0] = adjust_address (operands[0], BLKmode, 0);
6641 operands[1] = adjust_address (operands[1], BLKmode, 0);
6646 [(set (match_operand:BLK 0 "memory_operand" "")
6647 (and:BLK (match_dup 0)
6648 (match_operand:BLK 1 "memory_operand" "")))
6649 (use (match_operand 2 "const_int_operand" ""))
6650 (clobber (reg:CC CC_REGNUM))])
6652 [(set (match_operand:BLK 3 "memory_operand" "")
6653 (and:BLK (match_dup 3)
6654 (match_operand:BLK 4 "memory_operand" "")))
6655 (use (match_operand 5 "const_int_operand" ""))
6656 (clobber (reg:CC CC_REGNUM))])]
6657 "s390_offset_p (operands[0], operands[3], operands[2])
6658 && s390_offset_p (operands[1], operands[4], operands[2])
6659 && !s390_overlap_p (operands[0], operands[1],
6660 INTVAL (operands[2]) + INTVAL (operands[5]))
6661 && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
6663 [(set (match_dup 6) (and:BLK (match_dup 6) (match_dup 7)))
6665 (clobber (reg:CC CC_REGNUM))])]
6666 "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
6667 operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
6668 operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
6672 ;;- Bit set (inclusive or) instructions.
6675 (define_expand "ior<mode>3"
6676 [(set (match_operand:INT 0 "nonimmediate_operand" "")
6677 (ior:INT (match_operand:INT 1 "nonimmediate_operand" "")
6678 (match_operand:INT 2 "general_operand" "")))
6679 (clobber (reg:CC CC_REGNUM))]
6681 "s390_expand_logical_operator (IOR, <MODE>mode, operands); DONE;")
6684 ; iordi3 instruction pattern(s).
6687 (define_insn "*iordi3_cc"
6688 [(set (reg CC_REGNUM)
6689 (compare (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d, 0")
6690 (match_operand:DI 2 "general_operand" " d,d,RT"))
6692 (set (match_operand:DI 0 "register_operand" "=d,d, d")
6693 (ior:DI (match_dup 1) (match_dup 2)))]
6694 "s390_match_ccmode(insn, CCTmode) && TARGET_ZARCH"
6699 [(set_attr "op_type" "RRE,RRF,RXY")
6700 (set_attr "cpu_facility" "*,z196,*")
6701 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1")])
6703 (define_insn "*iordi3_cconly"
6704 [(set (reg CC_REGNUM)
6705 (compare (ior:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d,0")
6706 (match_operand:DI 2 "general_operand" " d,d,RT"))
6708 (clobber (match_scratch:DI 0 "=d,d,d"))]
6709 "s390_match_ccmode(insn, CCTmode) && TARGET_ZARCH"
6714 [(set_attr "op_type" "RRE,RRF,RXY")
6715 (set_attr "cpu_facility" "*,z196,*")
6716 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1")])
6718 (define_insn "*iordi3"
6719 [(set (match_operand:DI 0 "nonimmediate_operand"
6720 "=d, d, d, d, d, d,d,d, d, AQ,Q")
6721 (ior:DI (match_operand:DI 1 "nonimmediate_operand"
6722 " %0, 0, 0, 0, 0, 0,0,d, 0, 0,0")
6723 (match_operand:DI 2 "general_operand"
6724 "N0HD0,N1HD0,N2HD0,N3HD0,N0SD0,N1SD0,d,d,RT,NxQD0,Q")))
6725 (clobber (reg:CC CC_REGNUM))]
6726 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6739 [(set_attr "op_type" "RI,RI,RI,RI,RIL,RIL,RRE,RRF,RXY,SI,SS")
6740 (set_attr "cpu_facility" "*,*,*,*,extimm,extimm,*,z196,*,*,*")
6741 (set_attr "z10prop" "z10_super_E1,
6754 [(set (match_operand:DI 0 "s_operand" "")
6755 (ior:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
6756 (clobber (reg:CC CC_REGNUM))]
6759 [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
6760 (clobber (reg:CC CC_REGNUM))])]
6761 "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
6764 ; iorsi3 instruction pattern(s).
6767 (define_insn "*iorsi3_cc"
6768 [(set (reg CC_REGNUM)
6769 (compare (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0")
6770 (match_operand:SI 2 "general_operand" "Os,d,d,R,T"))
6772 (set (match_operand:SI 0 "register_operand" "=d,d,d,d,d")
6773 (ior:SI (match_dup 1) (match_dup 2)))]
6774 "s390_match_ccmode(insn, CCTmode)"
6781 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY")
6782 (set_attr "cpu_facility" "*,*,z196,*,*")
6783 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,z10_super_E1,z10_super_E1")])
6785 (define_insn "*iorsi3_cconly"
6786 [(set (reg CC_REGNUM)
6787 (compare (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0")
6788 (match_operand:SI 2 "general_operand" "Os,d,d,R,T"))
6790 (clobber (match_scratch:SI 0 "=d,d,d,d,d"))]
6791 "s390_match_ccmode(insn, CCTmode)"
6798 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY")
6799 (set_attr "cpu_facility" "*,*,z196,*,*")
6800 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,z10_super_E1,z10_super_E1")])
6802 (define_insn "*iorsi3_zarch"
6803 [(set (match_operand:SI 0 "nonimmediate_operand" "=d, d, d,d,d,d,d, AQ,Q")
6804 (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0, 0, 0,0,d,0,0, 0,0")
6805 (match_operand:SI 2 "general_operand" "N0HS0,N1HS0,Os,d,d,R,T,NxQS0,Q")))
6806 (clobber (reg:CC CC_REGNUM))]
6807 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6818 [(set_attr "op_type" "RI,RI,RIL,RR,RRF,RX,RXY,SI,SS")
6819 (set_attr "cpu_facility" "*,*,*,*,z196,*,*,*,*")
6820 (set_attr "z10prop" "z10_super_E1,
6830 (define_insn "*iorsi3_esa"
6831 [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,AQ,Q")
6832 (ior:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,0,0")
6833 (match_operand:SI 2 "general_operand" "d,R,NxQS0,Q")))
6834 (clobber (reg:CC CC_REGNUM))]
6835 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6841 [(set_attr "op_type" "RR,RX,SI,SS")
6842 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,*")])
6845 [(set (match_operand:SI 0 "s_operand" "")
6846 (ior:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
6847 (clobber (reg:CC CC_REGNUM))]
6850 [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
6851 (clobber (reg:CC CC_REGNUM))])]
6852 "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
6855 ; iorhi3 instruction pattern(s).
6858 (define_insn "*iorhi3_zarch"
6859 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d, AQ,Q")
6860 (ior:HI (match_operand:HI 1 "nonimmediate_operand" "%0,d,0, 0,0")
6861 (match_operand:HI 2 "general_operand" " d,d,n,NxQH0,Q")))
6862 (clobber (reg:CC CC_REGNUM))]
6863 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6870 [(set_attr "op_type" "RR,RRF,RI,SI,SS")
6871 (set_attr "cpu_facility" "*,z196,*,*,*")
6872 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,*,*")])
6874 (define_insn "*iorhi3_esa"
6875 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,AQ,Q")
6876 (ior:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,0")
6877 (match_operand:HI 2 "general_operand" "d,NxQH0,Q")))
6878 (clobber (reg:CC CC_REGNUM))]
6879 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6884 [(set_attr "op_type" "RR,SI,SS")
6885 (set_attr "z10prop" "z10_super_E1,*,*")])
6888 [(set (match_operand:HI 0 "s_operand" "")
6889 (ior:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
6890 (clobber (reg:CC CC_REGNUM))]
6893 [(set (match_dup 0) (ior:QI (match_dup 0) (match_dup 1)))
6894 (clobber (reg:CC CC_REGNUM))])]
6895 "s390_narrow_logical_operator (IOR, &operands[0], &operands[1]);")
6898 ; iorqi3 instruction pattern(s).
6901 (define_insn "*iorqi3_zarch"
6902 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,Q,S,Q")
6903 (ior:QI (match_operand:QI 1 "nonimmediate_operand" "%0,d,0,0,0,0")
6904 (match_operand:QI 2 "general_operand" " d,d,n,n,n,Q")))
6905 (clobber (reg:CC CC_REGNUM))]
6906 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6914 [(set_attr "op_type" "RR,RRF,RI,SI,SIY,SS")
6915 (set_attr "cpu_facility" "*,z196,*,*,*,*")
6916 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1,
6917 z10_super,z10_super,*")])
6919 (define_insn "*iorqi3_esa"
6920 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,Q,Q")
6921 (ior:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,0")
6922 (match_operand:QI 2 "general_operand" "d,n,Q")))
6923 (clobber (reg:CC CC_REGNUM))]
6924 "!TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
6929 [(set_attr "op_type" "RR,SI,SS")
6930 (set_attr "z10prop" "z10_super_E1,z10_super,*")])
6933 ; Block inclusive or (OC) patterns.
6937 [(set (match_operand:BLK 0 "memory_operand" "=Q")
6938 (ior:BLK (match_dup 0)
6939 (match_operand:BLK 1 "memory_operand" "Q")))
6940 (use (match_operand 2 "const_int_operand" "n"))
6941 (clobber (reg:CC CC_REGNUM))]
6942 "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
6943 "oc\t%O0(%2,%R0),%S1"
6944 [(set_attr "op_type" "SS")
6945 (set_attr "z196prop" "z196_cracked")])
6948 [(set (match_operand 0 "memory_operand" "")
6950 (match_operand 1 "memory_operand" "")))
6951 (clobber (reg:CC CC_REGNUM))]
6953 && GET_MODE (operands[0]) == GET_MODE (operands[1])
6954 && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
6956 [(set (match_dup 0) (ior:BLK (match_dup 0) (match_dup 1)))
6958 (clobber (reg:CC CC_REGNUM))])]
6960 operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
6961 operands[0] = adjust_address (operands[0], BLKmode, 0);
6962 operands[1] = adjust_address (operands[1], BLKmode, 0);
6967 [(set (match_operand:BLK 0 "memory_operand" "")
6968 (ior:BLK (match_dup 0)
6969 (match_operand:BLK 1 "memory_operand" "")))
6970 (use (match_operand 2 "const_int_operand" ""))
6971 (clobber (reg:CC CC_REGNUM))])
6973 [(set (match_operand:BLK 3 "memory_operand" "")
6974 (ior:BLK (match_dup 3)
6975 (match_operand:BLK 4 "memory_operand" "")))
6976 (use (match_operand 5 "const_int_operand" ""))
6977 (clobber (reg:CC CC_REGNUM))])]
6978 "s390_offset_p (operands[0], operands[3], operands[2])
6979 && s390_offset_p (operands[1], operands[4], operands[2])
6980 && !s390_overlap_p (operands[0], operands[1],
6981 INTVAL (operands[2]) + INTVAL (operands[5]))
6982 && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
6984 [(set (match_dup 6) (ior:BLK (match_dup 6) (match_dup 7)))
6986 (clobber (reg:CC CC_REGNUM))])]
6987 "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
6988 operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
6989 operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
6993 ;;- Xor instructions.
6996 (define_expand "xor<mode>3"
6997 [(set (match_operand:INT 0 "nonimmediate_operand" "")
6998 (xor:INT (match_operand:INT 1 "nonimmediate_operand" "")
6999 (match_operand:INT 2 "general_operand" "")))
7000 (clobber (reg:CC CC_REGNUM))]
7002 "s390_expand_logical_operator (XOR, <MODE>mode, operands); DONE;")
7004 ; Combine replaces (xor (x) (const_int -1)) with (not (x)) when doing
7005 ; simplifications. So its better to have something matching.
7007 [(set (match_operand:INT 0 "nonimmediate_operand" "")
7008 (not:INT (match_operand:INT 1 "nonimmediate_operand" "")))]
7011 [(set (match_dup 0) (xor:INT (match_dup 1) (match_dup 2)))
7012 (clobber (reg:CC CC_REGNUM))])]
7014 operands[2] = constm1_rtx;
7015 if (!s390_logical_operator_ok_p (operands))
7020 ; xordi3 instruction pattern(s).
7023 (define_insn "*xordi3_cc"
7024 [(set (reg CC_REGNUM)
7025 (compare (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d, 0")
7026 (match_operand:DI 2 "general_operand" " d,d,RT"))
7028 (set (match_operand:DI 0 "register_operand" "=d,d, d")
7029 (xor:DI (match_dup 1) (match_dup 2)))]
7030 "s390_match_ccmode(insn, CCTmode) && TARGET_ZARCH"
7035 [(set_attr "op_type" "RRE,RRF,RXY")
7036 (set_attr "cpu_facility" "*,z196,*")
7037 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1")])
7039 (define_insn "*xordi3_cconly"
7040 [(set (reg CC_REGNUM)
7041 (compare (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0,d, 0")
7042 (match_operand:DI 2 "general_operand" " d,d,RT"))
7044 (clobber (match_scratch:DI 0 "=d,d, d"))]
7045 "s390_match_ccmode(insn, CCTmode) && TARGET_ZARCH"
7050 [(set_attr "op_type" "RRE,RRF,RXY")
7051 (set_attr "cpu_facility" "*,z196,*")
7052 (set_attr "z10prop" "z10_super_E1,*,z10_super_E1")])
7054 (define_insn "*xordi3"
7055 [(set (match_operand:DI 0 "nonimmediate_operand" "=d, d,d,d, d, AQ,Q")
7056 (xor:DI (match_operand:DI 1 "nonimmediate_operand" "%0, 0,0,d, 0, 0,0")
7057 (match_operand:DI 2 "general_operand" "N0SD0,N1SD0,d,d,RT,NxQD0,Q")))
7058 (clobber (reg:CC CC_REGNUM))]
7059 "TARGET_ZARCH && s390_logical_operator_ok_p (operands)"
7068 [(set_attr "op_type" "RIL,RIL,RRE,RRF,RXY,SI,SS")
7069 (set_attr "cpu_facility" "extimm,extimm,*,z196,*,*,*")
7070 (set_attr "z10prop" "z10_super_E1,z10_super_E1,z10_super_E1,
7071 *,z10_super_E1,*,*")])
7074 [(set (match_operand:DI 0 "s_operand" "")
7075 (xor:DI (match_dup 0) (match_operand:DI 1 "immediate_operand" "")))
7076 (clobber (reg:CC CC_REGNUM))]
7079 [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
7080 (clobber (reg:CC CC_REGNUM))])]
7081 "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
7084 ; xorsi3 instruction pattern(s).
7087 (define_insn "*xorsi3_cc"
7088 [(set (reg CC_REGNUM)
7089 (compare (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0")
7090 (match_operand:SI 2 "general_operand" "Os,d,d,R,T"))
7092 (set (match_operand:SI 0 "register_operand" "=d,d,d,d,d")
7093 (xor:SI (match_dup 1) (match_dup 2)))]
7094 "s390_match_ccmode(insn, CCTmode)"
7101 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY")
7102 (set_attr "cpu_facility" "*,*,z196,*,*")
7103 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,
7104 z10_super_E1,z10_super_E1")])
7106 (define_insn "*xorsi3_cconly"
7107 [(set (reg CC_REGNUM)
7108 (compare (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0")
7109 (match_operand:SI 2 "general_operand" "Os,d,d,R,T"))
7111 (clobber (match_scratch:SI 0 "=d,d,d,d,d"))]
7112 "s390_match_ccmode(insn, CCTmode)"
7119 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY")
7120 (set_attr "cpu_facility" "*,*,z196,*,*")
7121 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,
7122 z10_super_E1,z10_super_E1")])
7124 (define_insn "*xorsi3"
7125 [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,d,d, AQ,Q")
7126 (xor:SI (match_operand:SI 1 "nonimmediate_operand" "%0,0,d,0,0, 0,0")
7127 (match_operand:SI 2 "general_operand" "Os,d,d,R,T,NxQS0,Q")))
7128 (clobber (reg:CC CC_REGNUM))]
7129 "s390_logical_operator_ok_p (operands)"
7138 [(set_attr "op_type" "RIL,RR,RRF,RX,RXY,SI,SS")
7139 (set_attr "cpu_facility" "*,*,z196,*,*,*,*")
7140 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,
7141 z10_super_E1,z10_super_E1,*,*")])
7144 [(set (match_operand:SI 0 "s_operand" "")
7145 (xor:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "")))
7146 (clobber (reg:CC CC_REGNUM))]
7149 [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
7150 (clobber (reg:CC CC_REGNUM))])]
7151 "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
7154 ; xorhi3 instruction pattern(s).
7157 (define_insn "*xorhi3"
7158 [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d, AQ,Q")
7159 (xor:HI (match_operand:HI 1 "nonimmediate_operand" "%0,0,d, 0,0")
7160 (match_operand:HI 2 "general_operand" "Os,d,d,NxQH0,Q")))
7161 (clobber (reg:CC CC_REGNUM))]
7162 "s390_logical_operator_ok_p (operands)"
7169 [(set_attr "op_type" "RIL,RR,RRF,SI,SS")
7170 (set_attr "cpu_facility" "*,*,z196,*,*")
7171 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,*,*")])
7174 [(set (match_operand:HI 0 "s_operand" "")
7175 (xor:HI (match_dup 0) (match_operand:HI 1 "immediate_operand" "")))
7176 (clobber (reg:CC CC_REGNUM))]
7179 [(set (match_dup 0) (xor:QI (match_dup 0) (match_dup 1)))
7180 (clobber (reg:CC CC_REGNUM))])]
7181 "s390_narrow_logical_operator (XOR, &operands[0], &operands[1]);")
7184 ; xorqi3 instruction pattern(s).
7187 (define_insn "*xorqi3"
7188 [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,Q,S,Q")
7189 (xor:QI (match_operand:QI 1 "nonimmediate_operand" "%0,0,d,0,0,0")
7190 (match_operand:QI 2 "general_operand" "Os,d,d,n,n,Q")))
7191 (clobber (reg:CC CC_REGNUM))]
7192 "s390_logical_operator_ok_p (operands)"
7200 [(set_attr "op_type" "RIL,RR,RRF,SI,SIY,SS")
7201 (set_attr "cpu_facility" "*,*,z196,*,*,*")
7202 (set_attr "z10prop" "z10_super_E1,z10_super_E1,*,z10_super,z10_super,*")])
7206 ; Block exclusive or (XC) patterns.
7210 [(set (match_operand:BLK 0 "memory_operand" "=Q")
7211 (xor:BLK (match_dup 0)
7212 (match_operand:BLK 1 "memory_operand" "Q")))
7213 (use (match_operand 2 "const_int_operand" "n"))
7214 (clobber (reg:CC CC_REGNUM))]
7215 "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 256"
7216 "xc\t%O0(%2,%R0),%S1"
7217 [(set_attr "op_type" "SS")])
7220 [(set (match_operand 0 "memory_operand" "")
7222 (match_operand 1 "memory_operand" "")))
7223 (clobber (reg:CC CC_REGNUM))]
7225 && GET_MODE (operands[0]) == GET_MODE (operands[1])
7226 && GET_MODE_SIZE (GET_MODE (operands[0])) > 0"
7228 [(set (match_dup 0) (xor:BLK (match_dup 0) (match_dup 1)))
7230 (clobber (reg:CC CC_REGNUM))])]
7232 operands[2] = GEN_INT (GET_MODE_SIZE (GET_MODE (operands[0])));
7233 operands[0] = adjust_address (operands[0], BLKmode, 0);
7234 operands[1] = adjust_address (operands[1], BLKmode, 0);
7239 [(set (match_operand:BLK 0 "memory_operand" "")
7240 (xor:BLK (match_dup 0)
7241 (match_operand:BLK 1 "memory_operand" "")))
7242 (use (match_operand 2 "const_int_operand" ""))
7243 (clobber (reg:CC CC_REGNUM))])
7245 [(set (match_operand:BLK 3 "memory_operand" "")
7246 (xor:BLK (match_dup 3)
7247 (match_operand:BLK 4 "memory_operand" "")))
7248 (use (match_operand 5 "const_int_operand" ""))
7249 (clobber (reg:CC CC_REGNUM))])]
7250 "s390_offset_p (operands[0], operands[3], operands[2])
7251 && s390_offset_p (operands[1], operands[4], operands[2])
7252 && !s390_overlap_p (operands[0], operands[1],
7253 INTVAL (operands[2]) + INTVAL (operands[5]))
7254 && INTVAL (operands[2]) + INTVAL (operands[5]) <= 256"
7256 [(set (match_dup 6) (xor:BLK (match_dup 6) (match_dup 7)))
7258 (clobber (reg:CC CC_REGNUM))])]
7259 "operands[6] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
7260 operands[7] = gen_rtx_MEM (BLKmode, XEXP (operands[1], 0));
7261 operands[8] = GEN_INT (INTVAL (operands[2]) + INTVAL (operands[5]));")
7264 ; Block xor (XC) patterns with src == dest.
7267 (define_insn "*xc_zero"
7268 [(set (match_operand:BLK 0 "memory_operand" "=Q")
7270 (use (match_operand 1 "const_int_operand" "n"))
7271 (clobber (reg:CC CC_REGNUM))]
7272 "INTVAL (operands[1]) >= 1 && INTVAL (operands[1]) <= 256"
7273 "xc\t%O0(%1,%R0),%S0"
7274 [(set_attr "op_type" "SS")
7275 (set_attr "z196prop" "z196_cracked")])
7279 [(set (match_operand:BLK 0 "memory_operand" "")
7281 (use (match_operand 1 "const_int_operand" ""))
7282 (clobber (reg:CC CC_REGNUM))])
7284 [(set (match_operand:BLK 2 "memory_operand" "")
7286 (use (match_operand 3 "const_int_operand" ""))
7287 (clobber (reg:CC CC_REGNUM))])]
7288 "s390_offset_p (operands[0], operands[2], operands[1])
7289 && INTVAL (operands[1]) + INTVAL (operands[3]) <= 256"
7291 [(set (match_dup 4) (const_int 0))
7293 (clobber (reg:CC CC_REGNUM))])]
7294 "operands[4] = gen_rtx_MEM (BLKmode, XEXP (operands[0], 0));
7295 operands[5] = GEN_INT (INTVAL (operands[1]) + INTVAL (operands[3]));")
7299 ;;- Negate instructions.
7303 ; neg(di|si)2 instruction pattern(s).
7306 (define_expand "neg<mode>2"
7308 [(set (match_operand:DSI 0 "register_operand" "=d")
7309 (neg:DSI (match_operand:DSI 1 "register_operand" "d")))
7310 (clobber (reg:CC CC_REGNUM))])]
7314 (define_insn "*negdi2_sign_cc"
7315 [(set (reg CC_REGNUM)
7316 (compare (neg:DI (ashiftrt:DI (ashift:DI (subreg:DI
7317 (match_operand:SI 1 "register_operand" "d") 0)
7318 (const_int 32)) (const_int 32)))
7320 (set (match_operand:DI 0 "register_operand" "=d")
7321 (neg:DI (sign_extend:DI (match_dup 1))))]
7322 "TARGET_ZARCH && s390_match_ccmode (insn, CCAmode)"
7324 [(set_attr "op_type" "RRE")
7325 (set_attr "z10prop" "z10_c")])
7327 (define_insn "*negdi2_sign"
7328 [(set (match_operand:DI 0 "register_operand" "=d")
7329 (neg:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "d"))))
7330 (clobber (reg:CC CC_REGNUM))]
7333 [(set_attr "op_type" "RRE")
7334 (set_attr "z10prop" "z10_c")])
7337 (define_insn "*neg<mode>2_cc"
7338 [(set (reg CC_REGNUM)
7339 (compare (neg:GPR (match_operand:GPR 1 "register_operand" "d"))
7341 (set (match_operand:GPR 0 "register_operand" "=d")
7342 (neg:GPR (match_dup 1)))]
7343 "s390_match_ccmode (insn, CCAmode)"
7345 [(set_attr "op_type" "RR<E>")
7346 (set_attr "z10prop" "z10_super_c_E1")])
7349 (define_insn "*neg<mode>2_cconly"
7350 [(set (reg CC_REGNUM)
7351 (compare (neg:GPR (match_operand:GPR 1 "register_operand" "d"))
7353 (clobber (match_scratch:GPR 0 "=d"))]
7354 "s390_match_ccmode (insn, CCAmode)"
7356 [(set_attr "op_type" "RR<E>")
7357 (set_attr "z10prop" "z10_super_c_E1")])
7360 (define_insn "*neg<mode>2"
7361 [(set (match_operand:GPR 0 "register_operand" "=d")
7362 (neg:GPR (match_operand:GPR 1 "register_operand" "d")))
7363 (clobber (reg:CC CC_REGNUM))]
7366 [(set_attr "op_type" "RR<E>")
7367 (set_attr "z10prop" "z10_super_c_E1")])
7369 (define_insn_and_split "*negdi2_31"
7370 [(set (match_operand:DI 0 "register_operand" "=d")
7371 (neg:DI (match_operand:DI 1 "register_operand" "d")))
7372 (clobber (reg:CC CC_REGNUM))]
7375 "&& reload_completed"
7377 [(set (match_dup 2) (neg:SI (match_dup 3)))
7378 (clobber (reg:CC CC_REGNUM))])
7380 [(set (reg:CCAP CC_REGNUM)
7381 (compare:CCAP (neg:SI (match_dup 5)) (const_int 0)))
7382 (set (match_dup 4) (neg:SI (match_dup 5)))])
7384 (if_then_else (ne (reg:CCAP CC_REGNUM) (const_int 0))
7386 (label_ref (match_dup 6))))
7388 [(set (match_dup 2) (plus:SI (match_dup 2) (const_int -1)))
7389 (clobber (reg:CC CC_REGNUM))])
7391 "operands[2] = operand_subword (operands[0], 0, 0, DImode);
7392 operands[3] = operand_subword (operands[1], 0, 0, DImode);
7393 operands[4] = operand_subword (operands[0], 1, 0, DImode);
7394 operands[5] = operand_subword (operands[1], 1, 0, DImode);
7395 operands[6] = gen_label_rtx ();")
7398 ; neg(df|sf)2 instruction pattern(s).
7401 (define_expand "neg<mode>2"
7403 [(set (match_operand:BFP 0 "register_operand" "=f")
7404 (neg:BFP (match_operand:BFP 1 "register_operand" "f")))
7405 (clobber (reg:CC CC_REGNUM))])]
7409 ; lcxbr, lcdbr, lcebr
7410 (define_insn "*neg<mode>2_cc"
7411 [(set (reg CC_REGNUM)
7412 (compare (neg:BFP (match_operand:BFP 1 "register_operand" "f"))
7413 (match_operand:BFP 2 "const0_operand" "")))
7414 (set (match_operand:BFP 0 "register_operand" "=f")
7415 (neg:BFP (match_dup 1)))]
7416 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7418 [(set_attr "op_type" "RRE")
7419 (set_attr "type" "fsimp<mode>")])
7421 ; lcxbr, lcdbr, lcebr
7422 (define_insn "*neg<mode>2_cconly"
7423 [(set (reg CC_REGNUM)
7424 (compare (neg:BFP (match_operand:BFP 1 "register_operand" "f"))
7425 (match_operand:BFP 2 "const0_operand" "")))
7426 (clobber (match_scratch:BFP 0 "=f"))]
7427 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7429 [(set_attr "op_type" "RRE")
7430 (set_attr "type" "fsimp<mode>")])
7433 (define_insn "*neg<mode>2_nocc"
7434 [(set (match_operand:FP 0 "register_operand" "=f")
7435 (neg:FP (match_operand:FP 1 "register_operand" "<fT0>")))]
7438 [(set_attr "op_type" "RRE")
7439 (set_attr "type" "fsimp<mode>")])
7441 ; lcxbr, lcdbr, lcebr
7442 (define_insn "*neg<mode>2"
7443 [(set (match_operand:BFP 0 "register_operand" "=f")
7444 (neg:BFP (match_operand:BFP 1 "register_operand" "f")))
7445 (clobber (reg:CC CC_REGNUM))]
7448 [(set_attr "op_type" "RRE")
7449 (set_attr "type" "fsimp<mode>")])
7453 ;;- Absolute value instructions.
7457 ; abs(di|si)2 instruction pattern(s).
7460 (define_insn "*absdi2_sign_cc"
7461 [(set (reg CC_REGNUM)
7462 (compare (abs:DI (ashiftrt:DI (ashift:DI (subreg:DI
7463 (match_operand:SI 1 "register_operand" "d") 0)
7464 (const_int 32)) (const_int 32)))
7466 (set (match_operand:DI 0 "register_operand" "=d")
7467 (abs:DI (sign_extend:DI (match_dup 1))))]
7468 "TARGET_ZARCH && s390_match_ccmode (insn, CCAmode)"
7470 [(set_attr "op_type" "RRE")
7471 (set_attr "z10prop" "z10_c")])
7473 (define_insn "*absdi2_sign"
7474 [(set (match_operand:DI 0 "register_operand" "=d")
7475 (abs:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "d"))))
7476 (clobber (reg:CC CC_REGNUM))]
7479 [(set_attr "op_type" "RRE")
7480 (set_attr "z10prop" "z10_c")])
7483 (define_insn "*abs<mode>2_cc"
7484 [(set (reg CC_REGNUM)
7485 (compare (abs:GPR (match_operand:DI 1 "register_operand" "d"))
7487 (set (match_operand:GPR 0 "register_operand" "=d")
7488 (abs:GPR (match_dup 1)))]
7489 "s390_match_ccmode (insn, CCAmode)"
7491 [(set_attr "op_type" "RR<E>")
7492 (set_attr "z10prop" "z10_c")])
7495 (define_insn "*abs<mode>2_cconly"
7496 [(set (reg CC_REGNUM)
7497 (compare (abs:GPR (match_operand:GPR 1 "register_operand" "d"))
7499 (clobber (match_scratch:GPR 0 "=d"))]
7500 "s390_match_ccmode (insn, CCAmode)"
7502 [(set_attr "op_type" "RR<E>")
7503 (set_attr "z10prop" "z10_c")])
7506 (define_insn "abs<mode>2"
7507 [(set (match_operand:GPR 0 "register_operand" "=d")
7508 (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
7509 (clobber (reg:CC CC_REGNUM))]
7512 [(set_attr "op_type" "RR<E>")
7513 (set_attr "z10prop" "z10_c")])
7516 ; abs(df|sf)2 instruction pattern(s).
7519 (define_expand "abs<mode>2"
7521 [(set (match_operand:BFP 0 "register_operand" "=f")
7522 (abs:BFP (match_operand:BFP 1 "register_operand" "f")))
7523 (clobber (reg:CC CC_REGNUM))])]
7527 ; lpxbr, lpdbr, lpebr
7528 (define_insn "*abs<mode>2_cc"
7529 [(set (reg CC_REGNUM)
7530 (compare (abs:BFP (match_operand:BFP 1 "register_operand" "f"))
7531 (match_operand:BFP 2 "const0_operand" "")))
7532 (set (match_operand:BFP 0 "register_operand" "=f")
7533 (abs:BFP (match_dup 1)))]
7534 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7536 [(set_attr "op_type" "RRE")
7537 (set_attr "type" "fsimp<mode>")])
7539 ; lpxbr, lpdbr, lpebr
7540 (define_insn "*abs<mode>2_cconly"
7541 [(set (reg CC_REGNUM)
7542 (compare (abs:BFP (match_operand:BFP 1 "register_operand" "f"))
7543 (match_operand:BFP 2 "const0_operand" "")))
7544 (clobber (match_scratch:BFP 0 "=f"))]
7545 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7547 [(set_attr "op_type" "RRE")
7548 (set_attr "type" "fsimp<mode>")])
7551 (define_insn "*abs<mode>2_nocc"
7552 [(set (match_operand:FP 0 "register_operand" "=f")
7553 (abs:FP (match_operand:FP 1 "register_operand" "<fT0>")))]
7556 [(set_attr "op_type" "RRE")
7557 (set_attr "type" "fsimp<mode>")])
7559 ; lpxbr, lpdbr, lpebr
7560 (define_insn "*abs<mode>2"
7561 [(set (match_operand:BFP 0 "register_operand" "=f")
7562 (abs:BFP (match_operand:BFP 1 "register_operand" "f")))
7563 (clobber (reg:CC CC_REGNUM))]
7566 [(set_attr "op_type" "RRE")
7567 (set_attr "type" "fsimp<mode>")])
7571 ;;- Negated absolute value instructions
7578 (define_insn "*negabsdi2_sign_cc"
7579 [(set (reg CC_REGNUM)
7580 (compare (neg:DI (abs:DI (ashiftrt:DI (ashift:DI (subreg:DI
7581 (match_operand:SI 1 "register_operand" "d") 0)
7582 (const_int 32)) (const_int 32))))
7584 (set (match_operand:DI 0 "register_operand" "=d")
7585 (neg:DI (abs:DI (sign_extend:DI (match_dup 1)))))]
7586 "TARGET_ZARCH && s390_match_ccmode (insn, CCAmode)"
7588 [(set_attr "op_type" "RRE")
7589 (set_attr "z10prop" "z10_c")])
7591 (define_insn "*negabsdi2_sign"
7592 [(set (match_operand:DI 0 "register_operand" "=d")
7593 (neg:DI (abs:DI (sign_extend:DI
7594 (match_operand:SI 1 "register_operand" "d")))))
7595 (clobber (reg:CC CC_REGNUM))]
7598 [(set_attr "op_type" "RRE")
7599 (set_attr "z10prop" "z10_c")])
7602 (define_insn "*negabs<mode>2_cc"
7603 [(set (reg CC_REGNUM)
7604 (compare (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
7606 (set (match_operand:GPR 0 "register_operand" "=d")
7607 (neg:GPR (abs:GPR (match_dup 1))))]
7608 "s390_match_ccmode (insn, CCAmode)"
7610 [(set_attr "op_type" "RR<E>")
7611 (set_attr "z10prop" "z10_c")])
7614 (define_insn "*negabs<mode>2_cconly"
7615 [(set (reg CC_REGNUM)
7616 (compare (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d")))
7618 (clobber (match_scratch:GPR 0 "=d"))]
7619 "s390_match_ccmode (insn, CCAmode)"
7621 [(set_attr "op_type" "RR<E>")
7622 (set_attr "z10prop" "z10_c")])
7625 (define_insn "*negabs<mode>2"
7626 [(set (match_operand:GPR 0 "register_operand" "=d")
7627 (neg:GPR (abs:GPR (match_operand:GPR 1 "register_operand" "d"))))
7628 (clobber (reg:CC CC_REGNUM))]
7631 [(set_attr "op_type" "RR<E>")
7632 (set_attr "z10prop" "z10_c")])
7638 ; lnxbr, lndbr, lnebr
7639 (define_insn "*negabs<mode>2_cc"
7640 [(set (reg CC_REGNUM)
7641 (compare (neg:BFP (abs:BFP (match_operand:BFP 1 "register_operand" "f")))
7642 (match_operand:BFP 2 "const0_operand" "")))
7643 (set (match_operand:BFP 0 "register_operand" "=f")
7644 (neg:BFP (abs:BFP (match_dup 1))))]
7645 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7647 [(set_attr "op_type" "RRE")
7648 (set_attr "type" "fsimp<mode>")])
7650 ; lnxbr, lndbr, lnebr
7651 (define_insn "*negabs<mode>2_cconly"
7652 [(set (reg CC_REGNUM)
7653 (compare (neg:BFP (abs:BFP (match_operand:BFP 1 "register_operand" "f")))
7654 (match_operand:BFP 2 "const0_operand" "")))
7655 (clobber (match_scratch:BFP 0 "=f"))]
7656 "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT"
7658 [(set_attr "op_type" "RRE")
7659 (set_attr "type" "fsimp<mode>")])
7662 (define_insn "*negabs<mode>2_nocc"
7663 [(set (match_operand:FP 0 "register_operand" "=f")
7664 (neg:FP (abs:FP (match_operand:BFP 1 "register_operand" "<fT0>"))))]
7667 [(set_attr "op_type" "RRE")
7668 (set_attr "type" "fsimp<mode>")])
7670 ; lnxbr, lndbr, lnebr
7671 (define_insn "*negabs<mode>2"
7672 [(set (match_operand:BFP 0 "register_operand" "=f")
7673 (neg:BFP (abs:BFP (match_operand:BFP 1 "register_operand" "f"))))
7674 (clobber (reg:CC CC_REGNUM))]
7677 [(set_attr "op_type" "RRE")
7678 (set_attr "type" "fsimp<mode>")])
7681 ;;- Square root instructions.
7685 ; sqrt(df|sf)2 instruction pattern(s).
7688 ; sqxbr, sqdbr, sqebr, sqdb, sqeb
7689 (define_insn "sqrt<mode>2"
7690 [(set (match_operand:BFP 0 "register_operand" "=f,f")
7691 (sqrt:BFP (match_operand:BFP 1 "general_operand" "f,<Rf>")))]
7696 [(set_attr "op_type" "RRE,RXE")
7697 (set_attr "type" "fsqrt<mode>")])
7701 ;;- One complement instructions.
7705 ; one_cmpl(di|si|hi|qi)2 instruction pattern(s).
7708 (define_expand "one_cmpl<mode>2"
7710 [(set (match_operand:INT 0 "register_operand" "")
7711 (xor:INT (match_operand:INT 1 "register_operand" "")
7713 (clobber (reg:CC CC_REGNUM))])]
7719 ;; Find leftmost bit instructions.
7722 (define_expand "clzdi2"
7723 [(set (match_operand:DI 0 "register_operand" "=d")
7724 (clz:DI (match_operand:DI 1 "register_operand" "d")))]
7725 "TARGET_EXTIMM && TARGET_ZARCH"
7727 rtx insn, clz_equal;
7728 rtx wide_reg = gen_reg_rtx (TImode);
7729 rtx msb = gen_rtx_CONST_INT (DImode, (unsigned HOST_WIDE_INT) 1 << 63);
7731 clz_equal = gen_rtx_CLZ (DImode, operands[1]);
7733 emit_insn (gen_clztidi2 (wide_reg, operands[1], msb));
7735 insn = emit_move_insn (operands[0], gen_highpart (DImode, wide_reg));
7736 set_unique_reg_note (insn, REG_EQUAL, clz_equal);
7741 (define_insn "clztidi2"
7742 [(set (match_operand:TI 0 "register_operand" "=d")
7746 (xor:DI (match_operand:DI 1 "register_operand" "d")
7747 (lshiftrt (match_operand:DI 2 "const_int_operand" "")
7748 (subreg:SI (clz:DI (match_dup 1)) 4))))
7751 (zero_extend:TI (clz:DI (match_dup 1)))))
7752 (clobber (reg:CC CC_REGNUM))]
7753 "(unsigned HOST_WIDE_INT) INTVAL (operands[2])
7754 == (unsigned HOST_WIDE_INT) 1 << 63
7755 && TARGET_EXTIMM && TARGET_ZARCH"
7757 [(set_attr "op_type" "RRE")])
7761 ;;- Rotate instructions.
7765 ; rotl(di|si)3 instruction pattern(s).
7769 (define_insn "rotl<mode>3"
7770 [(set (match_operand:GPR 0 "register_operand" "=d")
7771 (rotate:GPR (match_operand:GPR 1 "register_operand" "d")
7772 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))]
7775 [(set_attr "op_type" "RSE")
7776 (set_attr "atype" "reg")
7777 (set_attr "z10prop" "z10_super_E1")])
7780 (define_insn "*rotl<mode>3_and"
7781 [(set (match_operand:GPR 0 "register_operand" "=d")
7782 (rotate:GPR (match_operand:GPR 1 "register_operand" "d")
7783 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")
7784 (match_operand:SI 3 "const_int_operand" "n"))))]
7785 "TARGET_CPU_ZARCH && (INTVAL (operands[3]) & 63) == 63"
7787 [(set_attr "op_type" "RSE")
7788 (set_attr "atype" "reg")
7789 (set_attr "z10prop" "z10_super_E1")])
7793 ;;- Shift instructions.
7797 ; (ashl|lshr)(di|si)3 instruction pattern(s).
7798 ; Left shifts and logical right shifts
7800 (define_expand "<shift><mode>3"
7801 [(set (match_operand:DSI 0 "register_operand" "")
7802 (SHIFT:DSI (match_operand:DSI 1 "register_operand" "")
7803 (match_operand:SI 2 "shift_count_or_setmem_operand" "")))]
7808 (define_insn "*<shift>di3_31"
7809 [(set (match_operand:DI 0 "register_operand" "=d")
7810 (SHIFT:DI (match_operand:DI 1 "register_operand" "0")
7811 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))]
7814 [(set_attr "op_type" "RS")
7815 (set_attr "atype" "reg")
7816 (set_attr "z196prop" "z196_cracked")])
7818 ; sll, srl, sllg, srlg, sllk, srlk
7819 (define_insn "*<shift><mode>3"
7820 [(set (match_operand:GPR 0 "register_operand" "=d,d")
7821 (SHIFT:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7822 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")))]
7825 s<lr>l<g>\t%0,<1>%Y2
7826 s<lr>l<gk>\t%0,%1,%Y2"
7827 [(set_attr "op_type" "RS<E>,RSY")
7828 (set_attr "atype" "reg,reg")
7829 (set_attr "cpu_facility" "*,z196")
7830 (set_attr "z10prop" "z10_super_E1,*")])
7833 (define_insn "*<shift>di3_31_and"
7834 [(set (match_operand:DI 0 "register_operand" "=d")
7835 (SHIFT:DI (match_operand:DI 1 "register_operand" "0")
7836 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")
7837 (match_operand:SI 3 "const_int_operand" "n"))))]
7838 "!TARGET_ZARCH && (INTVAL (operands[3]) & 63) == 63"
7840 [(set_attr "op_type" "RS")
7841 (set_attr "atype" "reg")])
7843 ; sll, srl, sllg, srlg, sllk, srlk
7844 (define_insn "*<shift><mode>3_and"
7845 [(set (match_operand:GPR 0 "register_operand" "=d,d")
7846 (SHIFT:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7847 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")
7848 (match_operand:SI 3 "const_int_operand" "n,n"))))]
7849 "(INTVAL (operands[3]) & 63) == 63"
7851 s<lr>l<g>\t%0,<1>%Y2
7852 s<lr>l<gk>\t%0,%1,%Y2"
7853 [(set_attr "op_type" "RS<E>,RSY")
7854 (set_attr "atype" "reg,reg")
7855 (set_attr "cpu_facility" "*,z196")
7856 (set_attr "z10prop" "z10_super_E1,*")])
7859 ; ashr(di|si)3 instruction pattern(s).
7860 ; Arithmetic right shifts
7862 (define_expand "ashr<mode>3"
7864 [(set (match_operand:DSI 0 "register_operand" "")
7865 (ashiftrt:DSI (match_operand:DSI 1 "register_operand" "")
7866 (match_operand:SI 2 "shift_count_or_setmem_operand" "")))
7867 (clobber (reg:CC CC_REGNUM))])]
7871 (define_insn "*ashrdi3_cc_31"
7872 [(set (reg CC_REGNUM)
7873 (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7874 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y"))
7876 (set (match_operand:DI 0 "register_operand" "=d")
7877 (ashiftrt:DI (match_dup 1) (match_dup 2)))]
7878 "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)"
7880 [(set_attr "op_type" "RS")
7881 (set_attr "atype" "reg")])
7883 (define_insn "*ashrdi3_cconly_31"
7884 [(set (reg CC_REGNUM)
7885 (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7886 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y"))
7888 (clobber (match_scratch:DI 0 "=d"))]
7889 "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)"
7891 [(set_attr "op_type" "RS")
7892 (set_attr "atype" "reg")])
7894 (define_insn "*ashrdi3_31"
7895 [(set (match_operand:DI 0 "register_operand" "=d")
7896 (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7897 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))
7898 (clobber (reg:CC CC_REGNUM))]
7901 [(set_attr "op_type" "RS")
7902 (set_attr "atype" "reg")])
7905 (define_insn "*ashr<mode>3_cc"
7906 [(set (reg CC_REGNUM)
7907 (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7908 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y"))
7910 (set (match_operand:GPR 0 "register_operand" "=d,d")
7911 (ashiftrt:GPR (match_dup 1) (match_dup 2)))]
7912 "s390_match_ccmode(insn, CCSmode)"
7916 [(set_attr "op_type" "RS<E>,RSY")
7917 (set_attr "atype" "reg,reg")
7918 (set_attr "cpu_facility" "*,z196")
7919 (set_attr "z10prop" "z10_super_E1,*")])
7922 (define_insn "*ashr<mode>3_cconly"
7923 [(set (reg CC_REGNUM)
7924 (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7925 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y"))
7927 (clobber (match_scratch:GPR 0 "=d,d"))]
7928 "s390_match_ccmode(insn, CCSmode)"
7932 [(set_attr "op_type" "RS<E>,RSY")
7933 (set_attr "atype" "reg,reg")
7934 (set_attr "cpu_facility" "*,z196")
7935 (set_attr "z10prop" "z10_super_E1,*")])
7938 (define_insn "*ashr<mode>3"
7939 [(set (match_operand:GPR 0 "register_operand" "=d,d")
7940 (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7941 (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")))
7942 (clobber (reg:CC CC_REGNUM))]
7947 [(set_attr "op_type" "RS<E>,RSY")
7948 (set_attr "atype" "reg,reg")
7949 (set_attr "cpu_facility" "*,z196")
7950 (set_attr "z10prop" "z10_super_E1,*")])
7953 ; shift pattern with implicit ANDs
7955 (define_insn "*ashrdi3_cc_31_and"
7956 [(set (reg CC_REGNUM)
7957 (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7958 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")
7959 (match_operand:SI 3 "const_int_operand" "n")))
7961 (set (match_operand:DI 0 "register_operand" "=d")
7962 (ashiftrt:DI (match_dup 1) (and:SI (match_dup 2) (match_dup 3))))]
7963 "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)
7964 && (INTVAL (operands[3]) & 63) == 63"
7966 [(set_attr "op_type" "RS")
7967 (set_attr "atype" "reg")])
7969 (define_insn "*ashrdi3_cconly_31_and"
7970 [(set (reg CC_REGNUM)
7971 (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7972 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")
7973 (match_operand:SI 3 "const_int_operand" "n")))
7975 (clobber (match_scratch:DI 0 "=d"))]
7976 "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)
7977 && (INTVAL (operands[3]) & 63) == 63"
7979 [(set_attr "op_type" "RS")
7980 (set_attr "atype" "reg")])
7982 (define_insn "*ashrdi3_31_and"
7983 [(set (match_operand:DI 0 "register_operand" "=d")
7984 (ashiftrt:DI (match_operand:DI 1 "register_operand" "0")
7985 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")
7986 (match_operand:SI 3 "const_int_operand" "n"))))
7987 (clobber (reg:CC CC_REGNUM))]
7988 "!TARGET_ZARCH && (INTVAL (operands[3]) & 63) == 63"
7990 [(set_attr "op_type" "RS")
7991 (set_attr "atype" "reg")])
7994 (define_insn "*ashr<mode>3_cc_and"
7995 [(set (reg CC_REGNUM)
7996 (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
7997 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")
7998 (match_operand:SI 3 "const_int_operand" "n,n")))
8000 (set (match_operand:GPR 0 "register_operand" "=d,d")
8001 (ashiftrt:GPR (match_dup 1) (and:SI (match_dup 2) (match_dup 3))))]
8002 "s390_match_ccmode(insn, CCSmode) && (INTVAL (operands[3]) & 63) == 63"
8006 [(set_attr "op_type" "RS<E>,RSY")
8007 (set_attr "atype" "reg,reg")
8008 (set_attr "cpu_facility" "*,z196")
8009 (set_attr "z10prop" "z10_super_E1,*")])
8012 (define_insn "*ashr<mode>3_cconly_and"
8013 [(set (reg CC_REGNUM)
8014 (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
8015 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")
8016 (match_operand:SI 3 "const_int_operand" "n,n")))
8018 (clobber (match_scratch:GPR 0 "=d,d"))]
8019 "s390_match_ccmode(insn, CCSmode) && (INTVAL (operands[3]) & 63) == 63"
8023 [(set_attr "op_type" "RS<E>,RSY")
8024 (set_attr "atype" "reg,reg")
8025 (set_attr "cpu_facility" "*,z196")
8026 (set_attr "z10prop" "z10_super_E1,*")])
8029 (define_insn "*ashr<mode>3_and"
8030 [(set (match_operand:GPR 0 "register_operand" "=d,d")
8031 (ashiftrt:GPR (match_operand:GPR 1 "register_operand" "<d0>,d")
8032 (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")
8033 (match_operand:SI 3 "const_int_operand" "n,n"))))
8034 (clobber (reg:CC CC_REGNUM))]
8035 "(INTVAL (operands[3]) & 63) == 63"
8039 [(set_attr "op_type" "RS<E>,RSY")
8040 (set_attr "atype" "reg,reg")
8041 (set_attr "cpu_facility" "*,z196")
8042 (set_attr "z10prop" "z10_super_E1,*")])
8046 ;; Branch instruction patterns.
8049 (define_expand "cbranch<mode>4"
8051 (if_then_else (match_operator 0 "comparison_operator"
8052 [(match_operand:GPR 1 "register_operand" "")
8053 (match_operand:GPR 2 "general_operand" "")])
8054 (label_ref (match_operand 3 "" ""))
8057 "s390_emit_jump (operands[3],
8058 s390_emit_compare (GET_CODE (operands[0]), operands[1], operands[2]));
8061 (define_expand "cbranch<mode>4"
8063 (if_then_else (match_operator 0 "comparison_operator"
8064 [(match_operand:FP 1 "register_operand" "")
8065 (match_operand:FP 2 "general_operand" "")])
8066 (label_ref (match_operand 3 "" ""))
8069 "s390_emit_jump (operands[3],
8070 s390_emit_compare (GET_CODE (operands[0]), operands[1], operands[2]));
8073 (define_expand "cbranchcc4"
8075 (if_then_else (match_operator 0 "s390_eqne_operator"
8076 [(match_operand 1 "cc_reg_operand" "")
8077 (match_operand 2 "const0_operand" "")])
8078 (label_ref (match_operand 3 "" ""))
8081 "s390_emit_jump (operands[3],
8082 s390_emit_compare (GET_CODE (operands[0]), operands[1], operands[2]));
8088 ;;- Conditional jump instructions.
8091 (define_insn "*cjump_64"
8094 (match_operator 1 "s390_comparison" [(reg CC_REGNUM)
8095 (match_operand 2 "const_int_operand" "")])
8096 (label_ref (match_operand 0 "" ""))
8100 if (get_attr_length (insn) == 4)
8103 return "jg%C1\t%l0";
8105 [(set_attr "op_type" "RI")
8106 (set_attr "type" "branch")
8107 (set (attr "length")
8108 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8109 (const_int 4) (const_int 6)))])
8111 (define_insn "*cjump_31"
8114 (match_operator 1 "s390_comparison" [(reg CC_REGNUM)
8115 (match_operand 2 "const_int_operand" "")])
8116 (label_ref (match_operand 0 "" ""))
8120 gcc_assert (get_attr_length (insn) == 4);
8123 [(set_attr "op_type" "RI")
8124 (set_attr "type" "branch")
8125 (set (attr "length")
8126 (if_then_else (not (match_test "flag_pic"))
8127 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8128 (const_int 4) (const_int 6))
8129 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8130 (const_int 4) (const_int 8))))])
8132 (define_insn "*cjump_long"
8135 (match_operator 1 "s390_comparison" [(reg CC_REGNUM) (const_int 0)])
8136 (match_operand 0 "address_operand" "ZQZR")
8140 if (get_attr_op_type (insn) == OP_TYPE_RR)
8145 [(set (attr "op_type")
8146 (if_then_else (match_operand 0 "register_operand" "")
8147 (const_string "RR") (const_string "RX")))
8148 (set_attr "type" "branch")
8149 (set_attr "atype" "agen")])
8151 ;; A conditional return instruction.
8152 (define_insn "*c<code>"
8155 (match_operator 0 "s390_comparison" [(reg CC_REGNUM) (const_int 0)])
8158 "s390_can_use_<code>_insn ()"
8160 [(set_attr "op_type" "RR")
8161 (set_attr "type" "jsr")
8162 (set_attr "atype" "agen")])
8165 ;;- Negated conditional jump instructions.
8168 (define_insn "*icjump_64"
8171 (match_operator 1 "s390_comparison" [(reg CC_REGNUM) (const_int 0)])
8173 (label_ref (match_operand 0 "" ""))))]
8176 if (get_attr_length (insn) == 4)
8179 return "jg%D1\t%l0";
8181 [(set_attr "op_type" "RI")
8182 (set_attr "type" "branch")
8183 (set (attr "length")
8184 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8185 (const_int 4) (const_int 6)))])
8187 (define_insn "*icjump_31"
8190 (match_operator 1 "s390_comparison" [(reg CC_REGNUM) (const_int 0)])
8192 (label_ref (match_operand 0 "" ""))))]
8195 gcc_assert (get_attr_length (insn) == 4);
8198 [(set_attr "op_type" "RI")
8199 (set_attr "type" "branch")
8200 (set (attr "length")
8201 (if_then_else (not (match_test "flag_pic"))
8202 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8203 (const_int 4) (const_int 6))
8204 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8205 (const_int 4) (const_int 8))))])
8207 (define_insn "*icjump_long"
8210 (match_operator 1 "s390_comparison" [(reg CC_REGNUM) (const_int 0)])
8212 (match_operand 0 "address_operand" "ZQZR")))]
8215 if (get_attr_op_type (insn) == OP_TYPE_RR)
8220 [(set (attr "op_type")
8221 (if_then_else (match_operand 0 "register_operand" "")
8222 (const_string "RR") (const_string "RX")))
8223 (set_attr "type" "branch")
8224 (set_attr "atype" "agen")])
8227 ;;- Trap instructions.
8231 [(trap_if (const_int 1) (const_int 0))]
8234 [(set_attr "op_type" "RI")
8235 (set_attr "type" "branch")])
8237 (define_expand "ctrap<mode>4"
8238 [(trap_if (match_operator 0 "comparison_operator"
8239 [(match_operand:GPR 1 "register_operand" "")
8240 (match_operand:GPR 2 "general_operand" "")])
8241 (match_operand 3 "const0_operand" ""))]
8244 rtx cond = s390_emit_compare (GET_CODE (operands[0]),
8245 operands[1], operands[2]);
8246 emit_insn (gen_condtrap (cond, XEXP (cond, 0)));
8250 (define_expand "ctrap<mode>4"
8251 [(trap_if (match_operator 0 "comparison_operator"
8252 [(match_operand:FP 1 "register_operand" "")
8253 (match_operand:FP 2 "general_operand" "")])
8254 (match_operand 3 "const0_operand" ""))]
8257 rtx cond = s390_emit_compare (GET_CODE (operands[0]),
8258 operands[1], operands[2]);
8259 emit_insn (gen_condtrap (cond, XEXP (cond, 0)));
8263 (define_insn "condtrap"
8264 [(trap_if (match_operator 0 "s390_comparison"
8265 [(match_operand 1 "cc_reg_operand" "c")
8270 [(set_attr "op_type" "RI")
8271 (set_attr "type" "branch")])
8273 ; crt, cgrt, cit, cgit
8274 (define_insn "*cmp_and_trap_signed_int<mode>"
8275 [(trap_if (match_operator 0 "s390_signed_integer_comparison"
8276 [(match_operand:GPR 1 "register_operand" "d,d")
8277 (match_operand:GPR 2 "nonmemory_operand" "d,K")])
8283 [(set_attr "op_type" "RRF,RIE")
8284 (set_attr "type" "branch")
8285 (set_attr "z10prop" "z10_super_c,z10_super")])
8287 ; clrt, clgrt, clfit, clgit, clt, clgt
8288 (define_insn "*cmp_and_trap_unsigned_int<mode>"
8289 [(trap_if (match_operator 0 "s390_unsigned_integer_comparison"
8290 [(match_operand:GPR 1 "register_operand" "d,d, d")
8291 (match_operand:GPR 2 "general_operand" "d,D,RT")])
8298 [(set_attr "op_type" "RRF,RIE,RSY")
8299 (set_attr "type" "branch")
8300 (set_attr "z10prop" "z10_super_c,z10_super,*")
8301 (set_attr "cpu_facility" "z10,z10,zEC12")])
8304 (define_insn "*load_and_trap<mode>"
8305 [(trap_if (eq (match_operand:GPR 0 "memory_operand" "RT")
8308 (set (match_operand:GPR 1 "register_operand" "=d")
8312 [(set_attr "op_type" "RXY")])
8316 ;;- Loop instructions.
8318 ;; This is all complicated by the fact that since this is a jump insn
8319 ;; we must handle our own output reloads.
8323 ; This splitter will be matched by combine and has to add the 2 moves
8324 ; necessary to load the compare and the increment values into a
8325 ; register pair as needed by brxle.
8327 (define_insn_and_split "*brx_stage1_<GPR:mode>"
8330 (match_operator 6 "s390_brx_operator"
8331 [(plus:GPR (match_operand:GPR 1 "register_operand" "")
8332 (match_operand:GPR 2 "general_operand" ""))
8333 (match_operand:GPR 3 "register_operand" "")])
8334 (label_ref (match_operand 0 "" ""))
8336 (set (match_operand:GPR 4 "nonimmediate_operand" "")
8337 (plus:GPR (match_dup 1) (match_dup 2)))
8338 (clobber (match_scratch:GPR 5 ""))]
8341 "!reload_completed && !reload_in_progress"
8342 [(set (match_dup 7) (match_dup 2)) ; the increment
8343 (set (match_dup 8) (match_dup 3)) ; the comparison value
8344 (parallel [(set (pc)
8347 [(plus:GPR (match_dup 1) (match_dup 7))
8349 (label_ref (match_dup 0))
8352 (plus:GPR (match_dup 1) (match_dup 7)))
8353 (clobber (match_dup 5))
8354 (clobber (reg:CC CC_REGNUM))])]
8356 rtx dreg = gen_reg_rtx (word_mode == DImode ? TImode : DImode);
8357 operands[7] = gen_lowpart (<GPR:MODE>mode,
8358 gen_highpart (word_mode, dreg));
8359 operands[8] = gen_lowpart (<GPR:MODE>mode,
8360 gen_lowpart (word_mode, dreg));
8365 (define_insn_and_split "*brxg_64bit"
8368 (match_operator 5 "s390_brx_operator"
8369 [(plus:DI (match_operand:DI 1 "register_operand" "d,d,d")
8370 (subreg:DI (match_operand:TI 2 "register_operand" "d,d,d") 0))
8371 (subreg:DI (match_dup 2) 8)])
8372 (label_ref (match_operand 0 "" ""))
8374 (set (match_operand:DI 3 "nonimmediate_operand" "=1,?X,?X")
8375 (plus:DI (match_dup 1)
8376 (subreg:DI (match_dup 2) 0)))
8377 (clobber (match_scratch:DI 4 "=X,&1,&?d"))
8378 (clobber (reg:CC CC_REGNUM))]
8381 if (which_alternative != 0)
8383 else if (get_attr_length (insn) == 6)
8384 return "brx%E5g\t%1,%2,%l0";
8386 return "agr\t%1,%2\;cgr\t%1,%M2\;jg%C5\t%l0";
8388 "&& reload_completed
8389 && (!REG_P (operands[3])
8390 || !rtx_equal_p (operands[1], operands[3]))"
8391 [(set (match_dup 4) (match_dup 1))
8392 (parallel [(set (match_dup 4) (plus:DI (match_dup 4) (subreg:DI (match_dup 2) 0)))
8393 (clobber (reg:CC CC_REGNUM))])
8394 (set (reg:CCS CC_REGNUM) (compare:CCS (match_dup 4) (subreg:DI (match_dup 2) 8)))
8395 (set (match_dup 3) (match_dup 4))
8396 (set (pc) (if_then_else (match_op_dup 5 [(reg:CCS CC_REGNUM) (const_int 0)])
8397 (label_ref (match_dup 0))
8400 [(set_attr "op_type" "RIE")
8401 (set_attr "type" "branch")
8402 (set (attr "length")
8403 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8404 (const_int 6) (const_int 16)))])
8408 (define_insn_and_split "*brx_64bit"
8411 (match_operator 5 "s390_brx_operator"
8412 [(plus:SI (match_operand:SI 1 "register_operand" "d,d,d")
8413 (subreg:SI (match_operand:TI 2 "register_operand" "d,d,d") 4))
8414 (subreg:SI (match_dup 2) 12)])
8415 (label_ref (match_operand 0 "" ""))
8417 (set (match_operand:SI 3 "nonimmediate_operand" "=1,?X,?X")
8418 (plus:SI (match_dup 1)
8419 (subreg:SI (match_dup 2) 4)))
8420 (clobber (match_scratch:SI 4 "=X,&1,&?d"))
8421 (clobber (reg:CC CC_REGNUM))]
8424 if (which_alternative != 0)
8426 else if (get_attr_length (insn) == 6)
8427 return "brx%C5\t%1,%2,%l0";
8429 return "ar\t%1,%2\;cr\t%1,%M2\;jg%C5\t%l0";
8431 "&& reload_completed
8432 && (!REG_P (operands[3])
8433 || !rtx_equal_p (operands[1], operands[3]))"
8434 [(set (match_dup 4) (match_dup 1))
8435 (parallel [(set (match_dup 4) (plus:SI (match_dup 4) (subreg:SI (match_dup 2) 4)))
8436 (clobber (reg:CC CC_REGNUM))])
8437 (set (reg:CCS CC_REGNUM) (compare:CCS (match_dup 4) (subreg:SI (match_dup 2) 12)))
8438 (set (match_dup 3) (match_dup 4))
8439 (set (pc) (if_then_else (match_op_dup 5 [(reg:CCS CC_REGNUM) (const_int 0)])
8440 (label_ref (match_dup 0))
8443 [(set_attr "op_type" "RSI")
8444 (set_attr "type" "branch")
8445 (set (attr "length")
8446 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8447 (const_int 6) (const_int 14)))])
8451 (define_insn_and_split "*brx_31bit"
8454 (match_operator 5 "s390_brx_operator"
8455 [(plus:SI (match_operand:SI 1 "register_operand" "d,d,d")
8456 (subreg:SI (match_operand:DI 2 "register_operand" "d,d,d") 0))
8457 (subreg:SI (match_dup 2) 4)])
8458 (label_ref (match_operand 0 "" ""))
8460 (set (match_operand:SI 3 "nonimmediate_operand" "=1,?X,?X")
8461 (plus:SI (match_dup 1)
8462 (subreg:SI (match_dup 2) 0)))
8463 (clobber (match_scratch:SI 4 "=X,&1,&?d"))
8464 (clobber (reg:CC CC_REGNUM))]
8465 "!TARGET_ZARCH && TARGET_CPU_ZARCH"
8467 if (which_alternative != 0)
8469 else if (get_attr_length (insn) == 6)
8470 return "brx%C5\t%1,%2,%l0";
8472 return "ar\t%1,%2\;cr\t%1,%M2\;jg%C5\t%l0";
8474 "&& reload_completed
8475 && (!REG_P (operands[3])
8476 || !rtx_equal_p (operands[1], operands[3]))"
8477 [(set (match_dup 4) (match_dup 1))
8478 (parallel [(set (match_dup 4) (plus:SI (match_dup 4) (subreg:SI (match_dup 2) 0)))
8479 (clobber (reg:CC CC_REGNUM))])
8480 (set (reg:CCS CC_REGNUM) (compare:CCS (match_dup 4) (subreg:SI (match_dup 2) 4)))
8481 (set (match_dup 3) (match_dup 4))
8482 (set (pc) (if_then_else (match_op_dup 5 [(reg:CCS CC_REGNUM) (const_int 0)])
8483 (label_ref (match_dup 0))
8486 [(set_attr "op_type" "RSI")
8487 (set_attr "type" "branch")
8488 (set (attr "length")
8489 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8490 (const_int 6) (const_int 14)))])
8495 (define_expand "doloop_end"
8496 [(use (match_operand 0 "" "")) ; loop pseudo
8497 (use (match_operand 1 "" ""))] ; label
8500 if (GET_MODE (operands[0]) == SImode && !TARGET_CPU_ZARCH)
8501 emit_jump_insn (gen_doloop_si31 (operands[1], operands[0], operands[0]));
8502 else if (GET_MODE (operands[0]) == SImode && TARGET_CPU_ZARCH)
8503 emit_jump_insn (gen_doloop_si64 (operands[1], operands[0], operands[0]));
8504 else if (GET_MODE (operands[0]) == DImode && TARGET_ZARCH)
8505 emit_jump_insn (gen_doloop_di (operands[1], operands[0], operands[0]));
8512 (define_insn_and_split "doloop_si64"
8515 (ne (match_operand:SI 1 "register_operand" "d,d,d")
8517 (label_ref (match_operand 0 "" ""))
8519 (set (match_operand:SI 2 "nonimmediate_operand" "=1,?X,?X")
8520 (plus:SI (match_dup 1) (const_int -1)))
8521 (clobber (match_scratch:SI 3 "=X,&1,&?d"))
8522 (clobber (reg:CC CC_REGNUM))]
8525 if (which_alternative != 0)
8527 else if (get_attr_length (insn) == 4)
8528 return "brct\t%1,%l0";
8530 return "ahi\t%1,-1\;jgne\t%l0";
8532 "&& reload_completed
8533 && (! REG_P (operands[2])
8534 || ! rtx_equal_p (operands[1], operands[2]))"
8535 [(set (match_dup 3) (match_dup 1))
8536 (parallel [(set (reg:CCAN CC_REGNUM)
8537 (compare:CCAN (plus:SI (match_dup 3) (const_int -1))
8539 (set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))])
8540 (set (match_dup 2) (match_dup 3))
8541 (set (pc) (if_then_else (ne (reg:CCAN CC_REGNUM) (const_int 0))
8542 (label_ref (match_dup 0))
8545 [(set_attr "op_type" "RI")
8546 ; Strictly speaking, the z10 properties are valid for brct only, however, it does not
8547 ; hurt us in the (rare) case of ahi.
8548 (set_attr "z10prop" "z10_super_E1")
8549 (set_attr "type" "branch")
8550 (set (attr "length")
8551 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8552 (const_int 4) (const_int 10)))])
8554 (define_insn_and_split "doloop_si31"
8557 (ne (match_operand:SI 1 "register_operand" "d,d,d")
8559 (label_ref (match_operand 0 "" ""))
8561 (set (match_operand:SI 2 "nonimmediate_operand" "=1,?X,?X")
8562 (plus:SI (match_dup 1) (const_int -1)))
8563 (clobber (match_scratch:SI 3 "=X,&1,&?d"))
8564 (clobber (reg:CC CC_REGNUM))]
8567 if (which_alternative != 0)
8569 else if (get_attr_length (insn) == 4)
8570 return "brct\t%1,%l0";
8574 "&& reload_completed
8575 && (! REG_P (operands[2])
8576 || ! rtx_equal_p (operands[1], operands[2]))"
8577 [(set (match_dup 3) (match_dup 1))
8578 (parallel [(set (reg:CCAN CC_REGNUM)
8579 (compare:CCAN (plus:SI (match_dup 3) (const_int -1))
8581 (set (match_dup 3) (plus:SI (match_dup 3) (const_int -1)))])
8582 (set (match_dup 2) (match_dup 3))
8583 (set (pc) (if_then_else (ne (reg:CCAN CC_REGNUM) (const_int 0))
8584 (label_ref (match_dup 0))
8587 [(set_attr "op_type" "RI")
8588 ; Strictly speaking, the z10 properties are valid for brct only, however, it does not
8589 ; hurt us in the (rare) case of ahi.
8590 (set_attr "z10prop" "z10_super_E1")
8591 (set_attr "type" "branch")
8592 (set (attr "length")
8593 (if_then_else (not (match_test "flag_pic"))
8594 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8595 (const_int 4) (const_int 6))
8596 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8597 (const_int 4) (const_int 8))))])
8599 (define_insn "*doloop_si_long"
8602 (ne (match_operand:SI 1 "register_operand" "d")
8604 (match_operand 0 "address_operand" "ZQZR")
8606 (set (match_operand:SI 2 "register_operand" "=1")
8607 (plus:SI (match_dup 1) (const_int -1)))
8608 (clobber (match_scratch:SI 3 "=X"))
8609 (clobber (reg:CC CC_REGNUM))]
8612 if (get_attr_op_type (insn) == OP_TYPE_RR)
8613 return "bctr\t%1,%0";
8615 return "bct\t%1,%a0";
8617 [(set (attr "op_type")
8618 (if_then_else (match_operand 0 "register_operand" "")
8619 (const_string "RR") (const_string "RX")))
8620 (set_attr "type" "branch")
8621 (set_attr "atype" "agen")
8622 (set_attr "z10prop" "z10_c")
8623 (set_attr "z196prop" "z196_cracked")])
8625 (define_insn_and_split "doloop_di"
8628 (ne (match_operand:DI 1 "register_operand" "d,d,d")
8630 (label_ref (match_operand 0 "" ""))
8632 (set (match_operand:DI 2 "nonimmediate_operand" "=1,?X,?X")
8633 (plus:DI (match_dup 1) (const_int -1)))
8634 (clobber (match_scratch:DI 3 "=X,&1,&?d"))
8635 (clobber (reg:CC CC_REGNUM))]
8638 if (which_alternative != 0)
8640 else if (get_attr_length (insn) == 4)
8641 return "brctg\t%1,%l0";
8643 return "aghi\t%1,-1\;jgne\t%l0";
8645 "&& reload_completed
8646 && (! REG_P (operands[2])
8647 || ! rtx_equal_p (operands[1], operands[2]))"
8648 [(set (match_dup 3) (match_dup 1))
8649 (parallel [(set (reg:CCAN CC_REGNUM)
8650 (compare:CCAN (plus:DI (match_dup 3) (const_int -1))
8652 (set (match_dup 3) (plus:DI (match_dup 3) (const_int -1)))])
8653 (set (match_dup 2) (match_dup 3))
8654 (set (pc) (if_then_else (ne (reg:CCAN CC_REGNUM) (const_int 0))
8655 (label_ref (match_dup 0))
8658 [(set_attr "op_type" "RI")
8659 ; Strictly speaking, the z10 properties are valid for brct only, however, it does not
8660 ; hurt us in the (rare) case of ahi.
8661 (set_attr "z10prop" "z10_super_E1")
8662 (set_attr "type" "branch")
8663 (set (attr "length")
8664 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8665 (const_int 4) (const_int 10)))])
8668 ;;- Unconditional jump instructions.
8672 ; jump instruction pattern(s).
8675 (define_expand "jump"
8676 [(match_operand 0 "" "")]
8678 "s390_emit_jump (operands[0], NULL_RTX); DONE;")
8680 (define_insn "*jump64"
8681 [(set (pc) (label_ref (match_operand 0 "" "")))]
8684 if (get_attr_length (insn) == 4)
8689 [(set_attr "op_type" "RI")
8690 (set_attr "type" "branch")
8691 (set (attr "length")
8692 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8693 (const_int 4) (const_int 6)))])
8695 (define_insn "*jump31"
8696 [(set (pc) (label_ref (match_operand 0 "" "")))]
8699 gcc_assert (get_attr_length (insn) == 4);
8702 [(set_attr "op_type" "RI")
8703 (set_attr "type" "branch")
8704 (set (attr "length")
8705 (if_then_else (not (match_test "flag_pic"))
8706 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8707 (const_int 4) (const_int 6))
8708 (if_then_else (lt (abs (minus (pc) (match_dup 0))) (const_int 60000))
8709 (const_int 4) (const_int 8))))])
8712 ; indirect-jump instruction pattern(s).
8715 (define_insn "indirect_jump"
8716 [(set (pc) (match_operand 0 "address_operand" "ZQZR"))]
8719 if (get_attr_op_type (insn) == OP_TYPE_RR)
8724 [(set (attr "op_type")
8725 (if_then_else (match_operand 0 "register_operand" "")
8726 (const_string "RR") (const_string "RX")))
8727 (set_attr "type" "branch")
8728 (set_attr "atype" "agen")])
8731 ; casesi instruction pattern(s).
8734 (define_insn "casesi_jump"
8735 [(set (pc) (match_operand 0 "address_operand" "ZQZR"))
8736 (use (label_ref (match_operand 1 "" "")))]
8739 if (get_attr_op_type (insn) == OP_TYPE_RR)
8744 [(set (attr "op_type")
8745 (if_then_else (match_operand 0 "register_operand" "")
8746 (const_string "RR") (const_string "RX")))
8747 (set_attr "type" "branch")
8748 (set_attr "atype" "agen")])
8750 (define_expand "casesi"
8751 [(match_operand:SI 0 "general_operand" "")
8752 (match_operand:SI 1 "general_operand" "")
8753 (match_operand:SI 2 "general_operand" "")
8754 (label_ref (match_operand 3 "" ""))
8755 (label_ref (match_operand 4 "" ""))]
8758 rtx index = gen_reg_rtx (SImode);
8759 rtx base = gen_reg_rtx (Pmode);
8760 rtx target = gen_reg_rtx (Pmode);
8762 emit_move_insn (index, operands[0]);
8763 emit_insn (gen_subsi3 (index, index, operands[1]));
8764 emit_cmp_and_jump_insns (index, operands[2], GTU, NULL_RTX, SImode, 1,
8767 if (Pmode != SImode)
8768 index = convert_to_mode (Pmode, index, 1);
8769 if (GET_CODE (index) != REG)
8770 index = copy_to_mode_reg (Pmode, index);
8773 emit_insn (gen_ashldi3 (index, index, GEN_INT (3)));
8775 emit_insn (gen_ashlsi3 (index, index, const2_rtx));
8777 emit_move_insn (base, gen_rtx_LABEL_REF (Pmode, operands[3]));
8779 index = gen_const_mem (Pmode, gen_rtx_PLUS (Pmode, base, index));
8780 emit_move_insn (target, index);
8783 target = gen_rtx_PLUS (Pmode, base, target);
8784 emit_jump_insn (gen_casesi_jump (target, operands[3]));
8791 ;;- Jump to subroutine.
8796 ; untyped call instruction pattern(s).
8799 ;; Call subroutine returning any type.
8800 (define_expand "untyped_call"
8801 [(parallel [(call (match_operand 0 "" "")
8803 (match_operand 1 "" "")
8804 (match_operand 2 "" "")])]
8809 emit_call_insn (gen_call (operands[0], const0_rtx, const0_rtx));
8811 for (i = 0; i < XVECLEN (operands[2], 0); i++)
8813 rtx set = XVECEXP (operands[2], 0, i);
8814 emit_move_insn (SET_DEST (set), SET_SRC (set));
8817 /* The optimizer does not know that the call sets the function value
8818 registers we stored in the result block. We avoid problems by
8819 claiming that all hard registers are used and clobbered at this
8821 emit_insn (gen_blockage ());
8826 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
8827 ;; all of memory. This blocks insns from being moved across this point.
8829 (define_insn "blockage"
8830 [(unspec_volatile [(const_int 0)] UNSPECV_BLOCKAGE)]
8833 [(set_attr "type" "none")
8834 (set_attr "length" "0")])
8840 (define_expand "sibcall"
8841 [(call (match_operand 0 "" "")
8842 (match_operand 1 "" ""))]
8845 s390_emit_call (XEXP (operands[0], 0), NULL_RTX, NULL_RTX, NULL_RTX);
8849 (define_insn "*sibcall_br"
8850 [(call (mem:QI (reg SIBCALL_REGNUM))
8851 (match_operand 0 "const_int_operand" "n"))]
8852 "SIBLING_CALL_P (insn)
8853 && GET_MODE (XEXP (XEXP (PATTERN (insn), 0), 0)) == Pmode"
8855 [(set_attr "op_type" "RR")
8856 (set_attr "type" "branch")
8857 (set_attr "atype" "agen")])
8859 (define_insn "*sibcall_brc"
8860 [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
8861 (match_operand 1 "const_int_operand" "n"))]
8862 "SIBLING_CALL_P (insn) && TARGET_SMALL_EXEC"
8864 [(set_attr "op_type" "RI")
8865 (set_attr "type" "branch")])
8867 (define_insn "*sibcall_brcl"
8868 [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
8869 (match_operand 1 "const_int_operand" "n"))]
8870 "SIBLING_CALL_P (insn) && TARGET_CPU_ZARCH"
8872 [(set_attr "op_type" "RIL")
8873 (set_attr "type" "branch")])
8876 ; sibcall_value patterns
8879 (define_expand "sibcall_value"
8880 [(set (match_operand 0 "" "")
8881 (call (match_operand 1 "" "")
8882 (match_operand 2 "" "")))]
8885 s390_emit_call (XEXP (operands[1], 0), NULL_RTX, operands[0], NULL_RTX);
8889 (define_insn "*sibcall_value_br"
8890 [(set (match_operand 0 "" "")
8891 (call (mem:QI (reg SIBCALL_REGNUM))
8892 (match_operand 1 "const_int_operand" "n")))]
8893 "SIBLING_CALL_P (insn)
8894 && GET_MODE (XEXP (XEXP (XEXP (PATTERN (insn), 1), 0), 0)) == Pmode"
8896 [(set_attr "op_type" "RR")
8897 (set_attr "type" "branch")
8898 (set_attr "atype" "agen")])
8900 (define_insn "*sibcall_value_brc"
8901 [(set (match_operand 0 "" "")
8902 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
8903 (match_operand 2 "const_int_operand" "n")))]
8904 "SIBLING_CALL_P (insn) && TARGET_SMALL_EXEC"
8906 [(set_attr "op_type" "RI")
8907 (set_attr "type" "branch")])
8909 (define_insn "*sibcall_value_brcl"
8910 [(set (match_operand 0 "" "")
8911 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
8912 (match_operand 2 "const_int_operand" "n")))]
8913 "SIBLING_CALL_P (insn) && TARGET_CPU_ZARCH"
8915 [(set_attr "op_type" "RIL")
8916 (set_attr "type" "branch")])
8920 ; call instruction pattern(s).
8923 (define_expand "call"
8924 [(call (match_operand 0 "" "")
8925 (match_operand 1 "" ""))
8926 (use (match_operand 2 "" ""))]
8929 s390_emit_call (XEXP (operands[0], 0), NULL_RTX, NULL_RTX,
8930 gen_rtx_REG (Pmode, RETURN_REGNUM));
8934 (define_insn "*bras"
8935 [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
8936 (match_operand 1 "const_int_operand" "n"))
8937 (clobber (match_operand 2 "register_operand" "=r"))]
8938 "!SIBLING_CALL_P (insn)
8939 && TARGET_SMALL_EXEC
8940 && GET_MODE (operands[2]) == Pmode"
8942 [(set_attr "op_type" "RI")
8943 (set_attr "type" "jsr")
8944 (set_attr "z196prop" "z196_cracked")])
8946 (define_insn "*brasl"
8947 [(call (mem:QI (match_operand 0 "bras_sym_operand" "X"))
8948 (match_operand 1 "const_int_operand" "n"))
8949 (clobber (match_operand 2 "register_operand" "=r"))]
8950 "!SIBLING_CALL_P (insn)
8952 && GET_MODE (operands[2]) == Pmode"
8954 [(set_attr "op_type" "RIL")
8955 (set_attr "type" "jsr")
8956 (set_attr "z196prop" "z196_cracked")])
8958 (define_insn "*basr"
8959 [(call (mem:QI (match_operand 0 "address_operand" "ZQZR"))
8960 (match_operand 1 "const_int_operand" "n"))
8961 (clobber (match_operand 2 "register_operand" "=r"))]
8962 "!SIBLING_CALL_P (insn) && GET_MODE (operands[2]) == Pmode"
8964 if (get_attr_op_type (insn) == OP_TYPE_RR)
8965 return "basr\t%2,%0";
8967 return "bas\t%2,%a0";
8969 [(set (attr "op_type")
8970 (if_then_else (match_operand 0 "register_operand" "")
8971 (const_string "RR") (const_string "RX")))
8972 (set_attr "type" "jsr")
8973 (set_attr "atype" "agen")
8974 (set_attr "z196prop" "z196_cracked")])
8977 ; call_value instruction pattern(s).
8980 (define_expand "call_value"
8981 [(set (match_operand 0 "" "")
8982 (call (match_operand 1 "" "")
8983 (match_operand 2 "" "")))
8984 (use (match_operand 3 "" ""))]
8987 s390_emit_call (XEXP (operands[1], 0), NULL_RTX, operands[0],
8988 gen_rtx_REG (Pmode, RETURN_REGNUM));
8992 (define_insn "*bras_r"
8993 [(set (match_operand 0 "" "")
8994 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
8995 (match_operand:SI 2 "const_int_operand" "n")))
8996 (clobber (match_operand 3 "register_operand" "=r"))]
8997 "!SIBLING_CALL_P (insn)
8998 && TARGET_SMALL_EXEC
8999 && GET_MODE (operands[3]) == Pmode"
9001 [(set_attr "op_type" "RI")
9002 (set_attr "type" "jsr")
9003 (set_attr "z196prop" "z196_cracked")])
9005 (define_insn "*brasl_r"
9006 [(set (match_operand 0 "" "")
9007 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
9008 (match_operand 2 "const_int_operand" "n")))
9009 (clobber (match_operand 3 "register_operand" "=r"))]
9010 "!SIBLING_CALL_P (insn)
9012 && GET_MODE (operands[3]) == Pmode"
9014 [(set_attr "op_type" "RIL")
9015 (set_attr "type" "jsr")
9016 (set_attr "z196prop" "z196_cracked")])
9018 (define_insn "*basr_r"
9019 [(set (match_operand 0 "" "")
9020 (call (mem:QI (match_operand 1 "address_operand" "ZQZR"))
9021 (match_operand 2 "const_int_operand" "n")))
9022 (clobber (match_operand 3 "register_operand" "=r"))]
9023 "!SIBLING_CALL_P (insn) && GET_MODE (operands[3]) == Pmode"
9025 if (get_attr_op_type (insn) == OP_TYPE_RR)
9026 return "basr\t%3,%1";
9028 return "bas\t%3,%a1";
9030 [(set (attr "op_type")
9031 (if_then_else (match_operand 1 "register_operand" "")
9032 (const_string "RR") (const_string "RX")))
9033 (set_attr "type" "jsr")
9034 (set_attr "atype" "agen")
9035 (set_attr "z196prop" "z196_cracked")])
9038 ;;- Thread-local storage support.
9041 (define_expand "get_thread_pointer<mode>"
9042 [(set (match_operand:P 0 "nonimmediate_operand" "") (reg:P TP_REGNUM))]
9046 (define_expand "set_thread_pointer<mode>"
9047 [(set (reg:P TP_REGNUM) (match_operand:P 0 "nonimmediate_operand" ""))
9048 (set (reg:P TP_REGNUM) (unspec_volatile:P [(reg:P TP_REGNUM)] UNSPECV_SET_TP))]
9052 (define_insn "*set_tp"
9053 [(set (reg TP_REGNUM) (unspec_volatile [(reg TP_REGNUM)] UNSPECV_SET_TP))]
9056 [(set_attr "type" "none")
9057 (set_attr "length" "0")])
9059 (define_insn "*tls_load_64"
9060 [(set (match_operand:DI 0 "register_operand" "=d")
9061 (unspec:DI [(match_operand:DI 1 "memory_operand" "RT")
9062 (match_operand:DI 2 "" "")]
9066 [(set_attr "op_type" "RXE")
9067 (set_attr "z10prop" "z10_fwd_A3")])
9069 (define_insn "*tls_load_31"
9070 [(set (match_operand:SI 0 "register_operand" "=d,d")
9071 (unspec:SI [(match_operand:SI 1 "memory_operand" "R,T")
9072 (match_operand:SI 2 "" "")]
9078 [(set_attr "op_type" "RX,RXY")
9079 (set_attr "type" "load")
9080 (set_attr "z10prop" "z10_fwd_A3,z10_fwd_A3")])
9082 (define_insn "*bras_tls"
9083 [(set (match_operand 0 "" "")
9084 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
9085 (match_operand 2 "const_int_operand" "n")))
9086 (clobber (match_operand 3 "register_operand" "=r"))
9087 (use (match_operand 4 "" ""))]
9088 "!SIBLING_CALL_P (insn)
9089 && TARGET_SMALL_EXEC
9090 && GET_MODE (operands[3]) == Pmode"
9092 [(set_attr "op_type" "RI")
9093 (set_attr "type" "jsr")
9094 (set_attr "z196prop" "z196_cracked")])
9096 (define_insn "*brasl_tls"
9097 [(set (match_operand 0 "" "")
9098 (call (mem:QI (match_operand 1 "bras_sym_operand" "X"))
9099 (match_operand 2 "const_int_operand" "n")))
9100 (clobber (match_operand 3 "register_operand" "=r"))
9101 (use (match_operand 4 "" ""))]
9102 "!SIBLING_CALL_P (insn)
9104 && GET_MODE (operands[3]) == Pmode"
9106 [(set_attr "op_type" "RIL")
9107 (set_attr "type" "jsr")
9108 (set_attr "z196prop" "z196_cracked")])
9110 (define_insn "*basr_tls"
9111 [(set (match_operand 0 "" "")
9112 (call (mem:QI (match_operand 1 "address_operand" "ZQZR"))
9113 (match_operand 2 "const_int_operand" "n")))
9114 (clobber (match_operand 3 "register_operand" "=r"))
9115 (use (match_operand 4 "" ""))]
9116 "!SIBLING_CALL_P (insn) && GET_MODE (operands[3]) == Pmode"
9118 if (get_attr_op_type (insn) == OP_TYPE_RR)
9119 return "basr\t%3,%1%J4";
9121 return "bas\t%3,%a1%J4";
9123 [(set (attr "op_type")
9124 (if_then_else (match_operand 1 "register_operand" "")
9125 (const_string "RR") (const_string "RX")))
9126 (set_attr "type" "jsr")
9127 (set_attr "atype" "agen")
9128 (set_attr "z196prop" "z196_cracked")])
9131 ;;- Atomic operations
9135 ; memory barrier patterns.
9138 (define_expand "mem_signal_fence"
9139 [(match_operand:SI 0 "const_int_operand")] ;; model
9142 /* The s390 memory model is strong enough not to require any
9143 barrier in order to synchronize a thread with itself. */
9147 (define_expand "mem_thread_fence"
9148 [(match_operand:SI 0 "const_int_operand")] ;; model
9151 /* Unless this is a SEQ_CST fence, the s390 memory model is strong
9152 enough not to require barriers of any kind. */
9153 if (INTVAL (operands[0]) == MEMMODEL_SEQ_CST)
9155 rtx mem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
9156 MEM_VOLATILE_P (mem) = 1;
9157 emit_insn (gen_mem_thread_fence_1 (mem));
9162 ; Although bcr is superscalar on Z10, this variant will never
9163 ; become part of an execution group.
9164 ; With z196 we can make use of the fast-BCR-serialization facility.
9165 ; This allows for a slightly faster sync which is sufficient for our
9167 (define_insn "mem_thread_fence_1"
9168 [(set (match_operand:BLK 0 "" "")
9169 (unspec:BLK [(match_dup 0)] UNSPEC_MB))]
9177 [(set_attr "op_type" "RR")
9178 (set_attr "mnemonic" "bcr_flush")
9179 (set_attr "z196prop" "z196_alone")])
9182 ; atomic load/store operations
9185 ; Atomic loads need not examine the memory model at all.
9186 (define_expand "atomic_load<mode>"
9187 [(match_operand:DINT 0 "register_operand") ;; output
9188 (match_operand:DINT 1 "memory_operand") ;; memory
9189 (match_operand:SI 2 "const_int_operand")] ;; model
9192 if (MEM_ALIGN (operands[1]) < GET_MODE_BITSIZE (GET_MODE (operands[1])))
9195 if (<MODE>mode == TImode)
9196 emit_insn (gen_atomic_loadti_1 (operands[0], operands[1]));
9197 else if (<MODE>mode == DImode && !TARGET_ZARCH)
9198 emit_insn (gen_atomic_loaddi_1 (operands[0], operands[1]));
9200 emit_move_insn (operands[0], operands[1]);
9204 ; Different from movdi_31 in that we want no splitters.
9205 (define_insn "atomic_loaddi_1"
9206 [(set (match_operand:DI 0 "register_operand" "=d,d,!*f,!*f")
9207 (unspec:DI [(match_operand:DI 1 "memory_operand" "Q,S,R,T")]
9215 [(set_attr "op_type" "RS,RSY,RS,RSY")
9216 (set_attr "type" "lm,lm,floaddf,floaddf")])
9218 (define_insn "atomic_loadti_1"
9219 [(set (match_operand:TI 0 "register_operand" "=r")
9220 (unspec:TI [(match_operand:TI 1 "memory_operand" "RT")]
9224 [(set_attr "op_type" "RXY")
9225 (set_attr "type" "other")])
9227 ; Atomic stores must(?) enforce sequential consistency.
9228 (define_expand "atomic_store<mode>"
9229 [(match_operand:DINT 0 "memory_operand") ;; memory
9230 (match_operand:DINT 1 "register_operand") ;; input
9231 (match_operand:SI 2 "const_int_operand")] ;; model
9234 enum memmodel model = (enum memmodel) INTVAL (operands[2]);
9236 if (MEM_ALIGN (operands[0]) < GET_MODE_BITSIZE (GET_MODE (operands[0])))
9239 if (<MODE>mode == TImode)
9240 emit_insn (gen_atomic_storeti_1 (operands[0], operands[1]));
9241 else if (<MODE>mode == DImode && !TARGET_ZARCH)
9242 emit_insn (gen_atomic_storedi_1 (operands[0], operands[1]));
9244 emit_move_insn (operands[0], operands[1]);
9245 if (model == MEMMODEL_SEQ_CST)
9246 emit_insn (gen_mem_thread_fence (operands[2]));
9250 ; Different from movdi_31 in that we want no splitters.
9251 (define_insn "atomic_storedi_1"
9252 [(set (match_operand:DI 0 "memory_operand" "=Q,S,R,T")
9253 (unspec:DI [(match_operand:DI 1 "register_operand" "d,d,!*f,!*f")]
9261 [(set_attr "op_type" "RS,RSY,RS,RSY")
9262 (set_attr "type" "stm,stm,fstoredf,fstoredf")])
9264 (define_insn "atomic_storeti_1"
9265 [(set (match_operand:TI 0 "memory_operand" "=RT")
9266 (unspec:TI [(match_operand:TI 1 "register_operand" "r")]
9270 [(set_attr "op_type" "RXY")
9271 (set_attr "type" "other")])
9274 ; compare and swap patterns.
9277 (define_expand "atomic_compare_and_swap<mode>"
9278 [(match_operand:SI 0 "register_operand") ;; bool success output
9279 (match_operand:DGPR 1 "nonimmediate_operand");; oldval output
9280 (match_operand:DGPR 2 "memory_operand") ;; memory
9281 (match_operand:DGPR 3 "register_operand") ;; expected intput
9282 (match_operand:DGPR 4 "register_operand") ;; newval intput
9283 (match_operand:SI 5 "const_int_operand") ;; is_weak
9284 (match_operand:SI 6 "const_int_operand") ;; success model
9285 (match_operand:SI 7 "const_int_operand")] ;; failure model
9288 rtx cc, cmp, output = operands[1];
9290 if (!register_operand (output, <MODE>mode))
9291 output = gen_reg_rtx (<MODE>mode);
9293 if (MEM_ALIGN (operands[2]) < GET_MODE_BITSIZE (GET_MODE (operands[2])))
9296 emit_insn (gen_atomic_compare_and_swap<mode>_internal
9297 (output, operands[2], operands[3], operands[4]));
9299 /* We deliberately accept non-register operands in the predicate
9300 to ensure the write back to the output operand happens *before*
9301 the store-flags code below. This makes it easier for combine
9302 to merge the store-flags code with a potential test-and-branch
9303 pattern following (immediately!) afterwards. */
9304 if (output != operands[1])
9305 emit_move_insn (operands[1], output);
9307 cc = gen_rtx_REG (CCZ1mode, CC_REGNUM);
9308 cmp = gen_rtx_EQ (SImode, cc, const0_rtx);
9309 emit_insn (gen_cstorecc4 (operands[0], cmp, cc, const0_rtx));
9313 (define_expand "atomic_compare_and_swap<mode>"
9314 [(match_operand:SI 0 "register_operand") ;; bool success output
9315 (match_operand:HQI 1 "nonimmediate_operand") ;; oldval output
9316 (match_operand:HQI 2 "memory_operand") ;; memory
9317 (match_operand:HQI 3 "general_operand") ;; expected intput
9318 (match_operand:HQI 4 "general_operand") ;; newval intput
9319 (match_operand:SI 5 "const_int_operand") ;; is_weak
9320 (match_operand:SI 6 "const_int_operand") ;; success model
9321 (match_operand:SI 7 "const_int_operand")] ;; failure model
9324 s390_expand_cs_hqi (<MODE>mode, operands[0], operands[1], operands[2],
9325 operands[3], operands[4], INTVAL (operands[5]));
9329 (define_expand "atomic_compare_and_swap<mode>_internal"
9331 [(set (match_operand:DGPR 0 "register_operand")
9332 (match_operand:DGPR 1 "memory_operand"))
9334 (unspec_volatile:DGPR
9336 (match_operand:DGPR 2 "register_operand")
9337 (match_operand:DGPR 3 "register_operand")]
9339 (set (reg:CCZ1 CC_REGNUM)
9340 (compare:CCZ1 (match_dup 1) (match_dup 2)))])]
9344 (define_insn "*atomic_compare_and_swap<mode>_1"
9345 [(set (match_operand:TDI 0 "register_operand" "=r")
9346 (match_operand:TDI 1 "memory_operand" "+QS"))
9348 (unspec_volatile:TDI
9350 (match_operand:TDI 2 "register_operand" "0")
9351 (match_operand:TDI 3 "register_operand" "r")]
9353 (set (reg:CCZ1 CC_REGNUM)
9354 (compare:CCZ1 (match_dup 1) (match_dup 2)))]
9356 "c<td>sg\t%0,%3,%S1"
9357 [(set_attr "op_type" "RSY")
9358 (set_attr "type" "sem")])
9361 (define_insn "*atomic_compare_and_swapdi_2"
9362 [(set (match_operand:DI 0 "register_operand" "=r,r")
9363 (match_operand:DI 1 "memory_operand" "+Q,S"))
9367 (match_operand:DI 2 "register_operand" "0,0")
9368 (match_operand:DI 3 "register_operand" "r,r")]
9370 (set (reg:CCZ1 CC_REGNUM)
9371 (compare:CCZ1 (match_dup 1) (match_dup 2)))]
9376 [(set_attr "op_type" "RS,RSY")
9377 (set_attr "type" "sem")])
9380 (define_insn "*atomic_compare_and_swapsi_3"
9381 [(set (match_operand:SI 0 "register_operand" "=r,r")
9382 (match_operand:SI 1 "memory_operand" "+Q,S"))
9386 (match_operand:SI 2 "register_operand" "0,0")
9387 (match_operand:SI 3 "register_operand" "r,r")]
9389 (set (reg:CCZ1 CC_REGNUM)
9390 (compare:CCZ1 (match_dup 1) (match_dup 2)))]
9395 [(set_attr "op_type" "RS,RSY")
9396 (set_attr "type" "sem")])
9399 ; Other atomic instruction patterns.
9402 ; z196 load and add, xor, or and and instructions
9404 (define_expand "atomic_fetch_<atomic><mode>"
9405 [(match_operand:GPR 0 "register_operand") ;; val out
9407 (match_operand:GPR 1 "memory_operand") ;; memory
9408 (match_operand:GPR 2 "register_operand")) ;; val in
9409 (match_operand:SI 3 "const_int_operand")] ;; model
9412 if (MEM_ALIGN (operands[1]) < GET_MODE_BITSIZE (GET_MODE (operands[1])))
9415 emit_insn (gen_atomic_fetch_<atomic><mode>_iaf
9416 (operands[0], operands[1], operands[2]));
9420 ; lan, lang, lao, laog, lax, laxg, laa, laag
9421 (define_insn "atomic_fetch_<atomic><mode>_iaf"
9422 [(set (match_operand:GPR 0 "register_operand" "=d")
9423 (match_operand:GPR 1 "memory_operand" "+QS"))
9425 (unspec_volatile:GPR
9426 [(ATOMIC_Z196:GPR (match_dup 1)
9427 (match_operand:GPR 2 "general_operand" "d"))]
9429 (clobber (reg:CC CC_REGNUM))]
9431 "la<noxa><g>\t%0,%2,%1"
9432 [(set_attr "op_type" "RSY")
9433 (set_attr "type" "sem")])
9435 ;; For SImode and larger, the optabs.c code will do just fine in
9436 ;; expanding a compare-and-swap loop. For QI/HImode, we can do
9437 ;; better by expanding our own loop.
9439 (define_expand "atomic_<atomic><mode>"
9441 (match_operand:HQI 0 "memory_operand") ;; memory
9442 (match_operand:HQI 1 "general_operand")) ;; val in
9443 (match_operand:SI 2 "const_int_operand")] ;; model
9446 s390_expand_atomic (<MODE>mode, <CODE>, NULL_RTX, operands[0],
9447 operands[1], false);
9451 (define_expand "atomic_fetch_<atomic><mode>"
9452 [(match_operand:HQI 0 "register_operand") ;; val out
9454 (match_operand:HQI 1 "memory_operand") ;; memory
9455 (match_operand:HQI 2 "general_operand")) ;; val in
9456 (match_operand:SI 3 "const_int_operand")] ;; model
9459 s390_expand_atomic (<MODE>mode, <CODE>, operands[0], operands[1],
9460 operands[2], false);
9464 (define_expand "atomic_<atomic>_fetch<mode>"
9465 [(match_operand:HQI 0 "register_operand") ;; val out
9467 (match_operand:HQI 1 "memory_operand") ;; memory
9468 (match_operand:HQI 2 "general_operand")) ;; val in
9469 (match_operand:SI 3 "const_int_operand")] ;; model
9472 s390_expand_atomic (<MODE>mode, <CODE>, operands[0], operands[1],
9477 (define_expand "atomic_exchange<mode>"
9478 [(match_operand:HQI 0 "register_operand") ;; val out
9479 (match_operand:HQI 1 "memory_operand") ;; memory
9480 (match_operand:HQI 2 "general_operand") ;; val in
9481 (match_operand:SI 3 "const_int_operand")] ;; model
9484 s390_expand_atomic (<MODE>mode, SET, operands[0], operands[1],
9485 operands[2], false);
9490 ;;- Miscellaneous instructions.
9494 ; allocate stack instruction pattern(s).
9497 (define_expand "allocate_stack"
9498 [(match_operand 0 "general_operand" "")
9499 (match_operand 1 "general_operand" "")]
9502 rtx temp = gen_reg_rtx (Pmode);
9504 emit_move_insn (temp, s390_back_chain_rtx ());
9505 anti_adjust_stack (operands[1]);
9506 emit_move_insn (s390_back_chain_rtx (), temp);
9508 emit_move_insn (operands[0], virtual_stack_dynamic_rtx);
9514 ; setjmp instruction pattern.
9517 (define_expand "builtin_setjmp_receiver"
9518 [(match_operand 0 "" "")]
9521 emit_insn (s390_load_got ());
9522 emit_use (pic_offset_table_rtx);
9526 ;; These patterns say how to save and restore the stack pointer. We need not
9527 ;; save the stack pointer at function level since we are careful to
9528 ;; preserve the backchain. At block level, we have to restore the backchain
9529 ;; when we restore the stack pointer.
9531 ;; For nonlocal gotos, we must save both the stack pointer and its
9532 ;; backchain and restore both. Note that in the nonlocal case, the
9533 ;; save area is a memory location.
9535 (define_expand "save_stack_function"
9536 [(match_operand 0 "general_operand" "")
9537 (match_operand 1 "general_operand" "")]
9541 (define_expand "restore_stack_function"
9542 [(match_operand 0 "general_operand" "")
9543 (match_operand 1 "general_operand" "")]
9547 (define_expand "restore_stack_block"
9548 [(match_operand 0 "register_operand" "")
9549 (match_operand 1 "register_operand" "")]
9552 rtx temp = gen_reg_rtx (Pmode);
9554 emit_move_insn (temp, s390_back_chain_rtx ());
9555 emit_move_insn (operands[0], operands[1]);
9556 emit_move_insn (s390_back_chain_rtx (), temp);
9561 (define_expand "save_stack_nonlocal"
9562 [(match_operand 0 "memory_operand" "")
9563 (match_operand 1 "register_operand" "")]
9566 rtx base = gen_rtx_REG (Pmode, BASE_REGNUM);
9568 /* Copy the backchain to the first word, sp to the second and the
9569 literal pool base to the third. */
9571 rtx save_bc = adjust_address (operands[0], Pmode, 0);
9572 rtx save_sp = adjust_address (operands[0], Pmode, GET_MODE_SIZE (Pmode));
9573 rtx save_bp = adjust_address (operands[0], Pmode, 2 * GET_MODE_SIZE (Pmode));
9575 if (TARGET_BACKCHAIN)
9576 emit_move_insn (save_bc, force_reg (Pmode, s390_back_chain_rtx ()));
9578 emit_move_insn (save_sp, operands[1]);
9579 emit_move_insn (save_bp, base);
9584 (define_expand "restore_stack_nonlocal"
9585 [(match_operand 0 "register_operand" "")
9586 (match_operand 1 "memory_operand" "")]
9589 rtx base = gen_rtx_REG (Pmode, BASE_REGNUM);
9590 rtx temp = NULL_RTX;
9592 /* Restore the backchain from the first word, sp from the second and the
9593 literal pool base from the third. */
9595 rtx save_bc = adjust_address (operands[1], Pmode, 0);
9596 rtx save_sp = adjust_address (operands[1], Pmode, GET_MODE_SIZE (Pmode));
9597 rtx save_bp = adjust_address (operands[1], Pmode, 2 * GET_MODE_SIZE (Pmode));
9599 if (TARGET_BACKCHAIN)
9600 temp = force_reg (Pmode, save_bc);
9602 emit_move_insn (base, save_bp);
9603 emit_move_insn (operands[0], save_sp);
9606 emit_move_insn (s390_back_chain_rtx (), temp);
9612 (define_expand "exception_receiver"
9616 s390_set_has_landing_pad_p (true);
9621 ; nop instruction pattern(s).
9628 [(set_attr "op_type" "RR")
9629 (set_attr "z10prop" "z10_fr_E1")])
9635 [(set_attr "op_type" "RR")])
9639 ; Special literal pool access instruction pattern(s).
9642 (define_insn "*pool_entry"
9643 [(unspec_volatile [(match_operand 0 "consttable_operand" "X")]
9644 UNSPECV_POOL_ENTRY)]
9647 enum machine_mode mode = GET_MODE (PATTERN (insn));
9648 unsigned int align = GET_MODE_BITSIZE (mode);
9649 s390_output_pool_entry (operands[0], mode, align);
9652 [(set (attr "length")
9653 (symbol_ref "GET_MODE_SIZE (GET_MODE (PATTERN (insn)))"))])
9655 (define_insn "pool_align"
9656 [(unspec_volatile [(match_operand 0 "const_int_operand" "n")]
9657 UNSPECV_POOL_ALIGN)]
9660 [(set (attr "length") (symbol_ref "INTVAL (operands[0])"))])
9662 (define_insn "pool_section_start"
9663 [(unspec_volatile [(const_int 1)] UNSPECV_POOL_SECTION)]
9666 [(set_attr "length" "0")])
9668 (define_insn "pool_section_end"
9669 [(unspec_volatile [(const_int 0)] UNSPECV_POOL_SECTION)]
9672 [(set_attr "length" "0")])
9674 (define_insn "main_base_31_small"
9675 [(set (match_operand 0 "register_operand" "=a")
9676 (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))]
9677 "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
9679 [(set_attr "op_type" "RR")
9680 (set_attr "type" "la")
9681 (set_attr "z196prop" "z196_cracked")])
9683 (define_insn "main_base_31_large"
9684 [(set (match_operand 0 "register_operand" "=a")
9685 (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))
9686 (set (pc) (label_ref (match_operand 2 "" "")))]
9687 "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
9689 [(set_attr "op_type" "RI")
9690 (set_attr "z196prop" "z196_cracked")])
9692 (define_insn "main_base_64"
9693 [(set (match_operand 0 "register_operand" "=a")
9694 (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_MAIN_BASE))]
9695 "TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
9697 [(set_attr "op_type" "RIL")
9698 (set_attr "type" "larl")
9699 (set_attr "z10prop" "z10_fwd_A1")])
9701 (define_insn "main_pool"
9702 [(set (match_operand 0 "register_operand" "=a")
9703 (unspec_volatile [(const_int 0)] UNSPECV_MAIN_POOL))]
9704 "GET_MODE (operands[0]) == Pmode"
9709 (if_then_else (match_test "TARGET_CPU_ZARCH")
9710 (const_string "larl") (const_string "la")))])
9712 (define_insn "reload_base_31"
9713 [(set (match_operand 0 "register_operand" "=a")
9714 (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_RELOAD_BASE))]
9715 "!TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
9716 "basr\t%0,0\;la\t%0,%1-.(%0)"
9717 [(set_attr "length" "6")
9718 (set_attr "type" "la")
9719 (set_attr "z196prop" "z196_cracked")])
9721 (define_insn "reload_base_64"
9722 [(set (match_operand 0 "register_operand" "=a")
9723 (unspec [(label_ref (match_operand 1 "" ""))] UNSPEC_RELOAD_BASE))]
9724 "TARGET_CPU_ZARCH && GET_MODE (operands[0]) == Pmode"
9726 [(set_attr "op_type" "RIL")
9727 (set_attr "type" "larl")
9728 (set_attr "z10prop" "z10_fwd_A1")])
9731 [(unspec_volatile [(match_operand 0 "const_int_operand" "n")] UNSPECV_POOL)]
9736 [(set (attr "length") (symbol_ref "INTVAL (operands[0])"))])
9739 ;; Insns related to generating the function prologue and epilogue.
9743 (define_expand "prologue"
9744 [(use (const_int 0))]
9746 "s390_emit_prologue (); DONE;")
9748 (define_expand "epilogue"
9749 [(use (const_int 1))]
9751 "s390_emit_epilogue (false); DONE;")
9753 (define_expand "sibcall_epilogue"
9754 [(use (const_int 0))]
9756 "s390_emit_epilogue (true); DONE;")
9758 ;; A direct return instruction, without using an epilogue.
9759 (define_insn "<code>"
9761 "s390_can_use_<code>_insn ()"
9763 [(set_attr "op_type" "RR")
9764 (set_attr "type" "jsr")
9765 (set_attr "atype" "agen")])
9767 (define_insn "*return"
9769 (use (match_operand 0 "register_operand" "a"))]
9770 "GET_MODE (operands[0]) == Pmode"
9772 [(set_attr "op_type" "RR")
9773 (set_attr "type" "jsr")
9774 (set_attr "atype" "agen")])
9777 ;; Instruction definition to extend a 31-bit pointer into a 64-bit
9778 ;; pointer. This is used for compatibility.
9780 (define_expand "ptr_extend"
9781 [(set (match_operand:DI 0 "register_operand" "=r")
9782 (match_operand:SI 1 "register_operand" "r"))]
9785 emit_insn (gen_anddi3 (operands[0],
9786 gen_lowpart (DImode, operands[1]),
9787 GEN_INT (0x7fffffff)));
9791 ;; Instruction definition to expand eh_return macro to support
9792 ;; swapping in special linkage return addresses.
9794 (define_expand "eh_return"
9795 [(use (match_operand 0 "register_operand" ""))]
9798 s390_emit_tpf_eh_return (operands[0]);
9803 ; Stack Protector Patterns
9806 (define_expand "stack_protect_set"
9807 [(set (match_operand 0 "memory_operand" "")
9808 (match_operand 1 "memory_operand" ""))]
9811 #ifdef TARGET_THREAD_SSP_OFFSET
9813 = gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, s390_get_thread_pointer (),
9814 GEN_INT (TARGET_THREAD_SSP_OFFSET)));
9817 emit_insn (gen_stack_protect_setdi (operands[0], operands[1]));
9819 emit_insn (gen_stack_protect_setsi (operands[0], operands[1]));
9824 (define_insn "stack_protect_set<mode>"
9825 [(set (match_operand:DSI 0 "memory_operand" "=Q")
9826 (unspec:DSI [(match_operand:DSI 1 "memory_operand" "Q")] UNSPEC_SP_SET))]
9828 "mvc\t%O0(%G0,%R0),%S1"
9829 [(set_attr "op_type" "SS")])
9831 (define_expand "stack_protect_test"
9832 [(set (reg:CC CC_REGNUM)
9833 (compare (match_operand 0 "memory_operand" "")
9834 (match_operand 1 "memory_operand" "")))
9835 (match_operand 2 "" "")]
9839 #ifdef TARGET_THREAD_SSP_OFFSET
9841 = gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, s390_get_thread_pointer (),
9842 GEN_INT (TARGET_THREAD_SSP_OFFSET)));
9845 emit_insn (gen_stack_protect_testdi (operands[0], operands[1]));
9847 emit_insn (gen_stack_protect_testsi (operands[0], operands[1]));
9849 cc_reg = gen_rtx_REG (CCZmode, CC_REGNUM);
9850 test = gen_rtx_EQ (VOIDmode, cc_reg, const0_rtx);
9851 emit_jump_insn (gen_cbranchcc4 (test, cc_reg, const0_rtx, operands[2]));
9855 (define_insn "stack_protect_test<mode>"
9856 [(set (reg:CCZ CC_REGNUM)
9857 (unspec:CCZ [(match_operand:DSI 0 "memory_operand" "Q")
9858 (match_operand:DSI 1 "memory_operand" "Q")] UNSPEC_SP_TEST))]
9860 "clc\t%O0(%G0,%R0),%S1"
9861 [(set_attr "op_type" "SS")])
9863 ; This is used in s390_emit_prologue in order to prevent insns
9864 ; adjusting the stack pointer to be moved over insns writing stack
9865 ; slots using a copy of the stack pointer in a different register.
9866 (define_insn "stack_tie"
9867 [(set (match_operand:BLK 0 "memory_operand" "+m")
9868 (unspec:BLK [(match_dup 0)] UNSPEC_TIE))]
9871 [(set_attr "length" "0")])
9875 ; Data prefetch patterns
9878 (define_insn "prefetch"
9879 [(prefetch (match_operand 0 "address_operand" "ZQZRZSZT,X")
9880 (match_operand:SI 1 "const_int_operand" " n,n")
9881 (match_operand:SI 2 "const_int_operand" " n,n"))]
9884 switch (which_alternative)
9887 return INTVAL (operands[1]) == 1 ? "pfd\t2,%a0" : "pfd\t1,%a0";
9889 if (larl_operand (operands[0], Pmode))
9890 return INTVAL (operands[1]) == 1 ? "pfdrl\t2,%a0" : "pfdrl\t1,%a0";
9893 /* This might be reached for symbolic operands with an odd
9894 addend. We simply omit the prefetch for such rare cases. */
9899 [(set_attr "type" "load,larl")
9900 (set_attr "op_type" "RXY,RIL")
9901 (set_attr "z10prop" "z10_super")
9902 (set_attr "z196prop" "z196_alone")])
9906 ; Byte swap instructions
9909 (define_insn "bswap<mode>2"
9910 [(set (match_operand:GPR 0 "register_operand" "=d, d")
9911 (bswap:GPR (match_operand:GPR 1 "nonimmediate_operand" " d,RT")))]
9916 [(set_attr "type" "*,load")
9917 (set_attr "op_type" "RRE,RXY")
9918 (set_attr "z10prop" "z10_super")])
9922 ; Population count instruction
9925 ; The S/390 popcount instruction counts the bits of op1 in 8 byte
9926 ; portions and stores the result in the corresponding bytes in op0.
9927 (define_insn "*popcount<mode>"
9928 [(set (match_operand:INT 0 "register_operand" "=d")
9929 (unspec:INT [(match_operand:INT 1 "register_operand" "d")] UNSPEC_POPCNT))
9930 (clobber (reg:CC CC_REGNUM))]
9933 [(set_attr "op_type" "RRE")])
9935 (define_expand "popcountdi2"
9937 (parallel [(set (match_operand:DI 0 "register_operand" "")
9938 (unspec:DI [(match_operand:DI 1 "register_operand")]
9940 (clobber (reg:CC CC_REGNUM))])
9942 (set (match_dup 2) (ashift:DI (match_dup 0) (const_int 32)))
9944 (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))
9945 (clobber (reg:CC CC_REGNUM))])
9948 (ashift:DI (match_dup 0) (const_int 16)))
9950 (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))
9951 (clobber (reg:CC CC_REGNUM))])
9953 (set (match_dup 2) (ashift:DI (match_dup 0) (const_int 8)))
9955 (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))
9956 (clobber (reg:CC CC_REGNUM))])
9958 (set (match_dup 0) (lshiftrt:DI (match_dup 0) (const_int 56)))]
9959 "TARGET_Z196 && TARGET_64BIT"
9960 "operands[2] = gen_reg_rtx (DImode);")
9962 (define_expand "popcountsi2"
9964 (parallel [(set (match_operand:SI 0 "register_operand" "")
9965 (unspec:SI [(match_operand:SI 1 "register_operand")]
9967 (clobber (reg:CC CC_REGNUM))])
9970 (ashift:SI (match_dup 0) (const_int 16)))
9972 (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))
9973 (clobber (reg:CC CC_REGNUM))])
9975 (set (match_dup 2) (ashift:SI (match_dup 0) (const_int 8)))
9977 (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))
9978 (clobber (reg:CC CC_REGNUM))])
9980 (set (match_dup 0) (lshiftrt:SI (match_dup 0) (const_int 24)))]
9982 "operands[2] = gen_reg_rtx (SImode);")
9984 (define_expand "popcounthi2"
9986 (parallel [(set (match_operand:HI 0 "register_operand" "")
9987 (unspec:HI [(match_operand:HI 1 "register_operand")]
9989 (clobber (reg:CC CC_REGNUM))])
9992 (ashift:SI (match_dup 0) (const_int 8)))
9994 (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))
9995 (clobber (reg:CC CC_REGNUM))])
9997 (set (match_dup 0) (lshiftrt:HI (match_dup 0) (const_int 8)))]
9999 "operands[2] = gen_reg_rtx (SImode);")
10001 (define_expand "popcountqi2"
10003 (parallel [(set (match_operand:QI 0 "register_operand" "")
10004 (unspec:QI [(match_operand:QI 1 "register_operand")]
10006 (clobber (reg:CC CC_REGNUM))])]
10011 ;;- Copy sign instructions
10014 (define_insn "copysign<mode>3"
10015 [(set (match_operand:FP 0 "register_operand" "=f")
10016 (unspec:FP [(match_operand:FP 1 "register_operand" "<fT0>")
10017 (match_operand:FP 2 "register_operand" "f")]
10021 [(set_attr "op_type" "RRF")
10022 (set_attr "type" "fsimp<mode>")])
10026 ;;- Transactional execution instructions
10029 ; This splitter helps combine to make use of CC directly when
10030 ; comparing the integer result of a tbegin builtin with a constant.
10031 ; The unspec is already removed by canonicalize_comparison. So this
10032 ; splitters only job is to turn the PARALLEL into separate insns
10033 ; again. Unfortunately this only works with the very first cc/int
10034 ; compare since combine is not able to deal with data flow across
10035 ; basic block boundaries.
10037 ; It needs to be an insn pattern as well since combine does not apply
10038 ; the splitter directly. Combine would only use it if it actually
10039 ; would reduce the number of instructions.
10040 (define_insn_and_split "*ccraw_to_int"
10043 (match_operator 0 "s390_eqne_operator"
10044 [(reg:CCRAW CC_REGNUM)
10045 (match_operand 1 "const_int_operand" "")])
10046 (label_ref (match_operand 2 "" ""))
10048 (set (match_operand:SI 3 "register_operand" "=d")
10049 (unspec:SI [(reg:CCRAW CC_REGNUM)] UNSPEC_CC_TO_INT))]
10053 [(set (match_dup 3)
10054 (unspec:SI [(reg:CCRAW CC_REGNUM)] UNSPEC_CC_TO_INT))
10056 (if_then_else (match_op_dup 0 [(reg:CCRAW CC_REGNUM) (match_dup 1)])
10057 (label_ref (match_dup 2))
10061 ; Non-constrained transaction begin
10063 (define_expand "tbegin"
10064 [(match_operand:SI 0 "register_operand" "")
10065 (match_operand:BLK 1 "memory_operand" "")]
10068 s390_expand_tbegin (operands[0], operands[1], NULL_RTX, true);
10072 (define_expand "tbegin_nofloat"
10073 [(match_operand:SI 0 "register_operand" "")
10074 (match_operand:BLK 1 "memory_operand" "")]
10077 s390_expand_tbegin (operands[0], operands[1], NULL_RTX, false);
10081 (define_expand "tbegin_retry"
10082 [(match_operand:SI 0 "register_operand" "")
10083 (match_operand:BLK 1 "memory_operand" "")
10084 (match_operand:SI 2 "general_operand" "")]
10087 s390_expand_tbegin (operands[0], operands[1], operands[2], true);
10091 (define_expand "tbegin_retry_nofloat"
10092 [(match_operand:SI 0 "register_operand" "")
10093 (match_operand:BLK 1 "memory_operand" "")
10094 (match_operand:SI 2 "general_operand" "")]
10097 s390_expand_tbegin (operands[0], operands[1], operands[2], false);
10101 (define_insn "tbegin_1"
10102 [(set (reg:CCRAW CC_REGNUM)
10103 (unspec_volatile:CCRAW [(match_operand 0 "const_int_operand" "D")]
10105 (set (match_operand:BLK 1 "memory_operand" "=Q")
10106 (unspec_volatile:BLK [(match_dup 0)] UNSPECV_TBEGIN_TDB))
10107 (clobber (reg:DF 16))
10108 (clobber (reg:DF 17))
10109 (clobber (reg:DF 18))
10110 (clobber (reg:DF 19))
10111 (clobber (reg:DF 20))
10112 (clobber (reg:DF 21))
10113 (clobber (reg:DF 22))
10114 (clobber (reg:DF 23))
10115 (clobber (reg:DF 24))
10116 (clobber (reg:DF 25))
10117 (clobber (reg:DF 26))
10118 (clobber (reg:DF 27))
10119 (clobber (reg:DF 28))
10120 (clobber (reg:DF 29))
10121 (clobber (reg:DF 30))
10122 (clobber (reg:DF 31))]
10123 ; CONST_OK_FOR_CONSTRAINT_P does not work with D constraint since D is
10124 ; not supposed to be used for immediates (see genpreds.c).
10125 "TARGET_HTM && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 0xffff"
10127 [(set_attr "op_type" "SIL")])
10129 ; Same as above but without the FPR clobbers
10130 (define_insn "tbegin_nofloat_1"
10131 [(set (reg:CCRAW CC_REGNUM)
10132 (unspec_volatile:CCRAW [(match_operand 0 "const_int_operand" "D")]
10134 (set (match_operand:BLK 1 "memory_operand" "=Q")
10135 (unspec_volatile:BLK [(match_dup 0)] UNSPECV_TBEGIN_TDB))]
10136 "TARGET_HTM && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 0xffff"
10138 [(set_attr "op_type" "SIL")])
10141 ; Constrained transaction begin
10143 (define_expand "tbeginc"
10144 [(set (reg:CCRAW CC_REGNUM)
10145 (unspec_volatile:CCRAW [(const_int TBEGINC_MASK)]
10150 (define_insn "*tbeginc_1"
10151 [(set (reg:CCRAW CC_REGNUM)
10152 (unspec_volatile:CCRAW [(match_operand 0 "const_int_operand" " D")]
10154 "TARGET_HTM && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 0xffff"
10156 [(set_attr "op_type" "SIL")])
10160 (define_expand "tend"
10161 [(set (reg:CCRAW CC_REGNUM)
10162 (unspec_volatile:CCRAW [(const_int 0)] UNSPECV_TEND))
10163 (set (match_operand:SI 0 "register_operand" "")
10164 (unspec:SI [(reg:CCRAW CC_REGNUM)] UNSPEC_CC_TO_INT))]
10168 (define_insn "*tend_1"
10169 [(set (reg:CCRAW CC_REGNUM)
10170 (unspec_volatile:CCRAW [(const_int 0)] UNSPECV_TEND))]
10173 [(set_attr "op_type" "S")])
10175 ; Transaction abort
10177 (define_expand "tabort"
10178 [(unspec_volatile [(match_operand:SI 0 "shift_count_or_setmem_operand" "")]
10180 "TARGET_HTM && operands != NULL"
10182 if (CONST_INT_P (operands[0])
10183 && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 255)
10185 error ("Invalid transaction abort code: " HOST_WIDE_INT_PRINT_DEC
10186 ". Values in range 0 through 255 are reserved.",
10187 INTVAL (operands[0]));
10192 (define_insn "*tabort_1"
10193 [(unspec_volatile [(match_operand:SI 0 "shift_count_or_setmem_operand" "Y")]
10195 "TARGET_HTM && operands != NULL"
10197 [(set_attr "op_type" "S")])
10199 ; Transaction extract nesting depth
10201 (define_insn "etnd"
10202 [(set (match_operand:SI 0 "register_operand" "=d")
10203 (unspec_volatile:SI [(const_int 0)] UNSPECV_ETND))]
10206 [(set_attr "op_type" "RRE")])
10208 ; Non-transactional store
10210 (define_insn "ntstg"
10211 [(set (match_operand:DI 0 "memory_operand" "=RT")
10212 (unspec_volatile:DI [(match_operand:DI 1 "register_operand" "d")]
10216 [(set_attr "op_type" "RXY")])
10218 ; Transaction perform processor assist
10220 (define_expand "tx_assist"
10221 [(unspec_volatile [(match_operand:SI 0 "register_operand" "")
10222 (reg:SI GPR0_REGNUM)
10228 (define_insn "*ppa"
10229 [(unspec_volatile [(match_operand:SI 0 "register_operand" "d")
10230 (match_operand:SI 1 "register_operand" "d")
10231 (match_operand 2 "const_int_operand" "I")]
10233 "TARGET_HTM && INTVAL (operands[2]) < 16"
10235 [(set_attr "op_type" "RRF")])