gcc/config/i370/i370.md

   1 ;;- Machine description for GNU compiler -- System/370 version.
   2 ;;  Copyright (C) 1989, 1993, 1994, 1995 Free Software Foundation, Inc.
   3 ;;  Contributed by Jan Stein (jan@cd.chalmers.se).
   4 ;;  Modified for MVS C/370 by Dave Pitts (dpitts@nyx.cs.du.edu)
   5
   6 ;; This file is part of GNU CC.
   7
   8 ;; GNU CC is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation; either version 2, or (at your option)
  11 ;; any later version.
  12
  13 ;; GNU CC is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with GNU CC; see the file COPYING.  If not, write to
  20 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  21 ;; Boston, MA 02111-1307, USA.
  22
  23 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  24 ;;- updates for most instructions.
  25
  26 ;;
  27 ;; Special constraints for 370 machine description:
  28 ;;
  29 ;;    a -- Any address register from 1 to 15.
  30 ;;    d -- Any register from 0 to 15.
  31 ;;    I -- An 8-bit constant (0..255).
  32 ;;    J -- A 12-bit constant (0..4095).
  33 ;;    K -- A 16-bit constant (-32768..32767).
  34 ;;
  35 ;; Special formats used for outputting 370 instructions.
  36 ;;
  37 ;;   %B -- Print a constant byte integer.
  38 ;;   %H -- Print a signed 16-bit constant.
  39 ;;   %L -- Print least significant word of a CONST_DOUBLE.
  40 ;;   %M -- Print most significant word of a CONST_DOUBLE.
  41 ;;   %N -- Print next register (second word of a DImode reg).
  42 ;;   %O -- Print the offset of a memory reference (PLUS (REG) (CONST_INT)).
  43 ;;   %R -- Print the register of a memory reference (PLUS (REG) (CONST_INT)).
  44 ;;   %X -- Print a constant byte integer in hex.
  45 ;;
  46 ;; We have a special constraint for pattern matching.
  47 ;;
  48 ;;   s_operand -- Matches a valid S operand in a RS, SI or SS type instruction.
  49 ;;
  50 ;;   r_or_s_operand -- Matches a register or a valid S operand in a RS, SI
  51 ;;                     or SS type instruction or a register
  52 ;;
  53 ;; For MVS C/370 we use the following stack locations for:
  54 ;;
  55 ;;   136 - internal function result buffer
  56 ;;   140 - numeric conversion buffer
  57 ;;   144 - pointer to internal function result buffer
  58 ;;   148 - start of automatic variables and function arguments
  59 ;;
  60 ;; To support programs larger than a page, 4096 bytes, PAGE_REGISTER points
  61 ;; to a page origin table, all internal labels are generated to reload the
  62 ;; BASE_REGISTER knowing what page it is on and all branch instructions go
  63 ;; directly to the target if it is known that the target is on the current
  64 ;; page (essentially backward references).  All forward references and off
  65 ;; page references are handled by loading the address of target into a
  66 ;; register and branching indirectly.
  67 ;;
  68 ;; Some *di patterns have been commented out per advice from RMS, as gcc
  69 ;; will generate the right things to do.
  70 ;;
  71
  72 ;;
  73 ;;- Test instructions.
  74 ;;
  75
  76 ;
  77 ; tstdi instruction pattern(s).
  78 ;
  79
  80 (define_insn "tstdi"
  81   [(set (cc0)
  82         (match_operand:DI 0 "register_operand" "d"))]
  83   ""
  84   "*
  85 {
  86   check_label_emit ();
  87   mvs_check_page (0, 4, 0);
  88   return \"SRDA %0,0\";
  89 }")
  90
  91 ;
  92 ; tstsi instruction pattern(s).
  93 ;
  94
  95 (define_insn "tstsi"
  96   [(set (cc0)
  97         (match_operand:SI 0 "register_operand" "d"))]
  98   ""
  99   "*
 100 {
 101   check_label_emit ();
 102   mvs_check_page (0, 2, 0);
 103   return \"LTR  %0,%0\";
 104 }")
 105
 106 ;
 107 ; tsthi instruction pattern(s).
 108 ;
 109
 110 (define_insn "tsthi"
 111   [(set (cc0)
 112         (match_operand:HI 0 "register_operand" "d"))]
 113   ""
 114   "*
 115 {
 116   check_label_emit ();
 117   mvs_check_page (0, 4, 2);
 118   return \"CH   %0,=H'0'\";
 119 }")
 120
 121 ;
 122 ; tstqi instruction pattern(s).
 123 ;
 124
 125 (define_insn ""
 126   [(set (cc0)
 127         (match_operand:QI 0 "r_or_s_operand" "dm"))]
 128   "unsigned_jump_follows_p (insn)"
 129   "*
 130 {
 131   check_label_emit ();
 132   if (REG_P (operands[0]))
 133     {
 134       mvs_check_page (0, 4, 4);
 135       return \"N        %0,=X'000000FF'\";
 136     }
 137   mvs_check_page (0, 4, 0);
 138   return \"CLI  %0,0\";
 139 }")
 140
 141 (define_insn "tstqi"
 142   [(set (cc0)
 143      (match_operand:QI 0 "register_operand" "d"))]
 144   ""
 145   "*
 146 {
 147   check_label_emit ();
 148   if (unsigned_jump_follows_p (insn))
 149     {
 150       mvs_check_page (0, 4, 4);
 151       return \"N        %0,=X'000000FF'\";
 152     }
 153   mvs_check_page (0, 8, 0);
 154   return \"SLL  %0,24\;SRA      %0,24\";
 155 }")
 156
 157 ;
 158 ; tstdf instruction pattern(s).
 159 ;
 160
 161 (define_insn "tstdf"
 162   [(set (cc0)
 163         (match_operand:DF 0 "general_operand" "f"))]
 164   ""
 165   "*
 166 {
 167   check_label_emit ();
 168   mvs_check_page (0, 2, 0);
 169   return \"LTDR %0,%0\";
 170 }")
 171
 172 ;
 173 ; tstsf instruction pattern(s).
 174 ;
 175
 176 (define_insn "tstsf"
 177   [(set (cc0)
 178         (match_operand:SF 0 "general_operand" "f"))]
 179   ""
 180   "*
 181 {
 182   check_label_emit ();
 183   mvs_check_page (0, 2, 0);
 184   return \"LTER %0,%0\";
 185 }")
 186
 187 ;;
 188 ;;- Compare instructions.
 189 ;;
 190
 191 ;
 192 ; cmpdi instruction pattern(s).
 193 ;
 194
 195 ;(define_insn "cmpdi"
 196 ;  [(set (cc0)
 197 ;       (compare (match_operand:DI 0 "register_operand" "d")
 198 ;                (match_operand:DI 1 "general_operand" "")))]
 199 ;  ""
 200 ;  "*
 201 ;{
 202 ;  check_label_emit ();
 203 ;  if (REG_P (operands[1]))
 204 ;    {
 205 ;      mvs_check_page (0, 8, 0);
 206 ;      if (unsigned_jump_follows_p (insn))
 207 ;        return \"CLR   %0,%1\;BNE      *+6\;CLR        %N0,%N1\";
 208 ;      return \"CR      %0,%1\;BNE      *+6\;CLR        %N0,%N1\";
 209 ;    }
 210 ;  mvs_check_page (0, 12, 0);
 211 ;  if (unsigned_jump_follows_p (insn))
 212 ;    return \"CL        %0,%M1\;BNE     *+8\;CL %N0,%L1\";
 213 ;  return \"C   %0,%M1\;BNE     *+8\;CL %N0,%L1\";
 214 ;}")
 215
 216 ;
 217 ; cmpsi instruction pattern(s).
 218 ;
 219
 220 (define_insn "cmpsi"
 221   [(set (cc0)
 222         (compare (match_operand:SI 0 "register_operand" "d")
 223                  (match_operand:SI 1 "general_operand" "md")))]
 224   ""
 225   "*
 226 {
 227   check_label_emit ();
 228   if (REG_P (operands[1]))
 229     {
 230       mvs_check_page (0, 2, 0);
 231       if (unsigned_jump_follows_p (insn))
 232         return \"CLR    %0,%1\";
 233       return \"CR       %0,%1\";
 234     }
 235   if (GET_CODE (operands[1]) == CONST_INT)
 236     {
 237       mvs_check_page (0, 4, 4);
 238       if (unsigned_jump_follows_p (insn))
 239          return \"CL    %0,=F'%c1'\";
 240       return \"C        %0,=F'%c1'\";
 241     }
 242   mvs_check_page (0, 4, 0);
 243   if (unsigned_jump_follows_p (insn))
 244     return \"CL %0,%1\";
 245   return \"C    %0,%1\";
 246 }")
 247
 248 ;
 249 ; cmphi instruction pattern(s).
 250 ;
 251
 252 (define_insn "cmphi"
 253   [(set (cc0)
 254         (compare (match_operand:HI 0 "register_operand" "d")
 255                  (match_operand:HI 1 "general_operand" "")))]
 256   ""
 257   "*
 258 {
 259   check_label_emit ();
 260   if (REG_P (operands[1]))
 261     {
 262       mvs_check_page (0, 8, 0);
 263       if (unsigned_jump_follows_p (insn))
 264         return \"STH    %1,140(,13)\;CLM        %0,3,140(13)\";
 265       return \"STH      %1,140(,13)\;CH %0,140(,13)\";
 266     }
 267   if (GET_CODE (operands[1]) == CONST_INT)
 268     {
 269       mvs_check_page (0, 4, 0);
 270       return \"CH       %0,%H1\";
 271     }
 272   mvs_check_page (0, 4, 0);
 273   return \"CH   %0,%1\";
 274 }")
 275
 276 ;
 277 ; cmpqi instruction pattern(s).
 278 ;
 279
 280 (define_insn ""
 281   [(set (cc0)
 282         (compare (match_operand:QI 0 "r_or_s_operand" "g")
 283                  (match_operand:QI 1 "r_or_s_operand" "g")))]
 284   "unsigned_jump_follows_p (insn)"
 285   "*
 286 {
 287   check_label_emit ();
 288   if (REG_P (operands[0]))
 289     {
 290       if (REG_P (operands[1]))
 291         {
 292           mvs_check_page (0, 8, 0);
 293           return \"STC  %1,140(,13)\;CLM        %0,1,140(13)\";
 294         }
 295       if (GET_CODE (operands[1]) == CONST_INT)
 296         {
 297           mvs_check_page (0, 4, 1);
 298           return \"CLM  %0,1,=FL1'%B1'\";
 299         }
 300       mvs_check_page (0, 4, 0);
 301       return \"CLM      %0,1,%1\";
 302     }
 303   else if (GET_CODE (operands[0]) == CONST_INT)
 304     {
 305       cc_status.flags |= CC_REVERSED;
 306       if (REG_P (operands[1]))
 307         {
 308           mvs_check_page (0, 4, 1);
 309           return \"CLM  %1,1,=FL1'%B0'\";
 310         }
 311       mvs_check_page (0, 4, 0);
 312       return \"CLI      %1,%B0\";
 313     }
 314   if (GET_CODE (operands[1]) == CONST_INT)
 315     {
 316       mvs_check_page (0, 4, 0);
 317       return \"CLI      %0,%B1\";
 318     }
 319   if (GET_CODE (operands[1]) == MEM)
 320     {
 321       mvs_check_page (0, 6, 0);
 322       return \"CLC      %O0(1,%R0),%1\";
 323     }
 324   cc_status.flags |= CC_REVERSED;
 325   mvs_check_page (0, 4, 0);
 326   return \"CLM  %1,1,%0\";
 327 }")
 328
 329 (define_insn "cmpqi"
 330   [(set (cc0)
 331         (compare (match_operand:QI 0 "register_operand" "d")
 332                  (match_operand:QI 1 "general_operand" "di")))]
 333   ""
 334   "*
 335 {
 336   check_label_emit ();
 337   if (unsigned_jump_follows_p (insn))
 338     {
 339       if (REG_P (operands[1]))
 340         {
 341           mvs_check_page (0, 4, 0);
 342           return \"CLM  %0,1,%1\";
 343         }
 344       if (GET_CODE (operands[1]) == CONST_INT)
 345         {
 346           mvs_check_page (0, 4, 1);
 347           return \"CLM  %0,1,=FL1'%B1'\";
 348         }
 349       mvs_check_page (0, 8, 0);
 350       return \"STC      %1,140(,13)\;CLM        %0,1,140(13)\";
 351     }
 352   if (REG_P (operands[1]))
 353     {
 354       mvs_check_page (0, 18, 0);
 355       return \"SLL      %0,24\;SRA      %0,24\;SLL      %1,24\;SRA      %1,24\;CR       %0,%1\";
 356     }
 357   mvs_check_page (0, 12, 0);
 358   return \"SLL  %0,24\;SRA      %0,24\;C        %0,%1\";
 359 }")
 360
 361 ;
 362 ; cmpdf instruction pattern(s).
 363 ;
 364
 365 (define_insn "cmpdf"
 366   [(set (cc0)
 367         (compare (match_operand:DF 0 "general_operand" "f,mF")
 368                  (match_operand:DF 1 "general_operand" "fmF,f")))]
 369   ""
 370   "*
 371 {
 372   check_label_emit ();
 373   if (FP_REG_P (operands[0]))
 374     {
 375       if (FP_REG_P (operands[1]))
 376         {
 377           mvs_check_page (0, 2, 0);
 378           return \"CDR  %0,%1\";
 379         }
 380       mvs_check_page (0, 4, 0);
 381       return \"CD       %0,%1\";
 382     }
 383   cc_status.flags |= CC_REVERSED;
 384   mvs_check_page (0, 4, 0);
 385   return \"CD   %1,%0\";
 386 }")
 387
 388 ;
 389 ; cmpsf instruction pattern(s).
 390 ;
 391
 392 (define_insn "cmpsf"
 393   [(set (cc0)
 394         (compare (match_operand:SF 0 "general_operand" "f,mF")
 395                  (match_operand:SF 1 "general_operand" "fmF,f")))]
 396   ""
 397   "*
 398 {
 399 check_label_emit ();
 400   if (FP_REG_P (operands[0]))
 401     {
 402       if (FP_REG_P (operands[1]))
 403         {
 404           mvs_check_page (0, 2, 0);
 405           return \"CER  %0,%1\";
 406         }
 407       mvs_check_page (0, 4, 0);
 408       return \"CE       %0,%1\";
 409     }
 410   cc_status.flags |= CC_REVERSED;
 411   mvs_check_page (0, 4, 0);
 412   return \"CE   %1,%0\";
 413 }")
 414
 415 ;
 416 ; cmpstrsi instruction pattern(s).
 417 ;
 418
 419 (define_expand "cmpstrsi"
 420   [(set (match_operand:SI 0 "general_operand" "")
 421           (compare (match_operand:BLK 1 "general_operand" "")
 422                    (match_operand:BLK 2 "general_operand" "")))
 423      (use (match_operand:SI 3 "general_operand" ""))
 424      (use (match_operand:SI 4 "" ""))]
 425    ""
 426    "
 427 {
 428   rtx op1, op2;
 429
 430   op1 = XEXP (operands[1], 0);
 431   if (GET_CODE (op1) == REG
 432       || (GET_CODE (op1) == PLUS && GET_CODE (XEXP (op1, 0)) == REG
 433           && GET_CODE (XEXP (op1, 1)) == CONST_INT
 434           && (unsigned) INTVAL (XEXP (op1, 1)) < 4096))
 435     {
 436       op1 = operands[1];
 437     }
 438   else
 439     {
 440       op1 = gen_rtx (MEM, BLKmode, copy_to_mode_reg (SImode, op1));
 441     }
 442
 443   op2 = XEXP (operands[2], 0);
 444   if (GET_CODE (op2) == REG
 445       || (GET_CODE (op2) == PLUS && GET_CODE (XEXP (op2, 0)) == REG
 446           && GET_CODE (XEXP (op2, 1)) == CONST_INT
 447           && (unsigned) INTVAL (XEXP (op2, 1)) < 4096))
 448     {
 449       op2 = operands[2];
 450     }
 451   else
 452     {
 453       op2 = gen_rtx (MEM, BLKmode, copy_to_mode_reg (SImode, op2));
 454     }
 455
 456   if (GET_CODE (operands[3]) == CONST_INT && INTVAL (operands[3]) < 256)
 457     {
 458       emit_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
 459                 gen_rtx (SET, VOIDmode, operands[0],
 460                         gen_rtx (COMPARE, VOIDmode, op1, op2)),
 461                 gen_rtx (USE, VOIDmode, operands[3]))));
 462     }
 463   else
 464     {
 465       rtx reg1 = gen_reg_rtx (DImode);
 466       rtx reg2 = gen_reg_rtx (DImode);
 467       rtx subreg = gen_rtx (SUBREG, SImode, reg1, 1);
 468
 469       emit_insn (gen_rtx (SET, VOIDmode, subreg, operands[3]));
 470       emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (SUBREG, SImode, reg2, 1),
 471                                             subreg));
 472       emit_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (5,
 473                 gen_rtx (SET, VOIDmode, operands[0],
 474                         gen_rtx (COMPARE, VOIDmode, op1, op2)),
 475                 gen_rtx (USE, VOIDmode, reg1),
 476                 gen_rtx (USE, VOIDmode, reg2),
 477                 gen_rtx (CLOBBER, VOIDmode, reg1),
 478                 gen_rtx (CLOBBER, VOIDmode, reg2))));
 479     }
 480   DONE;
 481 }")
 482
 483 ; Compare a block that is less than 256 bytes in length.
 484
 485 (define_insn ""
 486   [(set (match_operand:SI 0 "register_operand" "d")
 487         (compare (match_operand:BLK 1 "s_operand" "m")
 488                  (match_operand:BLK 2 "s_operand" "m")))
 489    (use (match_operand:QI 3 "immediate_operand" "I"))]
 490   "((unsigned) INTVAL (operands[3]) < 256)"
 491   "*
 492 {
 493   check_label_emit ();
 494   mvs_check_page (0, 22, 0);
 495   return \"LA   %0,1\;CLC       %O1(%c3,%R1),%2\;BH     *+12\;BL        *+6\;SLR        %0,%0\;LNR      %0,%0\";
 496 }")
 497
 498 ; Compare a block that is larger than 255 bytes in length.
 499
 500 (define_insn ""
 501   [(set (match_operand:SI 0 "register_operand" "d")
 502         (compare (match_operand:BLK 1 "general_operand" "m")
 503                  (match_operand:BLK 2 "general_operand" "m")))
 504    (use (match_operand:DI 3 "register_operand" "d"))
 505    (use (match_operand:DI 4 "register_operand" "d"))
 506    (clobber (match_dup 3))
 507    (clobber (match_dup 4))]
 508   ""
 509   "*
 510 {
 511   check_label_emit ();
 512   mvs_check_page (0, 26, 0);
 513   return \"LA   %3,%1\;LA       %4,%2\;LA       %0,1\;CLCL      %3,%4\;BH       *+12\;BL        *+6\;SLR        %0,%0\;LNR      %0,%0\";
 514 }")
 515
 516 ;;
 517 ;;- Move instructions.
 518 ;;
 519
 520 ;
 521 ; movdi instruction pattern(s).
 522 ;
 523
 524 (define_insn ""
 525   [(set (match_operand:DI 0 "r_or_s_operand" "=dm")
 526         (match_operand:DI 1 "r_or_s_operand" "dim*fF"))]
 527   "TARGET_CHAR_INSTRUCTIONS"
 528   "*
 529 {
 530   check_label_emit ();
 531   if (REG_P (operands[0]))
 532     {
 533       if (FP_REG_P (operands[1]))
 534         {
 535           mvs_check_page (0, 8, 0);
 536           return \"STD  %1,140(,13)\;LM %0,%N0,140(13)\";
 537         }
 538       if (REG_P (operands[1]))
 539         {
 540           mvs_check_page (0, 4, 0);
 541           return \"LR   %0,%1\;LR       %N0,%N1\";
 542         }
 543       if (operands[1] == const0_rtx)
 544         {
 545           CC_STATUS_INIT;
 546           mvs_check_page (0, 4, 0);
 547           return \"SLR  %0,%0\;SLR      %N0,%N0\";
 548         }
 549       if (GET_CODE (operands[1]) == CONST_INT
 550           && (unsigned) INTVAL (operands[1]) < 4096)
 551         {
 552           CC_STATUS_INIT;
 553           mvs_check_page (0, 6, 0);
 554           return \"SLR  %0,%0\;LA       %N0,%c1\";
 555         }
 556       if (GET_CODE (operands[1]) == CONST_INT)
 557         {
 558           CC_STATUS_SET (operands[0], operands[1]);
 559           mvs_check_page (0, 8, 0);
 560           return \"L    %0,%1\;SRDA     %0,32\";
 561         }
 562       mvs_check_page (0, 4, 0);
 563       return \"LM       %0,%N0,%1\";
 564     }
 565   else if (FP_REG_P (operands[1]))
 566     {
 567       mvs_check_page (0, 4, 0);
 568       return \"STD      %1,%0\";
 569     }
 570   else if (REG_P (operands[1]))
 571     {
 572       mvs_check_page (0, 4, 0);
 573       return \"STM      %1,%N1,%0\";
 574     }
 575   mvs_check_page (0, 6, 0);
 576   return \"MVC  %O0(8,%R0),%1\";
 577 }")
 578
 579 (define_insn "movdi"
 580   [(set (match_operand:DI 0 "general_operand" "=dm")
 581         (match_operand:DI 1 "general_operand" "dim*fF"))]
 582   ""
 583   "*
 584 {
 585   check_label_emit ();
 586   if (REG_P (operands[0]))
 587     {
 588       if (FP_REG_P (operands[1]))
 589         {
 590           mvs_check_page (0, 8, 0);
 591           return \"STD  %1,140(,13)\;LM %0,%N0,140(13)\";
 592         }
 593       if (REG_P (operands[1]))
 594         {
 595           mvs_check_page (0, 4, 0);
 596           return \"LR   %0,%1\;LR       %N0,%N1\";
 597         }
 598       if (operands[1] == const0_rtx)
 599         {
 600           CC_STATUS_INIT;
 601           mvs_check_page (0, 4, 0);
 602           return \"SLR  %0,%0\;SLR      %N0,%N0\";
 603         }
 604       if (GET_CODE (operands[1]) == CONST_INT
 605           && (unsigned) INTVAL (operands[1]) < 4096)
 606         {
 607           CC_STATUS_INIT;
 608           mvs_check_page (0, 6, 0);
 609           return \"SLR  %0,%0\;LA       %N0,%c1\";
 610         }
 611       if (GET_CODE (operands[1]) == CONST_INT)
 612         {
 613           CC_STATUS_SET (operands[0], operands[1]);
 614           mvs_check_page (0, 8, 0);
 615           return \"L    %0,%1\;SRDA     %0,32\";
 616         }
 617       mvs_check_page (0, 4, 0);
 618       return \"LM       %0,%N0,%1\";
 619     }
 620   else if (FP_REG_P (operands[1]))
 621     {
 622       mvs_check_page (0, 4, 0);
 623       return \"STD      %1,%0\";
 624     }
 625   mvs_check_page (0, 4, 0);
 626   return \"STM  %1,%N1,%0\";
 627 }")
 628
 629 ;
 630 ; movsi instruction pattern(s).
 631 ;
 632
 633 (define_insn ""
 634   [(set (match_operand:SI 0 "r_or_s_operand" "=dm,dm")
 635         (match_operand:SI 1 "r_or_s_operand" "dim,*fF"))]
 636   "TARGET_CHAR_INSTRUCTIONS"
 637   "*
 638 {
 639   check_label_emit ();
 640   if (REG_P (operands[0]))
 641     {
 642       if (FP_REG_P (operands[1]))
 643         {
 644           mvs_check_page (0, 8, 0);
 645           return \"STE  %1,140(,13)\;L  %0,140(,13)\";
 646         }
 647       if (REG_P (operands[1]))
 648         {
 649           mvs_check_page (0, 2, 0);
 650           return \"LR   %0,%1\";
 651         }
 652       if (operands[1] == const0_rtx)
 653         {
 654           CC_STATUS_INIT;
 655           mvs_check_page (0, 2, 0);
 656           return \"SLR  %0,%0\";
 657         }
 658       if (GET_CODE (operands[1]) == CONST_INT
 659           && (unsigned) INTVAL (operands[1]) < 4096)
 660         {
 661           mvs_check_page (0, 4, 0);
 662           return \"LA   %0,%c1\";
 663         }
 664       mvs_check_page (0, 4, 0);
 665       return \"L        %0,%1\";
 666     }
 667   else if (FP_REG_P (operands[1]))
 668     {
 669       mvs_check_page (0, 4, 0);
 670       return \"STE      %1,%0\";
 671     }
 672   else if (REG_P (operands[1]))
 673     {
 674       mvs_check_page (0, 4, 0);
 675       return \"ST       %1,%0\";
 676     }
 677   mvs_check_page (0, 6, 0);
 678   return \"MVC  %O0(4,%R0),%1\";
 679 }")
 680
 681 (define_insn "movsi"
 682   [(set (match_operand:SI 0 "general_operand" "=d,dm")
 683         (match_operand:SI 1 "general_operand" "dimF,*fd"))]
 684   ""
 685   "*
 686 {
 687   check_label_emit ();
 688   if (REG_P (operands[0]))
 689     {
 690       if (FP_REG_P (operands[1]))
 691         {
 692           mvs_check_page (0, 8, 0);
 693           return \"STE  %1,140(,13)\;L  %0,140(,13)\";
 694         }
 695       if (REG_P (operands[1]))
 696         {
 697           mvs_check_page (0, 2, 0);
 698           return \"LR   %0,%1\";
 699         }
 700       if (operands[1] == const0_rtx)
 701         {
 702           CC_STATUS_INIT;
 703           mvs_check_page (0, 2, 0);
 704           return \"SLR  %0,%0\";
 705         }
 706       if (GET_CODE (operands[1]) == CONST_INT
 707           && (unsigned) INTVAL (operands[1]) < 4096)
 708         {
 709           mvs_check_page (0, 4, 0);
 710           return \"LA   %0,%c1\";
 711         }
 712       mvs_check_page (0, 4, 0);
 713       return \"L        %0,%1\";
 714     }
 715   else if (FP_REG_P (operands[1]))
 716     {
 717       mvs_check_page (0, 4, 0);
 718       return \"STE      %1,%0\";
 719     }
 720   mvs_check_page (0, 4, 0);
 721   return \"ST   %1,%0\";
 722 }")
 723
 724 ;(define_expand "movsi"
 725 ;  [(set (match_operand:SI 0 "general_operand" "=d,dm")
 726 ;       (match_operand:SI 1 "general_operand" "dimF,*fd"))]
 727 ;  ""
 728 ;  "
 729 ;{
 730 ;  rtx op0, op1;
 731 ;
 732 ;  op0 = operands[0];
 733 ;  if (GET_CODE (op0) == CONST
 734 ;      && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SYMBOL_REF
 735 ;      && SYMBOL_REF_FLAG (XEXP (XEXP (op0, 0), 0)))
 736 ;    {
 737 ;      op0 = gen_rtx (MEM, SImode, copy_to_mode_reg (SImode, XEXP (op0, 0)));
 738 ;    }
 739 ;
 740 ;  op1 = operands[1];
 741 ;  if (GET_CODE (op1) == CONST
 742 ;      && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SYMBOL_REF
 743 ;      && SYMBOL_REF_FLAG (XEXP (XEXP (op1, 0), 0)))
 744 ;    {
 745 ;      op1 = gen_rtx (MEM, SImode, copy_to_mode_reg (SImode, XEXP (op1, 0)));
 746 ;    }
 747 ;
 748 ;  emit_insn (gen_rtx (SET, VOIDmode, op0, op1));
 749 ;  DONE;
 750 ;}")
 751
 752 ;
 753 ; movhi instruction pattern(s).
 754 ;
 755
 756 (define_insn ""
 757   [(set (match_operand:HI 0 "r_or_s_operand" "=g")
 758         (match_operand:HI 1 "r_or_s_operand" "g"))]
 759   "TARGET_CHAR_INSTRUCTIONS"
 760   "*
 761 {
 762   check_label_emit ();
 763   if (REG_P (operands[0]))
 764     {
 765       if (REG_P (operands[1]))
 766         {
 767           mvs_check_page (0, 2, 0);
 768           return \"LR   %0,%1\";
 769         }
 770       if (operands[1] == const0_rtx)
 771         {
 772           CC_STATUS_INIT;
 773           mvs_check_page (0, 2, 0);
 774           return \"SLR  %0,%0\";
 775         }
 776       if (GET_CODE (operands[1]) == CONST_INT
 777           && (unsigned) INTVAL (operands[1]) < 4096)
 778         {
 779           mvs_check_page (0, 4, 0);
 780           return \"LA   %0,%c1\";
 781         }
 782       if (GET_CODE (operands[1]) == CONST_INT)
 783         {
 784           mvs_check_page (0, 4, 0);
 785           return \"LH   %0,%H1\";
 786         }
 787       mvs_check_page (0, 4, 0);
 788       return \"LH       %0,%1\";
 789     }
 790   else if (REG_P (operands[1]))
 791     {
 792       mvs_check_page (0, 4, 0);
 793       return \"STH      %1,%0\";
 794     }
 795   if (GET_CODE (operands[1]) == CONST_INT)
 796     {
 797       mvs_check_page (0, 6, 0);
 798       return \"MVC      %O0(2,%R0),%H1\";
 799     }
 800   mvs_check_page (0, 6, 0);
 801   return \"MVC  %O0(2,%R0),%1\";
 802 }")
 803
 804 (define_insn "movhi"
 805   [(set (match_operand:HI 0 "general_operand" "=d,m")
 806         (match_operand:HI 1 "general_operand" "g,d"))]
 807   ""
 808   "*
 809 {
 810   check_label_emit ();
 811   if (REG_P (operands[0]))
 812     {
 813       if (REG_P (operands[1]))
 814         {
 815           mvs_check_page (0, 2, 0);
 816           return \"LR   %0,%1\";
 817         }
 818       if (operands[1] == const0_rtx)
 819         {
 820           CC_STATUS_INIT;
 821           mvs_check_page (0, 2, 0);
 822           return \"SLR  %0,%0\";
 823         }
 824       if (GET_CODE (operands[1]) == CONST_INT
 825           && (unsigned) INTVAL (operands[1]) < 4096)
 826         {
 827           mvs_check_page (0, 4, 0);
 828           return \"LA   %0,%c1\";
 829         }
 830       if (GET_CODE (operands[1]) == CONST_INT)
 831         {
 832           mvs_check_page (0, 4, 0);
 833           return \"LH   %0,%H1\";
 834         }
 835       mvs_check_page (0, 4, 0);
 836       return \"LH       %0,%1\";
 837     }
 838   mvs_check_page (0, 4, 0);
 839   return \"STH  %1,%0\";
 840 }")
 841
 842 ;
 843 ; movqi instruction pattern(s).
 844 ;
 845
 846 (define_insn ""
 847   [(set (match_operand:QI 0 "r_or_s_operand" "=g")
 848         (match_operand:QI 1 "r_or_s_operand" "g"))]
 849   "TARGET_CHAR_INSTRUCTIONS"
 850   "*
 851 {
 852   check_label_emit ();
 853   if (REG_P (operands[0]))
 854     {
 855       if (REG_P (operands[1]))
 856         {
 857           mvs_check_page (0, 2, 0);
 858           return \"LR   %0,%1\";
 859         }
 860       if (operands[1] == const0_rtx)
 861         {
 862           CC_STATUS_INIT;
 863           mvs_check_page (0, 2, 0);
 864           return \"SLR  %0,%0\";
 865         }
 866       if (GET_CODE (operands[1]) == CONST_INT)
 867         {
 868           if (INTVAL (operands[1]) >= 0)
 869             {
 870               mvs_check_page (0, 4, 0);
 871               return \"LA       %0,%c1\";
 872             }
 873           mvs_check_page (0, 4, 0);
 874           return \"L    %0,=F'%c1'\";
 875         }
 876       mvs_check_page (0, 4, 0);
 877       return \"IC       %0,%1\";
 878     }
 879   else if (REG_P (operands[1]))
 880     {
 881       mvs_check_page (0, 4, 0);
 882       return \"STC      %1,%0\";
 883     }
 884   else if (GET_CODE (operands[1]) == CONST_INT)
 885     {
 886       mvs_check_page (0, 4, 0);
 887       return \"MVI      %0,%B1\";
 888     }
 889   mvs_check_page (0, 6, 0);
 890   return \"MVC  %O0(1,%R0),%1\";
 891 }")
 892
 893 (define_insn "movqi"
 894   [(set (match_operand:QI 0 "general_operand" "=d,m")
 895         (match_operand:QI 1 "general_operand" "g,d"))]
 896   ""
 897   "*
 898 {
 899   check_label_emit ();
 900   if (REG_P (operands[0]))
 901     {
 902       if (REG_P (operands[1]))
 903         {
 904           mvs_check_page (0, 2, 0);
 905           return \"LR   %0,%1\";
 906         }
 907       if (operands[1] == const0_rtx)
 908         {
 909           CC_STATUS_INIT;
 910           mvs_check_page (0, 2, 0);
 911           return \"SLR  %0,%0\";
 912         }
 913       if (GET_CODE (operands[1]) == CONST_INT)
 914         {
 915           if (INTVAL (operands[1]) >= 0)
 916             {
 917               mvs_check_page (0, 4, 0);
 918               return \"LA       %0,%c1\";
 919             }
 920           mvs_check_page (0, 4, 0);
 921           return \"L    %0,=F'%c1'\";
 922         }
 923       mvs_check_page (0, 4, 0);
 924       return \"IC       %0,%1\";
 925     }
 926   mvs_check_page (0, 4, 0);
 927   return \"STC  %1,%0\";
 928 }")
 929
 930 ;
 931 ; movestrictqi instruction pattern(s).
 932 ;
 933
 934 (define_insn "movestrictqi"
 935   [(set (strict_low_part (match_operand:QI 0 "general_operand" "=d"))
 936         (match_operand:QI 1 "general_operand" "g"))]
 937   ""
 938   "*
 939 {
 940   check_label_emit ();
 941   if (REG_P (operands[1]))
 942     {
 943       mvs_check_page (0, 8, 0);
 944       return \"STC      %1,140(,13)\;IC %0,140(,13)\";
 945     }
 946   mvs_check_page (0, 4, 0);
 947   return \"IC   %0,%1\";
 948 }")
 949
 950 ;
 951 ; movstricthi instruction pattern(s).
 952 ;
 953
 954 (define_insn ""
 955   [(set (strict_low_part (match_operand:HI 0 "register_operand" "=d"))
 956         (match_operand:HI 1 "r_or_s_operand" "g"))]
 957   ""
 958   "*
 959 {
 960   check_label_emit ();
 961   if (REG_P (operands[1]))
 962     {
 963       mvs_check_page (0, 8, 0);
 964       return \"STH      %1,140(,13)\;ICM        %0,3,140(13)\";
 965     }
 966   else if (GET_CODE (operands[1]) == CONST_INT)
 967     {
 968       mvs_check_page (0, 4, 0);
 969       return \"ICM      %0,3,%H1\";
 970     }
 971   mvs_check_page (0, 4, 0);
 972   return \"ICM  %0,3,%1\";
 973 }")
 974
 975 (define_insn "movestricthi"
 976   [(set (strict_low_part (match_operand:HI 0 "general_operand" "=dm"))
 977         (match_operand:HI 1 "general_operand" "d"))]
 978   ""
 979   "*
 980 {
 981   check_label_emit ();
 982   if (REG_P (operands[0]))
 983     {
 984       mvs_check_page (0, 8, 0);
 985       return \"STH      %1,140(,13)\;ICM        %0,3,140(13)\";
 986     }
 987   mvs_check_page (0, 4, 0);
 988   return \"STH  %1,%0\";
 989 }")
 990
 991 ;
 992 ; movdf instruction pattern(s).
 993 ;
 994
 995 (define_insn ""
 996   [(set (match_operand:DF 0 "r_or_s_operand" "=fm,fm,*dm")
 997         (match_operand:DF 1 "r_or_s_operand" "fmF,*dm,fmF"))]
 998   "TARGET_CHAR_INSTRUCTIONS"
 999   "*
1000 {
1001   check_label_emit ();
1002   if (FP_REG_P (operands[0]))
1003     {
1004       if (FP_REG_P (operands[1]))
1005         {
1006           mvs_check_page (0, 2, 0);
1007           return \"LDR  %0,%1\";
1008         }
1009       if (REG_P (operands[1]))
1010         {
1011           mvs_check_page (0, 8, 0);
1012           return \"STM  %1,%N1,140(13)\;LD      %0,140(,13)\";
1013         }
1014       if (operands[1] == const0_rtx)
1015         {
1016           CC_STATUS_SET (operands[0], operands[1]);
1017           mvs_check_page (0, 2, 0);
1018           return \"SDR  %0,%0\";
1019         }
1020       mvs_check_page (0, 4, 0);
1021       return \"LD       %0,%1\";
1022     }
1023   if (REG_P (operands[0]))
1024     {
1025       if (FP_REG_P (operands[1]))
1026         {
1027           mvs_check_page (0, 12, 0);
1028           return \"STD  %1,140(,13)\;LM %0,%N0,140(13)\";
1029         }
1030       mvs_check_page (0, 4, 0);
1031       return \"LM       %0,%N0,%1\";
1032     }
1033   else if (FP_REG_P (operands[1]))
1034     {
1035       mvs_check_page (0, 4, 0);
1036       return \"STD      %1,%0\";
1037     }
1038   else if (REG_P (operands[1]))
1039     {
1040       mvs_check_page (0, 4, 0);
1041       return \"STM      %1,%N1,%0\";
1042     }
1043   mvs_check_page (0, 6, 0);
1044   return \"MVC  %O0(8,%R0),%1\";
1045 }")
1046
1047 (define_insn "movdf"
1048   [(set (match_operand:DF 0 "general_operand" "=f,fm,m,*d")
1049         (match_operand:DF 1 "general_operand" "fmF,*d,f,fmF"))]
1050   ""
1051   "*
1052 {
1053   check_label_emit ();
1054   if (FP_REG_P (operands[0]))
1055     {
1056       if (FP_REG_P (operands[1]))
1057         {
1058           mvs_check_page (0, 2, 0);
1059           return \"LDR  %0,%1\";
1060         }
1061       if (REG_P (operands[1]))
1062         {
1063           mvs_check_page (0, 8, 0);
1064           return \"STM  %1,%N1,140(13)\;LD      %0,140(,13)\";
1065         }
1066       if (operands[1] == const0_rtx)
1067         {
1068           CC_STATUS_SET (operands[0], operands[1]);
1069           mvs_check_page (0, 2, 0);
1070           return \"SDR  %0,%0\";
1071         }
1072       mvs_check_page (0, 4, 0);
1073       return \"LD       %0,%1\";
1074     }
1075   else if (REG_P (operands[0]))
1076     {
1077       if (FP_REG_P (operands[1]))
1078         {
1079           mvs_check_page (0, 12, 0);
1080           return \"STD  %1,140(,13)\;LM %0,%N0,140(13)\";
1081         }
1082       mvs_check_page (0, 4, 0);
1083       return \"LM       %0,%N0,%1\";
1084     }
1085   else if (FP_REG_P (operands[1]))
1086     {
1087       mvs_check_page (0, 4, 0);
1088       return \"STD      %1,%0\";
1089     }
1090   mvs_check_page (0, 4, 0);
1091   return \"STM  %1,%N1,%0\";
1092 }")
1093
1094 ;
1095 ; movsf instruction pattern(s).
1096 ;
1097
1098 (define_insn ""
1099   [(set (match_operand:SF 0 "r_or_s_operand" "=fm,fm,*dm")
1100         (match_operand:SF 1 "r_or_s_operand" "fmF,*dm,fmF"))]
1101   "TARGET_CHAR_INSTRUCTIONS"
1102   "*
1103 {
1104   check_label_emit ();
1105   if (FP_REG_P (operands[0]))
1106     {
1107       if (FP_REG_P (operands[1]))
1108         {
1109           mvs_check_page (0, 2, 0);
1110           return \"LER  %0,%1\";
1111         }
1112       if (REG_P (operands[1]))
1113         {
1114           mvs_check_page (0, 8, 0);
1115           return \"ST   %1,140(,13)\;LE %0,140(,13)\";
1116         }
1117       if (operands[1] == const0_rtx)
1118         {
1119           CC_STATUS_SET (operands[0], operands[1]);
1120           mvs_check_page (0, 2, 0);
1121           return \"SER  %0,%0\";
1122         }
1123       mvs_check_page (0, 4, 0);
1124       return \"LE       %0,%1\";
1125     }
1126   else if (REG_P (operands[0]))
1127     {
1128       if (FP_REG_P (operands[1]))
1129         {
1130           mvs_check_page (0, 8, 0);
1131           return \"STE  %1,140(,13)\;L  %0,140(,13)\";
1132         }
1133       mvs_check_page (0, 4, 0);
1134       return \"L        %0,%1\";
1135     }
1136   else if (FP_REG_P (operands[1]))
1137     {
1138       mvs_check_page (0, 4, 0);
1139       return \"STE      %1,%0\";
1140     }
1141   else if (REG_P (operands[1]))
1142     {
1143       mvs_check_page (0, 4, 0);
1144       return \"ST       %1,%0\";
1145     }
1146   mvs_check_page (0, 6, 0);
1147   return \"MVC  %O0(4,%R0),%1\";
1148 }")
1149
1150 (define_insn "movsf"
1151   [(set (match_operand:SF 0 "general_operand" "=f,fm,m,*d")
1152         (match_operand:SF 1 "general_operand" "fmF,*d,f,fmF"))]
1153   ""
1154   "*
1155 {
1156   check_label_emit ();
1157   if (FP_REG_P (operands[0]))
1158     {
1159       if (FP_REG_P (operands[1]))
1160         {
1161           mvs_check_page (0, 2, 0);
1162           return \"LER  %0,%1\";
1163         }
1164       if (REG_P (operands[1]))
1165         {
1166           mvs_check_page (0, 8, 0);
1167           return \"ST   %1,140(,13)\;LE %0,140(,13)\";
1168         }
1169       if (operands[1] == const0_rtx)
1170         {
1171           CC_STATUS_SET (operands[0], operands[1]);
1172           mvs_check_page (0, 2, 0);
1173           return \"SER  %0,%0\";
1174         }
1175       mvs_check_page (0, 4, 0);
1176       return \"LE       %0,%1\";
1177     }
1178   else if (REG_P (operands[0]))
1179     {
1180       if (FP_REG_P (operands[1]))
1181         {
1182           mvs_check_page (0, 8, 0);
1183           return \"STE  %1,140(,13)\;L  %0,140(,13)\";
1184         }
1185       mvs_check_page (0, 4, 0);
1186       return \"L        %0,%1\";
1187     }
1188   else if (FP_REG_P (operands[1]))
1189     {
1190       mvs_check_page (0, 4, 0);
1191       return \"STE      %1,%0\";
1192     }
1193   mvs_check_page (0, 4, 0);
1194   return \"ST   %1,%0\";
1195 }")
1196
1197 ;
1198 ; movstrsi instruction pattern(s).
1199 ;
1200
1201 (define_expand "movstrsi"
1202   [(set (match_operand:BLK 0 "general_operand" "")
1203         (match_operand:BLK 1 "general_operand" ""))
1204    (use (match_operand:SI 2 "general_operand" ""))
1205    (match_operand 3 "" "")]
1206    ""
1207    "
1208 {
1209   rtx op0, op1;
1210
1211   op0 = XEXP (operands[0], 0);
1212   if (GET_CODE (op0) == REG
1213        || (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 0)) == REG
1214            && GET_CODE (XEXP (op0, 1)) == CONST_INT
1215            && (unsigned) INTVAL (XEXP (op0, 1)) < 4096))
1216     {
1217       op0 = operands[0];
1218     }
1219   else
1220     {
1221       op0 = gen_rtx (MEM, BLKmode, copy_to_mode_reg (SImode, op0));
1222     }
1223
1224   op1 = XEXP (operands[1], 0);
1225   if (GET_CODE (op1) == REG
1226       || (GET_CODE (op1) == PLUS && GET_CODE (XEXP (op1, 0)) == REG
1227           && GET_CODE (XEXP (op1, 1)) == CONST_INT
1228           && (unsigned) INTVAL (XEXP (op1, 1)) < 4096))
1229     {
1230       op1 = operands[1];
1231     }
1232   else
1233     {
1234       op1 = gen_rtx (MEM, BLKmode, copy_to_mode_reg (SImode, op1));
1235     }
1236
1237   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 256)
1238     {
1239       emit_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
1240                         gen_rtx (SET, VOIDmode, op0, op1),
1241                         gen_rtx (USE, VOIDmode, operands[2]))));
1242     }
1243   else
1244     {
1245       rtx reg1 = gen_reg_rtx (DImode);
1246       rtx reg2 = gen_reg_rtx (DImode);
1247       rtx subreg = gen_rtx (SUBREG, SImode, reg1, 1);
1248
1249       emit_insn (gen_rtx (SET, VOIDmode, subreg, operands[2]));
1250       emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (SUBREG, SImode, reg2, 1),
1251                                                  subreg));
1252       emit_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (5,
1253                         gen_rtx (SET, VOIDmode, op0, op1),
1254                         gen_rtx (USE, VOIDmode, reg1),
1255                         gen_rtx (USE, VOIDmode, reg2),
1256                         gen_rtx (CLOBBER, VOIDmode, reg1),
1257                         gen_rtx (CLOBBER, VOIDmode, reg2))));
1258     }
1259   DONE;
1260 }")
1261
1262 ; Move a block that is less than 256 bytes in length.
1263
1264 (define_insn ""
1265   [(set (match_operand:BLK 0 "s_operand" "=m")
1266         (match_operand:BLK 1 "s_operand" "m"))
1267    (use (match_operand 2 "immediate_operand" "I"))]
1268   "((unsigned) INTVAL (operands[2]) < 256)"
1269   "*
1270 {
1271   check_label_emit ();
1272   mvs_check_page (0, 6, 0);
1273   return \"MVC  %O0(%c2,%R0),%1\";
1274 }")
1275
1276 ; Move a block that is larger than 255 bytes in length.
1277
1278 (define_insn ""
1279   [(set (match_operand:BLK 0 "general_operand" "=m")
1280         (match_operand:BLK 1 "general_operand" "m"))
1281    (use (match_operand:DI 2 "register_operand" "d"))
1282    (use (match_operand:DI 3 "register_operand" "d"))
1283    (clobber (match_dup 2))
1284    (clobber (match_dup 3))]
1285   ""
1286   "*
1287 {
1288   check_label_emit ();
1289   mvs_check_page (0, 10, 0);
1290   return \"LA   %2,%0\;LA       %3,%1\;MVCL     %2,%3\";
1291 }")
1292
1293 ;;
1294 ;;- Conversion instructions.
1295 ;;
1296
1297 ;
1298 ; extendsidi2 instruction pattern(s).
1299 ;
1300
1301 (define_expand "extendsidi2"
1302   [(set (match_operand:DI 0 "general_operand" "")
1303         (sign_extend:DI (match_operand:SI 1 "general_operand" "")))]
1304   ""
1305   "
1306 {
1307   if (GET_CODE (operands[1]) != CONST_INT)
1308     {
1309       emit_insn (gen_rtx (SET, VOIDmode,
1310                   operand_subword (operands[0], 0, 1, DImode), operands[1]));
1311       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
1312                         gen_rtx (ASHIFTRT, DImode, operands[0],
1313                                 gen_rtx (CONST_INT, SImode, 32))));
1314     }
1315   else
1316     {
1317       if (INTVAL (operands[1]) < 0)
1318         {
1319           emit_insn (gen_rtx (SET, VOIDmode,
1320                                   operand_subword (operands[0], 0, 1, DImode),
1321                                gen_rtx (CONST_INT, SImode, -1)));
1322         }
1323       else
1324         {
1325           emit_insn (gen_rtx (SET, VOIDmode,
1326                                 operand_subword (operands[0], 0, 1, DImode),
1327                                gen_rtx (CONST_INT, SImode, 0)));
1328         }
1329       emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (SImode, operands[0]),
1330                            operands[1]));
1331     }
1332   DONE;
1333 }")
1334
1335 ;
1336 ; extendhisi2 instruction pattern(s).
1337 ;
1338
1339 (define_insn "extendhisi2"
1340   [(set (match_operand:SI 0 "general_operand" "=d,m")
1341         (sign_extend:SI (match_operand:HI 1 "general_operand" "g,d")))]
1342   ""
1343   "*
1344 {
1345   check_label_emit ();
1346   if (REG_P (operands[0]))
1347     {
1348       if (REG_P (operands[1]))
1349         if (REGNO (operands[0]) != REGNO (operands[1]))
1350           {
1351             mvs_check_page (0, 2, 0);
1352             return \"LR %0,%1\;SLL      %0,16\;SRA      %0,16\";
1353           }
1354         else
1355           return \"\"; /* Should be empty.  16-bits regs are always 32-bits.  */
1356       if (operands[1] == const0_rtx)
1357         {
1358           CC_STATUS_INIT;
1359           mvs_check_page (0, 2, 0);
1360           return \"SLR  %0,%0\";
1361         }
1362       if (GET_CODE (operands[1]) == CONST_INT
1363           && (unsigned) INTVAL (operands[1]) < 4096)
1364         {
1365           mvs_check_page (0, 4, 0);
1366           return \"LA   %0,%c1\";
1367         }
1368       if (GET_CODE (operands[1]) == CONST_INT)
1369         {
1370           mvs_check_page (0, 4, 0);
1371           return \"LH   %0,%H1\";
1372         }
1373       mvs_check_page (0, 4, 0);
1374       return \"LH       %0,%1\";
1375     }
1376   mvs_check_page (0, 4, 0);
1377   return \"SLL  %1,16\;SRA      %1,16\;ST       %1,%0\";
1378 }")
1379
1380 ;
1381 ; extendqisi2 instruction pattern(s).
1382 ;
1383
1384 (define_insn "extendqisi2"
1385   [(set (match_operand:SI 0 "general_operand" "=d")
1386         (sign_extend:SI (match_operand:QI 1 "general_operand" "0mi")))]
1387   ""
1388   "*
1389 {
1390   check_label_emit ();
1391   CC_STATUS_SET (operands[0], operands[1]);
1392   if (REG_P (operands[1]))
1393     {
1394       mvs_check_page (0, 8, 0);
1395       return \"SLL      %0,24\;SRA      %0,24\";
1396     }
1397   if (s_operand (operands[1]))
1398     {
1399       mvs_check_page (0, 8, 0);
1400       return \"ICM      %0,8,%1\;SRA    %0,24\";
1401     }
1402   mvs_check_page (0, 12, 0);
1403   return \"IC   %0,%1\;SLL      %0,24\;SRA      %0,24\";
1404 }")
1405
1406 ;
1407 ; extendqihi2 instruction pattern(s).
1408 ;
1409
1410 (define_insn "extendqihi2"
1411   [(set (match_operand:HI 0 "general_operand" "=d")
1412         (sign_extend:HI (match_operand:QI 1 "general_operand" "0m")))]
1413   ""
1414   "*
1415 {
1416   check_label_emit ();
1417   CC_STATUS_SET (operands[0], operands[1]);
1418   if (REG_P (operands[1]))
1419     {
1420       mvs_check_page (0, 8, 0);
1421       return \"SLL      %0,24\;SRA      %0,24\";
1422     }
1423   if (s_operand (operands[1]))
1424     {
1425       mvs_check_page (0, 8, 0);
1426       return \"ICM      %0,8,%1\;SRA    %0,24\";
1427     }
1428   mvs_check_page (0, 12, 0);
1429   return \"IC   %0,%1\;SLL      %0,24\;SRA      %0,24\";
1430 }")
1431
1432 ;
1433 ; zero_extendsidi2 instruction pattern(s).
1434 ;
1435
1436 (define_expand "zero_extendsidi2"
1437   [(set (match_operand:DI 0 "general_operand" "")
1438         (zero_extend:DI (match_operand:SI 1 "general_operand" "")))]
1439   ""
1440   "
1441 {
1442       emit_insn (gen_rtx (SET, VOIDmode,
1443                   operand_subword (operands[0], 0, 1, DImode), operands[1]));
1444       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
1445                         gen_rtx (LSHIFTRT, DImode, operands[0],
1446                                 gen_rtx (CONST_INT, SImode, 32))));
1447   DONE;
1448 }")
1449
1450 ;
1451 ; zero_extendhisi2 instruction pattern(s).
1452 ;
1453
1454 (define_insn "zero_extendhisi2"
1455   [(set (match_operand:SI 0 "general_operand" "=d")
1456         (zero_extend:SI (match_operand:HI 1 "general_operand" "0")))]
1457   ""
1458   "*
1459 {
1460   check_label_emit ();
1461   CC_STATUS_SET (operands[0], operands[1]);
1462   mvs_check_page (0, 4, 4);
1463   return \"N    %1,=X'0000FFFF'\";
1464 }")
1465
1466 ;
1467 ; zero_extendqisi2 instruction pattern(s).
1468 ;
1469
1470 (define_insn "zero_extendqisi2"
1471   [(set (match_operand:SI 0 "general_operand" "=d,&d")
1472         (zero_extend:SI (match_operand:QI 1 "general_operand" "0i,m")))]
1473   ""
1474   "*
1475 {
1476   check_label_emit ();
1477   if (REG_P (operands[1]))
1478     {
1479       CC_STATUS_SET (operands[0], operands[1]);
1480       mvs_check_page (0, 4, 4);
1481       return \"N        %0,=X'000000FF'\";
1482     }
1483   if (GET_CODE (operands[1]) == CONST_INT)
1484     {
1485       mvs_check_page (0, 4, 0);
1486       return \"LA       %0,%c1\";
1487     }
1488   CC_STATUS_INIT;
1489   mvs_check_page (0, 8, 0);
1490   return \"SLR  %0,%0\;IC       %0,%1\";
1491 }")
1492
1493 ;
1494 ; zero_extendqihi2 instruction pattern(s).
1495 ;
1496
1497 (define_insn "zero_extendqihi2"
1498   [(set (match_operand:HI 0 "general_operand" "=d,&d")
1499         (zero_extend:HI (match_operand:QI 1 "general_operand" "0i,m")))]
1500   ""
1501   "*
1502 {
1503   check_label_emit ();
1504   if (REG_P (operands[1]))
1505     {
1506       CC_STATUS_SET (operands[0], operands[1]);
1507       mvs_check_page (0, 4, 4);
1508       return \"N        %0,=X'000000FF'\";
1509     }
1510   if (GET_CODE (operands[1]) == CONST_INT)
1511     {
1512       mvs_check_page (0, 4, 0);
1513       return \"LA       %0,%c1\";
1514     }
1515   CC_STATUS_INIT;
1516   mvs_check_page (0, 8, 0);
1517   return \"SLR  %0,%0\;IC       %0,%1\";
1518 }")
1519
1520 ;
1521 ; truncsihi2 instruction pattern(s).
1522 ;
1523
1524 (define_insn "truncsihi2"
1525   [(set (match_operand:HI 0 "general_operand" "=d,m")
1526         (truncate:HI (match_operand:SI 1 "general_operand" "0,d")))]
1527   ""
1528   "*
1529 {
1530   check_label_emit ();
1531   if (REG_P (operands[0]))
1532     {
1533       CC_STATUS_SET (operands[0], operands[1]);
1534       mvs_check_page (0, 8, 0);
1535       return \"SLL      %0,16\;SRA      %0,16\";
1536     }
1537   mvs_check_page (0, 4, 0);
1538   return \"STH  %1,%0\";
1539 }")
1540
1541 ;
1542 ; fix_truncdfsi2 instruction pattern(s).
1543 ;
1544
1545 (define_insn "fix_truncdfsi2"
1546   [(set (match_operand:SI 0 "general_operand" "=d")
1547         (fix:SI (truncate:DF (match_operand:DF 1 "general_operand" "f"))))
1548         (clobber (reg:DF 16))]
1549   ""
1550   "*
1551 {
1552   check_label_emit ();
1553   CC_STATUS_INIT;
1554   if (REGNO (operands[1]) == 16)
1555     {
1556       mvs_check_page (0, 12, 8);
1557       return \"AD       0,=XL8'4F08000000000000'\;STD   0,140(,13)\;L   %0,144(,13)\";
1558     }
1559   mvs_check_page (0, 14, 8);
1560   return \"LDR  0,%1\;AD        0,=XL8'4F08000000000000'\;STD   0,140(,13)\;L   %0,144(,13)\";
1561 }")
1562
1563 ;
1564 ; floatsidf2 instruction pattern(s).
1565 ;
1566 ; Uses the float field of the TCA.
1567 ;
1568
1569 (define_insn "floatsidf2"
1570   [(set (match_operand:DF 0 "general_operand" "=f")
1571         (float:DF (match_operand:SI 1 "general_operand" "d")))]
1572   ""
1573   "*
1574 {
1575   check_label_emit ();
1576   CC_STATUS_INIT;
1577   mvs_check_page (0, 16, 8);
1578   return \"ST   %1,508(,12)\;XI 508(12),128\;LD %0,504(,12)\;SD %0,=XL8'4E00000080000000'\";
1579 }")
1580
1581 ;
1582 ; truncdfsf2 instruction pattern(s).
1583 ;
1584
1585 (define_insn "truncdfsf2"
1586   [(set (match_operand:SF 0 "general_operand" "=f")
1587         (float_truncate:SF (match_operand:DF 1 "general_operand" "f")))]
1588   ""
1589   "*
1590 {
1591   check_label_emit ();
1592   mvs_check_page (0, 2, 0);
1593   return \"LRER %0,%1\";
1594 }")
1595
1596 ;
1597 ; extendsfdf2 instruction pattern(s).
1598 ;
1599
1600 (define_insn "extendsfdf2"
1601   [(set (match_operand:DF 0 "general_operand" "=f")
1602         (float_extend:DF (match_operand:SF 1 "general_operand" "fmF")))]
1603   ""
1604   "*
1605 {
1606   check_label_emit ();
1607   CC_STATUS_SET (0, const0_rtx);
1608   if (FP_REG_P (operands[1]))
1609     {
1610       if (REGNO (operands[0]) == REGNO (operands[1]))
1611         {
1612           mvs_check_page (0, 10, 0);
1613           return \"STE  %1,140(,13)\;SDR        %0,%0\;LE       %0,140(,13)\";
1614         }
1615       mvs_check_page (0, 4, 0);
1616       return \"SDR      %0,%0\;LER      %0,%1\";
1617     }
1618   mvs_check_page (0, 6, 0);
1619   return \"SDR  %0,%0\;LE       %0,%1\";
1620 }")
1621
1622 ;;
1623 ;;- Add instructions.
1624 ;;
1625
1626 ;
1627 ; adddi3 instruction pattern(s).
1628 ;
1629
1630 (define_expand "adddi3"
1631   [(set (match_operand:DI 0 "general_operand" "")
1632         (plus:DI (match_operand:DI 1 "general_operand" "")
1633                  (match_operand:DI 2 "general_operand" "")))]
1634   ""
1635   "
1636 {
1637   rtx label = gen_label_rtx ();
1638   rtx op0_high = operand_subword (operands[0], 0, 1, DImode);
1639   rtx op0_low = gen_lowpart (SImode, operands[0]);
1640
1641   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1642                     gen_rtx (PLUS, SImode,
1643                             operand_subword (operands[1], 0, 1, DImode),
1644                             operand_subword (operands[2], 0, 1, DImode))));
1645   emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
1646               gen_rtx (SET, VOIDmode, op0_low,
1647                       gen_rtx (PLUS, SImode, gen_lowpart (SImode, operands[1]),
1648                               gen_lowpart (SImode, operands[2]))),
1649               gen_rtx (USE, VOIDmode, gen_rtx (LABEL_REF, VOIDmode, label)))));
1650   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1651                     gen_rtx (PLUS, SImode, op0_high,
1652                             gen_rtx (CONST_INT, SImode, 1))));
1653   emit_label (label);
1654   DONE;
1655 }")
1656
1657 (define_insn ""
1658   [(set (match_operand:SI 0 "general_operand" "=d")
1659         (plus:SI (match_operand:SI 1 "general_operand" "%0")
1660                  (match_operand:SI 2 "general_operand" "g")))
1661    (use (label_ref (match_operand 3 "" "")))]
1662   ""
1663   "*
1664 {
1665   int onpage;
1666
1667   check_label_emit ();
1668   onpage = mvs_check_label (CODE_LABEL_NUMBER (operands[3]));
1669   if (REG_P (operands[2]))
1670     {
1671       if (!onpage)
1672         {
1673           mvs_check_page (0, 8, 4);
1674           return \"ALR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1675         }
1676       if (mvs_check_page (0, 6, 0))
1677         {
1678           mvs_check_page (0, 2, 4);
1679           return \"ALR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1680         }
1681       return \"ALR      %0,%2\;BC       12,%l3\";
1682     }
1683   if (!onpage)
1684     {
1685       mvs_check_page (0, 10, 4);
1686       return \"AL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1687     }
1688   if (mvs_check_page (0, 8 ,0))
1689     {
1690       mvs_check_page (0, 2, 4);
1691       return \"AL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1692     }
1693   return \"AL   %0,%2\;BC       12,%l3\";
1694 }")
1695
1696 ;
1697 ; addsi3 instruction pattern(s).
1698 ;
1699 ; The following insn is used when it is known that operand one is an address,
1700 ; frame, stack or argument pointer, and operand two is a constant that is
1701 ; small enough to fit in the displacement field.
1702 ; Notice that we can't allow the frame pointer to used as a normal register
1703 ; because of this insn.
1704 ;
1705
1706 (define_insn ""
1707   [(set (match_operand:SI 0 "register_operand" "=d")
1708         (plus:SI (match_operand:SI 1 "general_operand" "%a")
1709                  (match_operand:SI 2 "immediate_operand" "J")))]
1710   "((REGNO (operands[1]) == FRAME_POINTER_REGNUM || REGNO (operands[1]) == ARG_POINTER_REGNUM || REGNO (operands[1]) == STACK_POINTER_REGNUM) && (unsigned) INTVAL (operands[2]) < 4096)"
1711   "*
1712 {
1713   check_label_emit ();
1714   CC_STATUS_INIT;
1715   mvs_check_page (0, 4, 0);
1716   return \"LA   %0,%c2(,%1)\";
1717 }")
1718
1719 ; This insn handles additions that are relative to the frame pointer.
1720
1721 (define_insn ""
1722   [(set (match_operand:SI 0 "register_operand" "=d")
1723          (plus:SI (match_operand:SI 1 "register_operand" "%a")
1724                   (match_operand:SI 2 "immediate_operand" "i")))]
1725   "REGNO (operands[1]) == FRAME_POINTER_REGNUM"
1726   "*
1727 {
1728   check_label_emit ();
1729   if ((unsigned) INTVAL (operands[2]) < 4096)
1730     {
1731       mvs_check_page (0, 4, 0);
1732       return \"LA       %0,%c2(,%1)\";
1733     }
1734   if (REGNO (operands[1]) == REGNO (operands[0]))
1735     {
1736       mvs_check_page (0, 4, 0);
1737       return \"A        %0,%2\";
1738     }
1739   mvs_check_page (0, 6, 0);
1740   return \"L    %0,%2\;AR       %0,%1\";
1741 }")
1742
1743 (define_insn "addsi3"
1744   [(set (match_operand:SI 0 "general_operand" "=d")
1745         (plus:SI (match_operand:SI 1 "general_operand" "%0")
1746                  (match_operand:SI 2 "general_operand" "g")))]
1747   ""
1748   "*
1749 {
1750   check_label_emit ();
1751   if (REG_P (operands[2]))
1752     {
1753       mvs_check_page (0, 2, 0);
1754       return \"AR       %0,%2\";
1755     }
1756   if (GET_CODE (operands[2]) == CONST_INT)
1757     {
1758       if (INTVAL (operands[2]) == -1)
1759         {
1760           CC_STATUS_INIT;
1761           mvs_check_page (0, 2, 0);
1762           return \"BCTR %0,0\";
1763         }
1764     }
1765   mvs_check_page (0, 4, 0);
1766   return \"A    %0,%2\";
1767 }")
1768
1769 ;
1770 ; addhi3 instruction pattern(s).
1771 ;
1772
1773 (define_insn "addhi3"
1774   [(set (match_operand:HI 0 "general_operand" "=d")
1775         (plus:HI (match_operand:HI 1 "general_operand" "%0")
1776                  (match_operand:HI 2 "general_operand" "dmi")))]
1777   ""
1778   "*
1779 {
1780   check_label_emit ();
1781   if (REG_P (operands[2]))
1782     {
1783       mvs_check_page (0, 8, 0);
1784       return \"STH      %2,140(,13)\;AH %0,140(,13)\";
1785     }
1786   if (GET_CODE (operands[2]) == CONST_INT)
1787     {
1788       if (INTVAL (operands[2]) == -1)
1789         {
1790           CC_STATUS_INIT;
1791           mvs_check_page (0, 2, 0);
1792           return \"BCTR %0,0\";
1793         }
1794       mvs_check_page (0, 4, 0);
1795       return \"AH       %0,%H2\";
1796     }
1797   mvs_check_page (0, 4, 0);
1798   return \"AH   %0,%2\";
1799 }")
1800
1801 ;
1802 ; addqi3 instruction pattern(s).
1803 ;
1804
1805 (define_insn "addqi3"
1806   [(set (match_operand:QI 0 "general_operand" "=d")
1807         (plus:QI (match_operand:QI 1 "general_operand" "%a")
1808                  (match_operand:QI 2 "general_operand" "ai")))]
1809   ""
1810   "*
1811 {
1812   check_label_emit ();
1813   CC_STATUS_INIT;
1814   mvs_check_page (0, 4, 0);
1815   if (REG_P (operands[2]))
1816     return \"LA %0,0(%1,%2)\";
1817   return \"LA   %0,%B2(,%1)\";
1818 }")
1819
1820 ;
1821 ; adddf3 instruction pattern(s).
1822 ;
1823
1824 (define_insn "adddf3"
1825   [(set (match_operand:DF 0 "general_operand" "=f")
1826         (plus:DF (match_operand:DF 1 "general_operand" "%0")
1827                  (match_operand:DF 2 "general_operand" "fmF")))]
1828   ""
1829   "*
1830 {
1831   check_label_emit ();
1832   if (FP_REG_P (operands[2]))
1833     {
1834       mvs_check_page (0, 2, 0);
1835       return \"ADR      %0,%2\";
1836     }
1837   mvs_check_page (0, 4, 0);
1838   return \"AD   %0,%2\";
1839 }")
1840
1841 ;
1842 ; addsf3 instruction pattern(s).
1843 ;
1844
1845 (define_insn "addsf3"
1846   [(set (match_operand:SF 0 "general_operand" "=f")
1847         (plus:SF (match_operand:SF 1 "general_operand" "%0")
1848                  (match_operand:SF 2 "general_operand" "fmF")))]
1849   ""
1850   "*
1851 {
1852   check_label_emit ();
1853   if (FP_REG_P (operands[2]))
1854     {
1855       mvs_check_page (0, 2, 0);
1856       return \"AER      %0,%2\";
1857     }
1858   mvs_check_page (0, 4, 0);
1859   return \"AE   %0,%2\";
1860 }")
1861
1862 ;;
1863 ;;- Subtract instructions.
1864 ;;
1865
1866 ;
1867 ; subdi3 instruction pattern(s).
1868 ;
1869
1870 (define_expand "subdi3"
1871   [(set (match_operand:DI 0 "general_operand" "")
1872         (minus:DI (match_operand:DI 1 "general_operand" "")
1873                   (match_operand:DI 2 "general_operand" "")))]
1874   ""
1875   "
1876 {
1877   rtx label = gen_label_rtx ();
1878   rtx op0_high = operand_subword (operands[0], 0, 1, DImode);
1879   rtx op0_low = gen_lowpart (SImode, operands[0]);
1880
1881   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1882                     gen_rtx (MINUS, SImode,
1883                               operand_subword (operands[1], 0, 1, DImode),
1884                               operand_subword (operands[2], 0, 1, DImode))));
1885   emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
1886                     gen_rtx (SET, VOIDmode, op0_low,
1887                               gen_rtx (MINUS, SImode,
1888                                       gen_lowpart (SImode, operands[1]),
1889                                       gen_lowpart (SImode, operands[2]))),
1890                     gen_rtx (USE, VOIDmode,
1891                               gen_rtx (LABEL_REF, VOIDmode, label)))));
1892   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1893                       gen_rtx (MINUS, SImode, op0_high,
1894                               gen_rtx (CONST_INT, SImode, 1))));
1895   emit_label (label);
1896   DONE;
1897 }")
1898
1899 (define_insn ""
1900   [(set (match_operand:SI 0 "general_operand" "=d")
1901         (minus:SI (match_operand:SI 1 "general_operand" "0")
1902                   (match_operand:SI 2 "general_operand" "g")))
1903    (use (label_ref (match_operand 3 "" "")))]
1904   ""
1905   "*
1906 {
1907   int onpage;
1908
1909   check_label_emit ();
1910   CC_STATUS_INIT;
1911   onpage = mvs_check_label (CODE_LABEL_NUMBER (operands[3]));
1912   if (REG_P (operands[2]))
1913     {
1914       if (!onpage)
1915         {
1916           mvs_check_page (0, 8, 4);
1917           return \"SLR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1918         }
1919       if (mvs_check_page (0, 6, 0))
1920         {
1921           mvs_check_page (0, 2, 4);
1922           return \"SLR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1923         }
1924       return \"SLR      %0,%2\;BC       12,%l3\";
1925     }
1926   if (!onpage)
1927     {
1928       mvs_check_page (0, 10, 4);
1929       return \"SL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1930     }
1931   if (mvs_check_page (0, 8, 0))
1932     {
1933       mvs_check_page (0, 2, 4);
1934       return \"SL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1935     }
1936   return \"SL   %0,%2\;BC       12,%l3\";
1937 }")
1938
1939 ;
1940 ; subsi3 instruction pattern(s).
1941 ;
1942
1943 (define_insn "subsi3"
1944   [(set (match_operand:SI 0 "general_operand" "=d")
1945         (minus:SI (match_operand:SI 1 "general_operand" "0")
1946                   (match_operand:SI 2 "general_operand" "g")))]
1947   ""
1948   "*
1949 {
1950   check_label_emit ();
1951   if (REG_P (operands[2]))
1952     {
1953       mvs_check_page (0, 2, 0);
1954       return \"SR       %0,%2\";
1955     }
1956   if (operands[2] == const1_rtx)
1957     {
1958       CC_STATUS_INIT;
1959       mvs_check_page (0, 2, 0);
1960       return \"BCTR     %0,0\";
1961     }
1962   mvs_check_page (0, 4, 0);
1963   return \"S    %0,%2\";
1964 }")
1965
1966 ;
1967 ; subhi3 instruction pattern(s).
1968 ;
1969
1970 (define_insn "subhi3"
1971   [(set (match_operand:HI 0 "general_operand" "=d")
1972         (minus:HI (match_operand:HI 1 "general_operand" "0")
1973                   (match_operand:HI 2 "general_operand" "g")))]
1974   ""
1975   "*
1976 {
1977   check_label_emit ();
1978   if (REG_P (operands[2]))
1979     {
1980       mvs_check_page (0, 8, 0);
1981       return \"STH      %2,140(,13)\;SH %0,140(,13)\";
1982     }
1983   if (operands[2] == const1_rtx)
1984     {
1985       CC_STATUS_INIT;
1986       mvs_check_page (0, 2, 0);
1987       return \"BCTR     %0,0\";
1988     }
1989   if (GET_CODE (operands[2]) == CONST_INT)
1990     {
1991       mvs_check_page (0, 4, 0);
1992       return \"SH       %0,%H2\";
1993     }
1994   mvs_check_page (0, 4, 0);
1995   return \"SH   %0,%2\";
1996 }")
1997
1998 ;
1999 ; subqi3 instruction pattern(s).
2000 ;
2001
2002 (define_expand "subqi3"
2003   [(set (match_operand:QI 0 "general_operand" "=d")
2004         (minus:QI (match_operand:QI 1 "general_operand" "0")
2005                   (match_operand:QI 2 "general_operand" "di")))]
2006   ""
2007   "
2008 {
2009   if (REG_P (operands[2]))
2010     {
2011       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2012                         gen_rtx (MINUS, QImode, operands[1], operands[2])));
2013     }
2014   else
2015     {
2016       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2017                         gen_rtx (PLUS, QImode, operands[1],
2018                                  negate_rtx (QImode, operands[2]))));
2019     }
2020   DONE;
2021 }")
2022
2023 (define_insn ""
2024   [(set (match_operand:QI 0 "register_operand" "=d")
2025         (minus:QI (match_operand:QI 1 "register_operand" "0")
2026                  (match_operand:QI 2 "register_operand" "d")))]
2027   ""
2028   "*
2029 {
2030   check_label_emit ();
2031   CC_STATUS_INIT;
2032   mvs_check_page (0, 2, 0);
2033   return \"SR   %0,%2\";
2034 }")
2035
2036 ;
2037 ; subdf3 instruction pattern(s).
2038 ;
2039
2040 (define_insn "subdf3"
2041   [(set (match_operand:DF 0 "general_operand" "=f")
2042         (minus:DF (match_operand:DF 1 "general_operand" "0")
2043                   (match_operand:DF 2 "general_operand" "fmF")))]
2044   ""
2045   "*
2046 {
2047   check_label_emit ();
2048   if (FP_REG_P (operands[2]))
2049     {
2050       mvs_check_page (0, 2, 0);
2051       return \"SDR      %0,%2\";
2052     }
2053   mvs_check_page (0, 4, 0);
2054   return \"SD   %0,%2\";
2055 }")
2056
2057 ;
2058 ; subsf3 instruction pattern(s).
2059 ;
2060
2061 (define_insn "subsf3"
2062   [(set (match_operand:SF 0 "general_operand" "=f")
2063         (minus:SF (match_operand:SF 1 "general_operand" "0")
2064                   (match_operand:SF 2 "general_operand" "fmF")))]
2065   ""
2066   "*
2067 {
2068   check_label_emit ();
2069   if (FP_REG_P (operands[2]))
2070     {
2071       mvs_check_page (0, 2, 0);
2072       return \"SER      %0,%2\";
2073     }
2074   mvs_check_page (0, 4, 0);
2075   return \"SE   %0,%2\";
2076 }")
2077
2078 ;;
2079 ;;- Multiply instructions.
2080 ;;
2081
2082 ;
2083 ; mulsi3 instruction pattern(s).
2084 ;
2085
2086 (define_expand "mulsi3"
2087   [(set (match_operand:SI 0 "general_operand" "")
2088         (mult:SI (match_operand:SI 1 "general_operand" "")
2089                  (match_operand:SI 2 "general_operand" "")))]
2090   ""
2091   "
2092 {
2093   if (GET_CODE (operands[1]) == CONST_INT
2094       && CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'K'))
2095     {
2096       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2097                           gen_rtx (MULT, SImode, operands[2], operands[1])));
2098     }
2099   else if (GET_CODE (operands[2]) == CONST_INT
2100            && CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
2101     {
2102       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2103                           gen_rtx (MULT, SImode, operands[1], operands[2])));
2104     }
2105   else
2106     {
2107       rtx r = gen_reg_rtx (DImode);
2108
2109       emit_insn (gen_rtx (SET, VOIDmode,
2110                           gen_rtx (SUBREG, SImode, r, 1), operands[1]));
2111       emit_insn (gen_rtx (SET, VOIDmode, r,
2112                           gen_rtx (MULT, SImode, r, operands[2])));
2113       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2114                           gen_rtx (SUBREG, SImode, r, 1)));
2115     }
2116   DONE;
2117 }")
2118
2119 (define_insn ""
2120   [(set (match_operand:SI 0 "register_operand" "=d")
2121         (mult:SI (match_operand:SI 1 "general_operand" "%0")
2122                  (match_operand:SI 2 "immediate_operand" "K")))]
2123   ""
2124   "*
2125 {
2126   check_label_emit ();
2127   mvs_check_page (0, 4, 0);
2128   return \"MH   %0,%H2\";
2129 }")
2130
2131 (define_insn ""
2132   [(set (match_operand:DI 0 "register_operand" "=d")
2133         (mult:SI (match_operand:DI 1 "general_operand" "%0")
2134                  (match_operand:SI 2 "general_operand" "g")))]
2135   ""
2136   "*
2137 {
2138   check_label_emit ();
2139   if (REG_P (operands[2]))
2140     {
2141       mvs_check_page (0, 2, 0);
2142       return \"MR       %0,%2\";
2143     }
2144   mvs_check_page (0, 4, 0);
2145   return \"M    %0,%2\";
2146 }")
2147
2148 ;
2149 ; muldf3 instruction pattern(s).
2150 ;
2151
2152 (define_insn "muldf3"
2153   [(set (match_operand:DF 0 "general_operand" "=f")
2154         (mult:DF (match_operand:DF 1 "general_operand" "%0")
2155                  (match_operand:DF 2 "general_operand" "fmF")))]
2156   ""
2157   "*
2158 {
2159   check_label_emit ();
2160   if (FP_REG_P (operands[2]))
2161     {
2162       mvs_check_page (0, 2, 0);
2163       return \"MDR      %0,%2\";
2164     }
2165   mvs_check_page (0, 4, 0);
2166   return \"MD   %0,%2\";
2167 }")
2168
2169 ;
2170 ; mulsf3 instruction pattern(s).
2171 ;
2172
2173 (define_insn "mulsf3"
2174   [(set (match_operand:SF 0 "general_operand" "=f")
2175         (mult:SF (match_operand:SF 1 "general_operand" "%0")
2176                  (match_operand:SF 2 "general_operand" "fmF")))]
2177   ""
2178   "*
2179 {
2180   check_label_emit ();
2181   if (FP_REG_P (operands[2]))
2182     {
2183       mvs_check_page (0, 2, 0);
2184       return \"MER      %0,%2\";
2185     }
2186   mvs_check_page (0, 4, 0);
2187   return \"ME   %0,%2\";
2188 }")
2189
2190 ;;
2191 ;;- Divide instructions.
2192 ;;
2193
2194 ;
2195 ; divsi3 instruction pattern(s).
2196 ;
2197
2198 (define_expand "divsi3"
2199   [(set (match_operand:SI 0 "general_operand" "")
2200         (div:SI (match_operand:SI 1 "general_operand" "")
2201                 (match_operand:SI 2 "general_operand" "")))]
2202   ""
2203   "
2204 {
2205   rtx r = gen_reg_rtx (DImode);
2206
2207   emit_insn (gen_extendsidi2 (r, operands[1]));
2208   emit_insn (gen_rtx (SET, VOIDmode, r,
2209                         gen_rtx (DIV, SImode, r, operands[2])));
2210   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2211                         gen_rtx (SUBREG, SImode, r, 1)));
2212   DONE;
2213 }")
2214
2215
2216 ;
2217 ; udivsi3 instruction pattern(s).
2218 ;
2219
2220 (define_expand "udivsi3"
2221   [(set (match_operand:SI 0 "general_operand" "")
2222         (udiv:SI (match_operand:SI 1 "general_operand" "")
2223                  (match_operand:SI 2 "general_operand" "")))]
2224   ""
2225   "
2226 {
2227   rtx dr = gen_reg_rtx (DImode);
2228   rtx dr_0 = gen_rtx (SUBREG, SImode, dr, 0);
2229   rtx dr_1 = gen_rtx (SUBREG, SImode, dr, 1);
2230
2231
2232   if (GET_CODE (operands[2]) == CONST_INT)
2233     {
2234       if (INTVAL (operands[2]) > 0)
2235         {
2236           emit_insn (gen_zero_extendsidi2 (dr, operands[1]));
2237           emit_insn (gen_rtx (SET, VOIDmode, dr,
2238                         gen_rtx (DIV, SImode, dr, operands[2])));
2239         }
2240       else
2241         {
2242           rtx label1 = gen_label_rtx ();
2243
2244           emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2245           emit_insn (gen_rtx (SET, VOIDmode, dr_1, const0_rtx));
2246           emit_insn (gen_cmpsi (dr_0, operands[2]));
2247           emit_jump_insn (gen_bltu (label1));
2248           emit_insn (gen_rtx (SET, VOIDmode, dr_1, const1_rtx));
2249           emit_label (label1);
2250         }
2251     }
2252   else
2253     {
2254       rtx label1 = gen_label_rtx ();
2255       rtx label2 = gen_label_rtx ();
2256       rtx label3 = gen_label_rtx ();
2257       rtx sr = gen_reg_rtx (SImode);
2258
2259       emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2260       emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2261       emit_insn (gen_rtx (SET, VOIDmode, dr_1, const0_rtx));
2262       emit_insn (gen_cmpsi (sr, dr_0));
2263       emit_jump_insn (gen_bgtu (label3));
2264       emit_insn (gen_cmpsi (sr, const1_rtx));
2265       emit_jump_insn (gen_blt (label2));
2266       emit_jump_insn (gen_beq (label1));
2267       emit_insn (gen_rtx (SET, VOIDmode, dr,
2268                           gen_rtx (LSHIFTRT, DImode, dr,
2269                                     gen_rtx (CONST_INT, SImode, 32))));
2270       emit_insn (gen_rtx (SET, VOIDmode, dr,
2271                     gen_rtx (DIV, SImode, dr, sr)));
2272       emit_jump_insn (gen_jump (label3));
2273       emit_label (label1);
2274       emit_insn (gen_rtx (SET, VOIDmode, dr_1, dr_0));
2275       emit_jump_insn (gen_jump (label3));
2276       emit_label (label2);
2277       emit_insn (gen_rtx (SET, VOIDmode, dr_1, const1_rtx));
2278       emit_label (label3);
2279     }
2280   emit_insn (gen_rtx (SET, VOIDmode, operands[0], dr_1));
2281
2282   DONE;
2283 }")
2284
2285 ; This is used by divsi3 & udivsi3.
2286
2287 (define_insn ""
2288   [(set (match_operand:DI 0 "register_operand" "=d")
2289         (div:SI (match_operand:DI 1 "register_operand" "0")
2290                 (match_operand:SI 2 "general_operand" "")))]
2291   ""
2292   "*
2293 {
2294   check_label_emit ();
2295   if (REG_P (operands[2]))
2296     {
2297       mvs_check_page (0, 2, 0);
2298       return \"DR       %0,%2\";
2299     }
2300   mvs_check_page (0, 4, 0);
2301   return \"D    %0,%2\";
2302 }")
2303
2304 ;
2305 ; divdf3 instruction pattern(s).
2306 ;
2307
2308 (define_insn "divdf3"
2309   [(set (match_operand:DF 0 "general_operand" "=f")
2310         (div:DF (match_operand:DF 1 "general_operand" "0")
2311                 (match_operand:DF 2 "general_operand" "fmF")))]
2312   ""
2313   "*
2314 {
2315   check_label_emit ();
2316   if (FP_REG_P (operands[2]))
2317     {
2318       mvs_check_page (0, 2, 0);
2319       return \"DDR      %0,%2\";
2320     }
2321   mvs_check_page (0, 4, 0);
2322   return \"DD   %0,%2\";
2323 }")
2324
2325 ;
2326 ; divsf3 instruction pattern(s).
2327 ;
2328
2329 (define_insn "divsf3"
2330   [(set (match_operand:SF 0 "general_operand" "=f")
2331         (div:SF (match_operand:SF 1 "general_operand" "0")
2332                 (match_operand:SF 2 "general_operand" "fmF")))]
2333   ""
2334   "*
2335 {
2336   check_label_emit ();
2337   if (FP_REG_P (operands[2]))
2338     {
2339       mvs_check_page (0, 2, 0);
2340       return \"DER      %0,%2\";
2341     }
2342   mvs_check_page (0, 4, 0);
2343   return \"DE   %0,%2\";
2344 }")
2345
2346 ;;
2347 ;;- Modulo instructions.
2348 ;;
2349
2350 ;
2351 ; modsi3 instruction pattern(s).
2352 ;
2353
2354 (define_expand "modsi3"
2355   [(set (match_operand:SI 0 "general_operand" "")
2356         (mod:SI (match_operand:SI 1 "general_operand" "")
2357                 (match_operand:SI 2 "general_operand" "")))]
2358   ""
2359   "
2360 {
2361   rtx r = gen_reg_rtx (DImode);
2362
2363   emit_insn (gen_extendsidi2 (r, operands[1]));
2364   emit_insn (gen_rtx (SET, VOIDmode, r,
2365                         gen_rtx (MOD, SImode, r, operands[2])));
2366   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2367                         gen_rtx (SUBREG, SImode, r, 0)));
2368   DONE;
2369 }")
2370
2371 ;
2372 ; umodsi3 instruction pattern(s).
2373 ;
2374
2375 (define_expand "umodsi3"
2376   [(set (match_operand:SI 0 "general_operand" "")
2377         (umod:SI (match_operand:SI 1 "general_operand" "")
2378                  (match_operand:SI 2 "general_operand" "")))]
2379   ""
2380   "
2381 {
2382   rtx dr = gen_reg_rtx (DImode);
2383   rtx dr_0 = gen_rtx (SUBREG, SImode, dr, 0);
2384   rtx dr_1 = gen_rtx (SUBREG, SImode, dr, 1);
2385
2386   emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2387
2388   if (GET_CODE (operands[2]) == CONST_INT)
2389     {
2390       if (INTVAL (operands[2]) > 0)
2391         {
2392           emit_insn (gen_rtx (SET, VOIDmode, dr,
2393                               gen_rtx (LSHIFTRT, DImode, dr,
2394                                         gen_rtx (CONST_INT, SImode, 32))));
2395           emit_insn (gen_rtx (SET, VOIDmode, dr,
2396                         gen_rtx (MOD, SImode, dr, operands[2])));
2397         }
2398       else
2399         {
2400           rtx label1 = gen_label_rtx ();
2401           rtx sr = gen_reg_rtx (SImode);
2402
2403           emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2404           emit_insn (gen_cmpsi (dr_0, sr));
2405           emit_jump_insn (gen_bltu (label1));
2406           emit_insn (gen_rtx (SET, VOIDmode, sr, gen_rtx (ABS, SImode, sr)));
2407           emit_insn (gen_rtx (SET, VOIDmode, dr_0,
2408                               gen_rtx (PLUS, SImode, dr_0, sr)));
2409           emit_label (label1);
2410         }
2411     }
2412   else
2413     {
2414       rtx label1 = gen_label_rtx ();
2415       rtx label2 = gen_label_rtx ();
2416       rtx label3 = gen_label_rtx ();
2417       rtx sr = gen_reg_rtx (SImode);
2418
2419       emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2420       emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2421       emit_insn (gen_cmpsi (sr, dr_0));
2422       emit_jump_insn (gen_bgtu (label3));
2423       emit_insn (gen_cmpsi (sr, const1_rtx));
2424       emit_jump_insn (gen_blt (label2));
2425       emit_jump_insn (gen_beq (label1));
2426       emit_insn (gen_rtx (SET, VOIDmode, dr,
2427                           gen_rtx (LSHIFTRT, DImode, dr,
2428                                     gen_rtx (CONST_INT, SImode, 32))));
2429       emit_insn (gen_rtx (SET, VOIDmode, dr, gen_rtx (MOD, SImode, dr, sr)));
2430       emit_jump_insn (gen_jump (label3));
2431       emit_label (label1);
2432       emit_insn (gen_rtx (SET, VOIDmode, dr_0, const0_rtx));
2433       emit_jump_insn (gen_jump (label3));
2434       emit_label (label2);
2435       emit_insn (gen_rtx (SET, VOIDmode, dr_0,
2436                           gen_rtx (MINUS, SImode, dr_0, sr)));
2437       emit_label (label3);
2438
2439     }
2440   emit_insn (gen_rtx (SET, VOIDmode, operands[0], dr_0));
2441
2442   DONE;
2443 }")
2444
2445 ; This is used by modsi3 & umodsi3.
2446
2447 (define_insn ""
2448   [(set (match_operand:DI 0 "register_operand" "=d")
2449         (mod:SI (match_operand:DI 1 "register_operand" "0")
2450                 (match_operand:SI 2 "general_operand" "")))]
2451   ""
2452   "*
2453 {
2454   check_label_emit ();
2455   if (REG_P (operands[2]))
2456     {
2457       mvs_check_page (0, 2, 0);
2458       return \"DR       %0,%2\";
2459     }
2460   mvs_check_page (0, 4, 0);
2461   return \"D    %0,%2\";
2462 }")
2463
2464 ;;
2465 ;;- And instructions.
2466 ;;
2467
2468 ;
2469 ; anddi3 instruction pattern(s).
2470 ;
2471
2472 ;(define_expand "anddi3"
2473 ;  [(set (match_operand:DI 0 "general_operand" "")
2474 ;       (and:DI (match_operand:DI 1 "general_operand" "")
2475 ;               (match_operand:DI 2 "general_operand" "")))]
2476 ;  ""
2477 ;  "
2478 ;{
2479 ;  rtx gen_andsi3();
2480 ;
2481 ;  emit_insn (gen_andsi3 (operand_subword (operands[0], 0, 1, DImode),
2482 ;                        operand_subword (operands[1], 0, 1, DImode),
2483 ;                        operand_subword (operands[2], 0, 1, DImode)));
2484 ;  emit_insn (gen_andsi3 (gen_lowpart (SImode, operands[0]),
2485 ;                        gen_lowpart (SImode, operands[1]),
2486 ;                        gen_lowpart (SImode, operands[2])));
2487 ;  DONE;
2488 ;}")
2489
2490 ;
2491 ; andsi3 instruction pattern(s).
2492 ;
2493
2494 (define_insn ""
2495   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2496         (and:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2497                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2498   "TARGET_CHAR_INSTRUCTIONS"
2499   "*
2500 {
2501   check_label_emit ();
2502   if (REG_P (operands[2]))
2503     {
2504       mvs_check_page (0, 2, 0);
2505       return \"NR       %0,%2\";
2506     }
2507   if (REG_P (operands[0]))
2508     {
2509       mvs_check_page (0, 4, 0);
2510       return \"N        %0,%2\";
2511     }
2512   CC_STATUS_INIT;
2513   mvs_check_page (0, 6, 0);
2514   return \"NC   %O0(4,%R0),%2\";
2515 }")
2516
2517 (define_insn "andsi3"
2518   [(set (match_operand:SI 0 "general_operand" "=d")
2519         (and:SI (match_operand:SI 1 "general_operand" "%0")
2520                 (match_operand:SI 2 "general_operand" "g")))]
2521   ""
2522   "*
2523 {
2524   check_label_emit ();
2525   if (REG_P (operands[2]))
2526     {
2527       mvs_check_page (0, 2, 0);
2528       return \"NR       %0,%2\";
2529     }
2530   mvs_check_page (0, 4, 0);
2531   return \"N    %0,%2\";
2532 }")
2533
2534 ;
2535 ; andhi3 instruction pattern(s).
2536 ;
2537
2538 (define_insn ""
2539   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2540         (and:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2541                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2542   "TARGET_CHAR_INSTRUCTIONS"
2543   "*
2544 {
2545   check_label_emit ();
2546   if (REG_P (operands[2]))
2547     {
2548       mvs_check_page (0, 2, 0);
2549       return \"NR       %0,%2\";
2550     }
2551   if (REG_P (operands[0]))
2552     {
2553       mvs_check_page (0, 4, 0);
2554       return \"N        %0,%2\";
2555     }
2556   CC_STATUS_INIT;
2557   if (GET_CODE (operands[2]) == CONST_INT)
2558     {
2559       mvs_check_page (0, 6, 0);
2560       return \"NC       %O0(2,%R0),%H2\";
2561     }
2562   mvs_check_page (0, 6, 0);
2563   return \"NC   %O0(2,%R0),%2\";
2564 }")
2565
2566 (define_insn "andhi3"
2567   [(set (match_operand:HI 0 "general_operand" "=d")
2568         (and:HI (match_operand:HI 1 "general_operand" "%0")
2569                 (match_operand:HI 2 "general_operand" "di")))]
2570   ""
2571   "*
2572 {
2573   check_label_emit ();
2574   if (GET_CODE (operands[2]) == CONST_INT)
2575     {
2576       mvs_check_page (0, 4, 0);
2577       return \"N        %0,%2\";
2578     }
2579   mvs_check_page (0, 2, 0);
2580   return \"NR   %0,%2\";
2581 }")
2582
2583 ;
2584 ; andqi3 instruction pattern(s).
2585 ;
2586
2587 (define_insn ""
2588   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2589         (and:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2590                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2591   "TARGET_CHAR_INSTRUCTIONS"
2592   "*
2593 {
2594   check_label_emit ();
2595   CC_STATUS_INIT;
2596   if (REG_P (operands[2]))
2597     {
2598       mvs_check_page (0, 2, 0);
2599       return \"NR       %0,%2\";
2600     }
2601   if (REG_P (operands[0]))
2602     {
2603       mvs_check_page (0, 4, 0);
2604       return \"N        %0,%2\";
2605     }
2606   if (GET_CODE (operands[2]) == CONST_INT)
2607     {
2608       mvs_check_page (0, 4, 0);
2609       return \"NI       %0,%B2\";
2610     }
2611   mvs_check_page (0, 6, 0);
2612   return \"NC   %O0(1,%R0),%2\";
2613 }")
2614
2615 (define_insn "andqi3"
2616   [(set (match_operand:QI 0 "general_operand" "=d")
2617         (and:QI (match_operand:QI 1 "general_operand" "%0")
2618                 (match_operand:QI 2 "general_operand" "di")))]
2619   ""
2620   "*
2621 {
2622   check_label_emit ();
2623   CC_STATUS_INIT;
2624   if (GET_CODE (operands[2]) == CONST_INT)
2625     {
2626       mvs_check_page (0, 4, 0);
2627       return \"N        %0,%2\";
2628     }
2629   mvs_check_page (0, 2, 0);
2630   return \"NR   %0,%2\";
2631 }")
2632
2633 ;;
2634 ;;- Bit set (inclusive or) instructions.
2635 ;;
2636
2637 ;
2638 ; iordi3 instruction pattern(s).
2639 ;
2640
2641 ;(define_expand "iordi3"
2642 ;  [(set (match_operand:DI 0 "general_operand" "")
2643 ;       (ior:DI (match_operand:DI 1 "general_operand" "")
2644 ;               (match_operand:DI 2 "general_operand" "")))]
2645 ;  ""
2646 ;  "
2647 ;{
2648 ;  rtx gen_iorsi3();
2649 ;
2650 ;  emit_insn (gen_iorsi3 (operand_subword (operands[0], 0, 1, DImode),
2651 ;                        operand_subword (operands[1], 0, 1, DImode),
2652 ;                        operand_subword (operands[2], 0, 1, DImode)));
2653 ;  emit_insn (gen_iorsi3 (gen_lowpart (SImode, operands[0]),
2654 ;                        gen_lowpart (SImode, operands[1]),
2655 ;                        gen_lowpart (SImode, operands[2])));
2656 ;  DONE;
2657 ;}")
2658
2659 ;
2660 ; iorsi3 instruction pattern(s).
2661 ;
2662
2663 (define_insn ""
2664   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2665         (ior:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2666                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2667   "TARGET_CHAR_INSTRUCTIONS"
2668   "*
2669 {
2670   check_label_emit ();
2671   if (REG_P (operands[2]))
2672     {
2673       mvs_check_page (0, 2, 0);
2674       return \"OR       %0,%2\";
2675     }
2676   if (REG_P (operands[0]))
2677     {
2678       mvs_check_page (0, 4, 0);
2679       return \"O        %0,%2\";
2680     }
2681   CC_STATUS_INIT;
2682   mvs_check_page (0, 6, 0);
2683   return \"OC   %O0(4,%R0),%2\";
2684 }")
2685
2686 (define_insn "iorsi3"
2687   [(set (match_operand:SI 0 "general_operand" "=d")
2688         (ior:SI (match_operand:SI 1 "general_operand" "%0")
2689                 (match_operand:SI 2 "general_operand" "g")))]
2690   ""
2691   "*
2692 {
2693   check_label_emit ();
2694   if (REG_P (operands[2]))
2695     {
2696       mvs_check_page (0, 2, 0);
2697       return \"OR       %0,%2\";
2698     }
2699   mvs_check_page (0, 4, 0);
2700   return \"O    %0,%2\";
2701 }")
2702
2703 ;
2704 ; iorhi3 instruction pattern(s).
2705 ;
2706
2707 (define_insn ""
2708   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2709         (ior:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2710                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2711   "TARGET_CHAR_INSTRUCTIONS"
2712   "*
2713 {
2714   check_label_emit ();
2715   if (REG_P (operands[2]))
2716     {
2717       mvs_check_page (0, 2, 0);
2718       return \"OR       %0,%2\";
2719     }
2720   if (REG_P (operands[0]))
2721     {
2722       mvs_check_page (0, 4, 0);
2723       return \"O        %0,%2\";
2724     }
2725   CC_STATUS_INIT;
2726   if (GET_CODE (operands[2]) == CONST_INT)
2727     {
2728       mvs_check_page (0, 6, 0);
2729       return \"OC       %O0(2,%R0),%H2\";
2730     }
2731   mvs_check_page (0, 6, 0);
2732   return \"OC   %O0(2,%R0),%2\";
2733 }")
2734
2735 (define_insn "iorhi3"
2736   [(set (match_operand:HI 0 "general_operand" "=d")
2737         (ior:HI (match_operand:HI 1 "general_operand" "%0")
2738                 (match_operand:HI 2 "general_operand" "di")))]
2739   ""
2740   "*
2741 {
2742   check_label_emit ();
2743   if (GET_CODE (operands[2]) == CONST_INT)
2744     {
2745       mvs_check_page (0, 4, 0);
2746       return \"O        %0,%2\";
2747     }
2748   mvs_check_page (0, 2, 0);
2749   return \"OR   %0,%2\";
2750 }")
2751
2752 ;
2753 ; iorqi3 instruction pattern(s).
2754 ;
2755
2756 (define_insn ""
2757   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2758         (ior:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2759                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2760   "TARGET_CHAR_INSTRUCTIONS"
2761   "*
2762 {
2763   check_label_emit ();
2764   CC_STATUS_INIT;
2765   if (REG_P (operands[2]))
2766     {
2767       mvs_check_page (0, 2, 0);
2768       return \"OR       %0,%2\";
2769     }
2770   if (REG_P (operands[0]))
2771     {
2772       mvs_check_page (0, 4, 0);
2773       return \"O        %0,%2\";
2774     }
2775   CC_STATUS_INIT;
2776   if (GET_CODE (operands[2]) == CONST_INT)
2777     {
2778       mvs_check_page (0, 4, 0);
2779       return \"OI       %0,%B2\";
2780     }
2781   mvs_check_page (0, 6, 0);
2782   return \"OC   %O0(1,%R0),%2\";
2783 }")
2784
2785 (define_insn "iorqi3"
2786   [(set (match_operand:QI 0 "general_operand" "=d")
2787         (ior:QI (match_operand:QI 1 "general_operand" "%0")
2788                 (match_operand:QI 2 "general_operand" "di")))]
2789   ""
2790   "*
2791 {
2792   check_label_emit ();
2793   CC_STATUS_INIT;
2794   if (GET_CODE (operands[2]) == CONST_INT)
2795     {
2796       mvs_check_page (0, 4, 0);
2797       return \"O        %0,%2\";
2798     }
2799   mvs_check_page (0, 2, 0);
2800   return \"OR   %0,%2\";
2801 }")
2802
2803 ;;
2804 ;;- Xor instructions.
2805 ;;
2806
2807 ;
2808 ; xordi3 instruction pattern(s).
2809 ;
2810
2811 ;(define_expand "xordi3"
2812 ;  [(set (match_operand:DI 0 "general_operand" "")
2813 ;       (xor:DI (match_operand:DI 1 "general_operand" "")
2814 ;               (match_operand:DI 2 "general_operand" "")))]
2815 ;  ""
2816 ;  "
2817 ;{
2818 ;  rtx gen_xorsi3();
2819 ;
2820 ;  emit_insn (gen_xorsi3 (operand_subword (operands[0], 0, 1, DImode),
2821 ;                        operand_subword (operands[1], 0, 1, DImode),
2822 ;                        operand_subword (operands[2], 0, 1, DImode)));
2823 ;  emit_insn (gen_xorsi3 (gen_lowpart (SImode, operands[0]),
2824 ;                        gen_lowpart (SImode, operands[1]),
2825 ;                        gen_lowpart (SImode, operands[2])));
2826 ;  DONE;
2827 ;}")
2828
2829 ;
2830 ; xorsi3 instruction pattern(s).
2831 ;
2832
2833 (define_insn ""
2834   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2835         (xor:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2836                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2837   "TARGET_CHAR_INSTRUCTIONS"
2838   "*
2839 {
2840   check_label_emit ();
2841   if (REG_P (operands[2]))
2842     {
2843       mvs_check_page (0, 2, 0);
2844       return \"XR       %0,%2\";
2845     }
2846   if (REG_P (operands[0]))
2847     {
2848       mvs_check_page (0, 4, 0);
2849       return \"X        %0,%2\";
2850     }
2851   CC_STATUS_INIT;
2852   mvs_check_page (0, 6, 0);
2853   return \"XC   %O0(4,%R0),%2\";
2854 }")
2855
2856 (define_insn "xorsi3"
2857   [(set (match_operand:SI 0 "general_operand" "=d")
2858         (xor:SI (match_operand:SI 1 "general_operand" "%0")
2859                 (match_operand:SI 2 "general_operand" "g")))]
2860   ""
2861   "*
2862 {
2863   check_label_emit ();
2864   if (REG_P (operands[2]))
2865     {
2866       mvs_check_page (0, 2, 0);
2867       return \"XR       %0,%2\";
2868     }
2869   mvs_check_page (0, 4, 0);
2870   return \"X    %0,%2\";
2871 }")
2872
2873 ;
2874 ; xorhi3 instruction pattern(s).
2875 ;
2876
2877 (define_insn ""
2878   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2879         (xor:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2880                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2881   "TARGET_CHAR_INSTRUCTIONS"
2882   "*
2883 {
2884   check_label_emit ();
2885   if (REG_P (operands[2]))
2886     {
2887       mvs_check_page (0, 2, 0);
2888       return \"XR       %0,%2\";
2889     }
2890   if (REG_P (operands[0]))
2891     {
2892       mvs_check_page (0, 4, 0);
2893       return \"X        %0,%2\";
2894     }
2895   CC_STATUS_INIT;
2896   if (GET_CODE (operands[2]) == CONST_INT)
2897     {
2898       mvs_check_page (0, 6, 0);
2899       return \"XC       %O0(2,%R0),%H2\";
2900     }
2901   mvs_check_page (0, 6, 0);
2902   return \"XC   %O0(2,%R0),%2\";
2903 }")
2904
2905 (define_insn "xorhi3"
2906   [(set (match_operand:HI 0 "general_operand" "=d")
2907         (xor:HI (match_operand:HI 1 "general_operand" "%0")
2908                 (match_operand:HI 2 "general_operand" "di")))]
2909   ""
2910   "*
2911 {
2912   check_label_emit ();
2913   if (GET_CODE (operands[2]) == CONST_INT)
2914     {
2915       mvs_check_page (0, 4, 0);
2916       return \"X        %0,%2\";
2917     }
2918   mvs_check_page (0, 2, 0);
2919   return \"XR   %0,%2\";
2920 }")
2921
2922 ;
2923 ; xorqi3 instruction pattern(s).
2924 ;
2925
2926 (define_insn ""
2927   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2928         (xor:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2929                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2930   "TARGET_CHAR_INSTRUCTIONS"
2931   "*
2932 {
2933   check_label_emit ();
2934   CC_STATUS_INIT;
2935   if (REG_P (operands[2]))
2936     {
2937       mvs_check_page (0, 2, 0);
2938       return \"XR       %0,%2\";
2939     }
2940   if (REG_P (operands[0]))
2941     {
2942       mvs_check_page (0, 4, 0);
2943       return \"X        %0,%2\";
2944     }
2945   if (GET_CODE (operands[2]) == CONST_INT)
2946     {
2947       mvs_check_page (0, 4, 0);
2948       return \"XI       %0,%B2\";
2949     }
2950   mvs_check_page (0, 6, 0);
2951   return \"XC   %O0(1,%R0),%2\";
2952 }")
2953
2954 (define_insn "xorqi3"
2955   [(set (match_operand:QI 0 "general_operand" "=d")
2956         (xor:QI (match_operand:QI 1 "general_operand" "%0")
2957                 (match_operand:QI 2 "general_operand" "di")))]
2958   ""
2959   "*
2960 {
2961   check_label_emit ();
2962   CC_STATUS_INIT;
2963   if (GET_CODE (operands[2]) == CONST_INT)
2964     {
2965       mvs_check_page (0, 4, 0);
2966       return \"X        %0,%2\";
2967     }
2968   mvs_check_page (0, 2, 0);
2969   return \"XR   %0,%2\";
2970 }")
2971
2972 ;;
2973 ;;- Negate instructions.
2974 ;;
2975
2976 ;
2977 ; negsi2 instruction pattern(s).
2978 ;
2979
2980 (define_insn "negsi2"
2981   [(set (match_operand:SI 0 "general_operand" "=d")
2982         (neg:SI (match_operand:SI 1 "general_operand" "d")))]
2983   ""
2984   "*
2985 {
2986   check_label_emit ();
2987   mvs_check_page (0, 2, 0);
2988   return \"LCR  %0,%1\";
2989 }")
2990
2991 ;
2992 ; neghi2 instruction pattern(s).
2993 ;
2994
2995 (define_insn "neghi2"
2996   [(set (match_operand:HI 0 "general_operand" "=d")
2997         (neg:HI (match_operand:HI 1 "general_operand" "d")))]
2998   ""
2999   "*
3000 {
3001   check_label_emit ();
3002   mvs_check_page (0, 10, 0);
3003   return \"SLL  %1,16\;SRA      %1,16\;LCR      %0,%1\";
3004 }")
3005
3006 ;
3007 ; negdf2 instruction pattern(s).
3008 ;
3009
3010 (define_insn "negdf2"
3011   [(set (match_operand:DF 0 "general_operand" "=f")
3012         (neg:DF (match_operand:DF 1 "general_operand" "f")))]
3013   ""
3014   "*
3015 {
3016   check_label_emit ();
3017   mvs_check_page (0, 2, 0);
3018   return \"LCDR %0,%1\";
3019 }")
3020
3021 ;
3022 ; negsf2 instruction pattern(s).
3023 ;
3024
3025 (define_insn "negsf2"
3026   [(set (match_operand:SF 0 "general_operand" "=f")
3027         (neg:SF (match_operand:SF 1 "general_operand" "f")))]
3028   ""
3029   "*
3030 {
3031   check_label_emit ();
3032   mvs_check_page (0, 2, 0);
3033   return \"LCER %0,%1\";
3034 }")
3035
3036 ;;
3037 ;;- Absolute value instructions.
3038 ;;
3039
3040 ;
3041 ; abssi2 instruction pattern(s).
3042 ;
3043
3044 (define_insn "abssi2"
3045   [(set (match_operand:SI 0 "general_operand" "=d")
3046         (abs:SI (match_operand:SI 1 "general_operand" "d")))]
3047   ""
3048   "*
3049 {
3050   check_label_emit ();
3051   mvs_check_page (0, 2, 0);
3052   return \"LPR  %0,%1\";
3053 }")
3054
3055 ;
3056 ; abshi2 instruction pattern(s).
3057 ;
3058
3059 (define_insn "abshi2"
3060   [(set (match_operand:HI 0 "general_operand" "=d")
3061         (abs:HI (match_operand:HI 1 "general_operand" "d")))]
3062   ""
3063   "*
3064 {
3065   check_label_emit ();
3066   mvs_check_page (0, 10, 0);
3067   return \"SLL  %1,16\;SRA      %1,16\;LPR      %0,%1\";
3068 }")
3069
3070 ;
3071 ; absdf2 instruction pattern(s).
3072 ;
3073
3074 (define_insn "absdf2"
3075   [(set (match_operand:DF 0 "general_operand" "=f")
3076         (abs:DF (match_operand:DF 1 "general_operand" "f")))]
3077   ""
3078   "*
3079 {
3080   check_label_emit ();
3081   mvs_check_page (0, 2, 0);
3082   return \"LPDR %0,%1\";
3083 }")
3084
3085 ;
3086 ; abssf2 instruction pattern(s).
3087 ;
3088
3089 (define_insn "abssf2"
3090   [(set (match_operand:SF 0 "general_operand" "=f")
3091         (abs:SF (match_operand:SF 1 "general_operand" "f")))]
3092   ""
3093   "*
3094 {
3095   check_label_emit ();
3096   mvs_check_page (0, 2, 0);
3097   return \"LPER %0,%1\";
3098 }")
3099
3100 ;;
3101 ;;- One complement instructions.
3102 ;;
3103
3104 ;
3105 ; one_cmpldi2 instruction pattern(s).
3106 ;
3107
3108 ;(define_expand "one_cmpldi2"
3109 ;  [(set (match_operand:DI 0 "general_operand" "")
3110 ;       (not:DI (match_operand:DI 1 "general_operand" "")))]
3111 ;  ""
3112 ;  "
3113 ;{
3114 ;  rtx gen_one_cmplsi2();
3115 ;
3116 ;  emit_insn (gen_one_cmplsi2 (operand_subword (operands[0], 0, 1, DImode),
3117 ;                             operand_subword (operands[1], 0, 1, DImode)));
3118 ;  emit_insn (gen_one_cmplsi2 (gen_lowpart (SImode, operands[0]),
3119 ;                             gen_lowpart (SImode, operands[1])));
3120 ;  DONE;
3121 ;}")
3122
3123 ;
3124 ; one_cmplsi2 instruction pattern(s).
3125 ;
3126
3127 (define_insn ""
3128   [(set (match_operand:SI 0 "r_or_s_operand" "=dm")
3129         (not:SI (match_operand:SI 1 "r_or_s_operand" "0")))]
3130   "TARGET_CHAR_INSTRUCTIONS"
3131   "*
3132 {
3133   check_label_emit ();
3134   if (REG_P (operands[0]))
3135     {
3136       mvs_check_page (0, 4, 4);
3137       return \"X        %0,=F'-1'\";
3138     }
3139   CC_STATUS_INIT;
3140   mvs_check_page (0, 6, 4);
3141   return \"XC   %O0(4,%R0),=F'-1'\";
3142 }")
3143
3144 (define_insn "one_cmplsi2"
3145   [(set (match_operand:SI 0 "general_operand" "=d")
3146         (not:SI (match_operand:SI 1 "general_operand" "0")))]
3147   ""
3148   "*
3149 {
3150   check_label_emit ();
3151   mvs_check_page (0, 4, 4);
3152   return \"X    %0,=F'-1'\";
3153 }")
3154
3155 ;
3156 ; one_cmplhi2 instruction pattern(s).
3157 ;
3158
3159 (define_insn ""
3160   [(set (match_operand:HI 0 "r_or_s_operand" "=dm")
3161         (not:HI (match_operand:HI 1 "r_or_s_operand" "0")))]
3162   "TARGET_CHAR_INSTRUCTIONS"
3163   "*
3164 {
3165   check_label_emit ();
3166   if (REG_P (operands[0]))
3167     {
3168       mvs_check_page (0, 4, 4);
3169       return \"X        %0,=F'-1'\";
3170     }
3171   CC_STATUS_INIT;
3172   mvs_check_page (0, 6, 4);
3173   return \"XC   %O0(2,%R0),=X'FFFF'\";
3174 }")
3175
3176 (define_insn "one_cmplhi2"
3177   [(set (match_operand:HI 0 "general_operand" "=d")
3178         (not:HI (match_operand:HI 1 "general_operand" "0")))]
3179   ""
3180   "*
3181 {
3182   check_label_emit ();
3183   mvs_check_page (0, 4, 4);
3184   return \"X    %0,=F'-1'\";
3185 }")
3186
3187 ;
3188 ; one_cmplqi2 instruction pattern(s).
3189 ;
3190
3191 (define_insn ""
3192   [(set (match_operand:QI 0 "r_or_s_operand" "=dm")
3193         (not:QI (match_operand:QI 1 "r_or_s_operand" "0")))]
3194   "TARGET_CHAR_INSTRUCTIONS"
3195   "*
3196 {
3197   check_label_emit ();
3198   CC_STATUS_INIT;
3199   if (REG_P (operands[0]))
3200     {
3201       mvs_check_page (0, 4, 4);
3202       return \"X        %0,=F'-1'\";
3203     }
3204   mvs_check_page (0, 4, 0);
3205   return \"XI   %0,255\";
3206 }")
3207
3208 (define_insn "one_cmplqi2"
3209   [(set (match_operand:QI 0 "general_operand" "=d")
3210         (not:QI (match_operand:QI 1 "general_operand" "0")))]
3211   ""
3212   "*
3213 {
3214   check_label_emit ();
3215   CC_STATUS_INIT;
3216   mvs_check_page (0, 4, 4);
3217   return \"X    %0,=F'-1'\";
3218 }")
3219
3220 ;;
3221 ;;- Arithmetic shift instructions.
3222 ;;
3223
3224 ;
3225 ; ashldi3 instruction pattern(s).
3226 ;
3227
3228 (define_insn "ashldi3"
3229   [(set (match_operand:DI 0 "general_operand" "=d")
3230         (ashift:DI (match_operand:DI 1 "general_operand" "0")
3231                    (match_operand:SI 2 "general_operand" "Ja")))]
3232   ""
3233   "*
3234 {
3235   check_label_emit ();
3236   CC_STATUS_INIT;
3237   mvs_check_page (0, 4, 0);
3238   if (REG_P (operands[2]))
3239     return \"SLDA       %0,0(%2)\";
3240   return \"SLDA %0,%c2\";
3241 }")
3242
3243 ;
3244 ; ashrdi3 instruction pattern(s).
3245 ;
3246
3247 (define_insn "ashrdi3"
3248   [(set (match_operand:DI 0 "register_operand" "=d")
3249         (ashiftrt:DI (match_operand:DI 1 "general_operand" "0")
3250                      (match_operand:SI 2 "general_operand" "Ja")))]
3251   ""
3252   "*
3253 {
3254   check_label_emit ();
3255   mvs_check_page (0, 4, 0);
3256   if (REG_P (operands[2]))
3257     return \"SRDA       %0,0(%2)\";
3258   return \"SRDA %0,%c2\";
3259 }")
3260
3261 ;
3262 ; ashlsi3 instruction pattern(s).
3263 ;
3264
3265 (define_insn "ashlsi3"
3266   [(set (match_operand:SI 0 "general_operand" "=d")
3267         (ashift:SI (match_operand:SI 1 "general_operand" "0")
3268                    (match_operand:SI 2 "general_operand" "Ja")))]
3269   ""
3270   "*
3271 {
3272   check_label_emit ();
3273   CC_STATUS_INIT;
3274   mvs_check_page (0, 4, 0);
3275   if (REG_P (operands[2]))
3276     return \"SLL        %0,0(%2)\";
3277   return \"SLL  %0,%c2\";
3278 }")
3279
3280 ;
3281 ; ashrsi3 instruction pattern(s).
3282 ;
3283
3284 (define_insn "ashrsi3"
3285   [(set (match_operand:SI 0 "general_operand" "=d")
3286         (ashiftrt:SI (match_operand:SI 1 "general_operand" "0")
3287                      (match_operand:SI 2 "general_operand" "Ja")))]
3288   ""
3289   "*
3290 {
3291   check_label_emit ();
3292   mvs_check_page (0, 4, 0);
3293   if (REG_P (operands[2]))
3294     return \"SRA        %0,0(%2)\";
3295   return \"SRA  %0,%c2\";
3296 }")
3297
3298 ;
3299 ; ashlhi3 instruction pattern(s).
3300 ;
3301
3302 (define_insn "ashlhi3"
3303   [(set (match_operand:HI 0 "general_operand" "=d")
3304         (ashift:HI (match_operand:HI 1 "general_operand" "0")
3305                    (match_operand:SI 2 "general_operand" "Ja")))]
3306   ""
3307   "*
3308 {
3309   check_label_emit ();
3310   mvs_check_page (0, 8, 0);
3311   if (REG_P (operands[2]))
3312     return \"SLL        %0,16(%2)\;SRA  %0,16\";
3313   return \"SLL  %0,16+%c2\;SRA  %0,16\";
3314 }")
3315
3316 ;
3317 ; ashrhi3 instruction pattern(s).
3318 ;
3319
3320 (define_insn "ashrhi3"
3321   [(set (match_operand:HI 0 "general_operand" "=d")
3322         (ashiftrt:HI (match_operand:HI 1 "general_operand" "0")
3323                      (match_operand:SI 2 "general_operand" "Ja")))]
3324   ""
3325   "*
3326 {
3327   check_label_emit ();
3328   mvs_check_page (0, 4, 0);
3329   if (REG_P (operands[2]))
3330     return \"SLL        %0,16\;SRA      %0,16(%2)\";
3331   return \"SLL  %0,16\;SRA      %0,16+%c2\";
3332 }")
3333
3334 ;
3335 ; ashlqi3 instruction pattern(s).
3336 ;
3337
3338 (define_insn "ashlqi3"
3339   [(set (match_operand:QI 0 "general_operand" "=d")
3340         (ashift:QI (match_operand:QI 1 "general_operand" "0")
3341                    (match_operand:SI 2 "general_operand" "Ja")))]
3342   ""
3343   "*
3344 {
3345   check_label_emit ();
3346   CC_STATUS_INIT;
3347   mvs_check_page (0, 4, 0);
3348   if (REG_P (operands[2]))
3349     return \"SLL        %0,0(%2)\";
3350   return \"SLL  %0,%c2\";
3351 }")
3352
3353 ;
3354 ; ashrqi3 instruction pattern(s).
3355 ;
3356
3357 (define_insn "ashrqi3"
3358   [(set (match_operand:QI 0 "general_operand" "=d")
3359         (ashiftrt:QI (match_operand:QI 1 "general_operand" "0")
3360                      (match_operand:SI 2 "general_operand" "Ja")))]
3361   ""
3362   "*
3363 {
3364   check_label_emit ();
3365   mvs_check_page (0, 8, 0);
3366   if (REG_P (operands[2]))
3367     return \"SLL        %0,24\;SRA      %0,24(%2)\";
3368   return \"SLL  %0,24\;SRA      %0,24+%c2\";
3369 }")
3370
3371 ;;
3372 ;;- Logical shift instructions.
3373 ;;
3374
3375 ;
3376 ; lshrdi3 instruction pattern(s).
3377 ;
3378
3379 (define_insn "lshrdi3"
3380   [(set (match_operand:DI 0 "general_operand" "=d")
3381         (lshiftrt:DI (match_operand:DI 1 "general_operand" "0")
3382                      (match_operand:SI 2 "general_operand" "Ja")))]
3383   ""
3384   "*
3385 {
3386   check_label_emit ();
3387   mvs_check_page (0, 4, 0);
3388   if (REG_P (operands[2]))
3389     return \"SRDL       %0,0(%2)\";
3390   return \"SRDL %0,%c2\";
3391 }")
3392
3393
3394 ;
3395 ; lshrsi3 instruction pattern(s).
3396 ;
3397
3398 (define_insn "lshrsi3"
3399   [(set (match_operand:SI 0 "general_operand" "=d")
3400         (lshiftrt:SI (match_operand:SI 1 "general_operand" "0")
3401                      (match_operand:SI 2 "general_operand" "Ja")))]
3402   ""
3403   "*
3404 {
3405   check_label_emit ();
3406   mvs_check_page (0, 4, 0);
3407   if (REG_P (operands[2]))
3408     return \"SRL        %0,0(%2)\";
3409   return \"SRL  %0,%c2\";
3410 }")
3411
3412 ;
3413 ; lshrhi3 instruction pattern(s).
3414 ;
3415
3416 (define_insn "lshrhi3"
3417   [(set (match_operand:HI 0 "general_operand" "=d")
3418         (lshiftrt:HI (match_operand:HI 1 "general_operand" "0")
3419                      (match_operand:SI 2 "general_operand" "Ja")))]
3420   ""
3421   "*
3422 {
3423   check_label_emit ();
3424   CC_STATUS_INIT;
3425   if (REG_P (operands[2]))
3426     {
3427       mvs_check_page (0, 8, 4);
3428       return \"N        %0,=X'0000FFFF'\;SRL    %0,0(%2)\";
3429     }
3430   mvs_check_page (0, 8, 4);
3431   return \"N    %0,=X'0000FFFF'\;SRL    %0,%c2\";
3432 }")
3433
3434 ;
3435 ; lshrqi3 instruction pattern(s).
3436 ;
3437
3438 (define_insn "lshrqi3"
3439   [(set (match_operand:QI 0 "general_operand" "=d")
3440         (lshiftrt:QI (match_operand:QI 1 "general_operand" "0")
3441                      (match_operand:SI 2 "general_operand" "Ja")))]
3442   ""
3443   "*
3444 {
3445   check_label_emit ();
3446   CC_STATUS_INIT;
3447   mvs_check_page (0, 8, 4);
3448   if (REG_P (operands[2]))
3449     return \"N  %0,=X'000000FF'\;SRL    %0,0(%2)\";
3450   return \"N    %0,=X'000000FF'\;SRL    %0,%c2\";
3451 }")
3452
3453 ;;
3454 ;;- Conditional jump instructions.
3455 ;;
3456
3457 ;
3458 ; beq instruction pattern(s).
3459 ;
3460
3461 (define_insn "beq"
3462   [(set (pc)
3463         (if_then_else (eq (cc0)
3464                           (const_int 0))
3465                       (label_ref (match_operand 0 "" ""))
3466                       (pc)))]
3467   ""
3468   "*
3469 {
3470   check_label_emit ();
3471   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3472     {
3473       mvs_check_page (0, 6, 4);
3474       return \"L        14,=A(%l0)\;BER 14\";
3475     }
3476   if (mvs_check_page (0, 4, 0))
3477     {
3478       mvs_check_page (0, 2, 4);
3479       return \"L        14,=A(%l0)\;BER 14\";
3480     }
3481   return \"BE   %l0\";
3482 }")
3483
3484 ;
3485 ; bne instruction pattern(s).
3486 ;
3487
3488 (define_insn "bne"
3489   [(set (pc)
3490         (if_then_else (ne (cc0)
3491                           (const_int 0))
3492                       (label_ref (match_operand 0 "" ""))
3493                       (pc)))]
3494   ""
3495   "*
3496 {
3497   check_label_emit ();
3498   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3499     {
3500       mvs_check_page (0, 6, 4);
3501       return \"L        14,=A(%l0)\;BNER        14\";
3502     }
3503   if (mvs_check_page (0, 4, 0))
3504     {
3505       mvs_check_page (0, 2, 4);
3506       return \"L        14,=A(%l0)\;BNER        14\";
3507     }
3508   return \"BNE  %l0\";
3509 }")
3510
3511 ;
3512 ; bgt instruction pattern(s).
3513 ;
3514
3515 (define_insn "bgt"
3516   [(set (pc)
3517         (if_then_else (gt (cc0)
3518                           (const_int 0))
3519                       (label_ref (match_operand 0 "" ""))
3520                       (pc)))]
3521   ""
3522   "*
3523 {
3524   check_label_emit ();
3525   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3526     {
3527       mvs_check_page (0, 6, 4);
3528       return \"L        14,=A(%l0)\;BHR 14\";
3529     }
3530   if (mvs_check_page (0, 4, 0))
3531     {
3532       mvs_check_page (0, 2, 4);
3533       return \"L        14,=A(%l0)\;BHR 14\";
3534     }
3535   return \"BH   %l0\";
3536 }")
3537
3538 ;
3539 ; bgtu instruction pattern(s).
3540 ;
3541
3542 (define_insn "bgtu"
3543   [(set (pc)
3544         (if_then_else (gtu (cc0)
3545                            (const_int 0))
3546                       (label_ref (match_operand 0 "" ""))
3547                       (pc)))]
3548   ""
3549   "*
3550 {
3551   check_label_emit ();
3552   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3553     {
3554       mvs_check_page (0, 6, 4);
3555       return \"L        14,=A(%l0)\;BHR 14\";
3556     }
3557   if (mvs_check_page (0, 4, 0))
3558     {
3559       mvs_check_page (0, 2, 4);
3560       return \"L        14,=A(%l0)\;BHR 14\";
3561     }
3562   return \"BH   %l0\";
3563 }")
3564
3565 ;
3566 ; blt instruction pattern(s).
3567 ;
3568
3569 (define_insn "blt"
3570   [(set (pc)
3571         (if_then_else (lt (cc0)
3572                           (const_int 0))
3573                       (label_ref (match_operand 0 "" ""))
3574                       (pc)))]
3575   ""
3576   "*
3577 {
3578   check_label_emit ();
3579   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3580     {
3581       mvs_check_page (0, 6, 4);
3582       return \"L        14,=A(%l0)\;BLR 14\";
3583     }
3584   if (mvs_check_page (0, 4, 0))
3585     {
3586       mvs_check_page (0, 2, 4);
3587       return \"L        14,=A(%l0)\;BLR 14\";
3588     }
3589   return \"BL   %l0\";
3590 }")
3591
3592 ;
3593 ; bltu instruction pattern(s).
3594 ;
3595
3596 (define_insn "bltu"
3597   [(set (pc)
3598         (if_then_else (ltu (cc0)
3599                            (const_int 0))
3600                       (label_ref (match_operand 0 "" ""))
3601                       (pc)))]
3602   ""
3603   "*
3604 {
3605   check_label_emit ();
3606   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3607     {
3608       mvs_check_page (0, 6, 4);
3609       return \"L        14,=A(%l0)\;BLR 14\";
3610     }
3611   if (mvs_check_page (0, 4, 0))
3612     {
3613       mvs_check_page (0, 2, 4);
3614       return \"L        14,=A(%l0)\;BLR 14\";
3615     }
3616   return \"BL   %l0\";
3617 }")
3618
3619 ;
3620 ; bge instruction pattern(s).
3621 ;
3622
3623 (define_insn "bge"
3624   [(set (pc)
3625         (if_then_else (ge (cc0)
3626                           (const_int 0))
3627                       (label_ref (match_operand 0 "" ""))
3628                       (pc)))]
3629   ""
3630   "*
3631 {
3632   check_label_emit ();
3633   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3634     {
3635       mvs_check_page (0, 6, 4);
3636       return \"L        14,=A(%l0)\;BNLR        14\";
3637     }
3638   if (mvs_check_page (0, 4, 0))
3639     {
3640       mvs_check_page (0, 2, 4);
3641       return \"L        14,=A(%l0)\;BNLR        14\";
3642     }
3643   return \"BNL  %l0\";
3644 }")
3645
3646 ;
3647 ; bgeu instruction pattern(s).
3648 ;
3649
3650 (define_insn "bgeu"
3651   [(set (pc)
3652         (if_then_else (geu (cc0)
3653                            (const_int 0))
3654                       (label_ref (match_operand 0 "" ""))
3655                       (pc)))]
3656   ""
3657   "*
3658 {
3659   check_label_emit ();
3660   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3661     {
3662       mvs_check_page (0, 6, 4);
3663       return \"L        14,=A(%l0)\;BNLR        14\";
3664     }
3665   if (mvs_check_page (0, 4, 0))
3666     {
3667       mvs_check_page (0, 2, 4);
3668       return \"L        14,=A(%l0)\;BNLR        14\";
3669     }
3670   return \"BNL  %l0\";
3671 }")
3672
3673 ;
3674 ; ble instruction pattern(s).
3675 ;
3676
3677 (define_insn "ble"
3678   [(set (pc)
3679         (if_then_else (le (cc0)
3680                           (const_int 0))
3681                       (label_ref (match_operand 0 "" ""))
3682                       (pc)))]
3683   ""
3684   "*
3685 {
3686   check_label_emit ();
3687   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3688     {
3689       mvs_check_page (0, 6, 4);
3690       return \"L        14,=A(%l0)\;BNHR        14\";
3691     }
3692   if (mvs_check_page (0, 4, 0))
3693     {
3694       mvs_check_page (0, 2, 4);
3695       return \"L        14,=A(%l0)\;BNHR        14\";
3696     }
3697   return \"BNH  %l0\";
3698 }")
3699
3700 ;
3701 ; bleu instruction pattern(s).
3702 ;
3703
3704 (define_insn "bleu"
3705   [(set (pc)
3706         (if_then_else (leu (cc0)
3707                            (const_int 0))
3708                       (label_ref (match_operand 0 "" ""))
3709                       (pc)))]
3710   ""
3711   "*
3712 {
3713   check_label_emit ();
3714   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3715     {
3716       mvs_check_page (0, 6, 4);
3717       return \"L        14,=A(%l0)\;BNHR        14\";
3718     }
3719   if (mvs_check_page (0, 4, 0))
3720     {
3721       mvs_check_page (0, 2, 4);
3722       return \"L        14,=A(%l0)\;BNHR        14\";
3723     }
3724   return \"BNH  %l0\";
3725 }")
3726
3727 ;;
3728 ;;- Negated conditional jump instructions.
3729 ;;
3730
3731 (define_insn ""
3732   [(set (pc)
3733         (if_then_else (eq (cc0)
3734                           (const_int 0))
3735                       (pc)
3736                       (label_ref (match_operand 0 "" ""))))]
3737   ""
3738   "*
3739 {
3740   check_label_emit ();
3741   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3742     {
3743       mvs_check_page (0, 6, 4);
3744       return \"L        14,=A(%l0)\;BNER        14\";
3745     }
3746   if (mvs_check_page (0, 4, 0))
3747     {
3748       mvs_check_page (0, 2, 4);
3749       return \"L        14,=A(%l0)\;BNER        14\";
3750     }
3751   return \"BNE  %l0\";
3752 }")
3753
3754 (define_insn ""
3755   [(set (pc)
3756         (if_then_else (ne (cc0)
3757                           (const_int 0))
3758                       (pc)
3759                       (label_ref (match_operand 0 "" ""))))]
3760   ""
3761   "*
3762 {
3763   check_label_emit ();
3764   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3765     {
3766       mvs_check_page (0, 6, 4);
3767       return \"L        14,=A(%l0)\;BER 14\";
3768     }
3769   if (mvs_check_page (0, 4, 0))
3770     {
3771       mvs_check_page (0, 2, 4);
3772       return \"L        14,=A(%l0)\;BER 14\";
3773     }
3774   return \"BE   %l0\";
3775 }")
3776
3777 (define_insn ""
3778   [(set (pc)
3779         (if_then_else (gt (cc0)
3780                           (const_int 0))
3781                       (pc)
3782                       (label_ref (match_operand 0 "" ""))))]
3783   ""
3784   "*
3785 {
3786   check_label_emit ();
3787   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3788     {
3789       mvs_check_page (0, 6, 4);
3790       return \"L        14,=A(%l0)\;BNHR        14\";
3791     }
3792   if (mvs_check_page (0, 4, 0))
3793     {
3794       mvs_check_page (0, 2, 4);
3795       return \"L        14,=A(%l0)\;BNHR        14\";
3796     }
3797   return \"BNH  %l0\";
3798 }")
3799
3800 (define_insn ""
3801   [(set (pc)
3802         (if_then_else (gtu (cc0)
3803                            (const_int 0))
3804                       (pc)
3805                       (label_ref (match_operand 0 "" ""))))]
3806   ""
3807   "*
3808 {
3809   check_label_emit ();
3810   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3811     {
3812       mvs_check_page (0, 6, 4);
3813       return \"L        14,=A(%l0)\;BNHR        14\";
3814     }
3815   if (mvs_check_page (0, 4, 0))
3816     {
3817       mvs_check_page (0, 2, 4);
3818       return \"L        14,=A(%l0)\;BNHR        14\";
3819     }
3820   return \"BNH  %l0\";
3821 }")
3822
3823 (define_insn ""
3824   [(set (pc)
3825         (if_then_else (lt (cc0)
3826                           (const_int 0))
3827                       (pc)
3828                       (label_ref (match_operand 0 "" ""))))]
3829   ""
3830   "*
3831 {
3832   check_label_emit ();
3833   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3834     {
3835       mvs_check_page (0, 6, 4);
3836       return \"L        14,=A(%l0)\;BNLR        14\";
3837     }
3838   if (mvs_check_page (0, 4, 0))
3839     {
3840       mvs_check_page (0, 2, 4);
3841       return \"L        14,=A(%l0)\;BNLR        14\";
3842     }
3843   return \"BNL  %l0\";
3844 }")
3845
3846 (define_insn ""
3847   [(set (pc)
3848         (if_then_else (ltu (cc0)
3849                            (const_int 0))
3850                       (pc)
3851                       (label_ref (match_operand 0 "" ""))))]
3852   ""
3853   "*
3854 {
3855   check_label_emit ();
3856   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3857     {
3858       mvs_check_page (0, 6, 4);
3859       return \"L        14,=A(%l0)\;BNLR        14\";
3860     }
3861   if (mvs_check_page (0, 4, 0))
3862     {
3863       mvs_check_page (0, 2, 4);
3864       return \"L        14,=A(%l0)\;BNLR        14\";
3865     }
3866   return \"BNL  %l0\";
3867 }")
3868
3869 (define_insn ""
3870   [(set (pc)
3871         (if_then_else (ge (cc0)
3872                           (const_int 0))
3873                       (pc)
3874                       (label_ref (match_operand 0 "" ""))))]
3875   ""
3876   "*
3877 {
3878   check_label_emit ();
3879   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3880     {
3881       mvs_check_page (0, 6, 4);
3882       return \"L        14,=A(%l0)\;BLR 14\";
3883     }
3884   if (mvs_check_page (0, 4, 0))
3885     {
3886       mvs_check_page (0, 2, 4);
3887       return \"L        14,=A(%l0)\;BLR 14\";
3888     }
3889   return \"BL   %l0\";
3890 }")
3891
3892 (define_insn ""
3893   [(set (pc)
3894         (if_then_else (geu (cc0)
3895                            (const_int 0))
3896                       (pc)
3897                       (label_ref (match_operand 0 "" ""))))]
3898   ""
3899   "*
3900 {
3901   check_label_emit ();
3902   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3903     {
3904       mvs_check_page (0, 6, 4);
3905       return \"L        14,=A(%l0)\;BLR 14\";
3906     }
3907   if (mvs_check_page (0, 4, 0))
3908     {
3909       mvs_check_page (0, 2, 4);
3910       return \"L        14,=A(%l0)\;BLR 14\";
3911     }
3912   return \"BL   %l0\";
3913 }")
3914
3915 (define_insn ""
3916   [(set (pc)
3917         (if_then_else (le (cc0)
3918                           (const_int 0))
3919                       (pc)
3920                       (label_ref (match_operand 0 "" ""))))]
3921   ""
3922   "*
3923 {
3924   check_label_emit ();
3925   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3926     {
3927       mvs_check_page (0, 6, 4);
3928       return \"L        14,=A(%l0)\;BHR 14\";
3929     }
3930   if (mvs_check_page (0, 4, 0))
3931     {
3932       mvs_check_page (0, 2, 4);
3933       return \"L        14,=A(%l0)\;BHR 14\";
3934     }
3935   return \"BH   %l0\";
3936 }")
3937
3938 (define_insn ""
3939   [(set (pc)
3940         (if_then_else (leu (cc0)
3941                            (const_int 0))
3942                       (pc)
3943                       (label_ref (match_operand 0 "" ""))))]
3944   ""
3945   "*
3946 {
3947   check_label_emit ();
3948   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3949     {
3950       mvs_check_page (0, 6, 4);
3951       return \"L        14,=A(%l0)\;BHR 14\";
3952     }
3953   if (mvs_check_page (0, 4, 0))
3954     {
3955       mvs_check_page (0, 2, 4);
3956       return \"L        14,=A(%l0)\;BHR 14\";
3957     }
3958   return \"BH   %l0\";
3959 }")
3960
3961 ;;
3962 ;;- Subtract one and jump if not zero.
3963 ;;
3964
3965 (define_insn ""
3966   [(set (pc)
3967         (if_then_else
3968          (ne (plus:SI (match_operand:SI 0 "register_operand" "+d")
3969                       (const_int -1))
3970              (const_int 0))
3971          (label_ref (match_operand 1 "" ""))
3972          (pc)))
3973    (set (match_dup 0)
3974         (plus:SI (match_dup 0)
3975                  (const_int -1)))]
3976   ""
3977   "*
3978 {
3979   check_label_emit ();
3980   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[1])))
3981     {
3982       mvs_check_page (0, 6, 4);
3983       return \"L        14,=A(%l1)\;BCTR        %0,14\";
3984     }
3985   if (mvs_check_page (0, 4, 0))
3986     {
3987       mvs_check_page (0, 2, 4);
3988       return \"L        14,=A(%l1)\;BCTR        %0,14\";
3989     }
3990   return \"BCT  %0,%l1\";
3991 }")
3992
3993 (define_insn ""
3994   [(set (pc)
3995         (if_then_else
3996          (eq (plus:SI (match_operand:SI 0 "register_operand" "+d")
3997                       (const_int -1))
3998              (const_int 0))
3999          (pc)
4000          (label_ref (match_operand 1 "" ""))))
4001    (set (match_dup 0)
4002         (plus:SI (match_dup 0)
4003                  (const_int -1)))]
4004   ""
4005   "*
4006 {
4007   check_label_emit ();
4008   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[1])))
4009     {
4010       mvs_check_page (0, 6, 4);
4011       return \"L        14,=A(%l1)\;BCTR        %0,14\";
4012     }
4013   if (mvs_check_page (0, 4, 0))
4014     {
4015       mvs_check_page (0, 2, 4);
4016       return \"L        14,=A(%l1)\;BCTR        %0,14\";
4017     }
4018   return \"BCT  %0,%l1\";
4019 }")
4020
4021 ;;
4022 ;;- Unconditional jump instructions.
4023 ;;
4024
4025 ;
4026 ; jump instruction pattern(s).
4027 ;
4028
4029 (define_insn "jump"
4030   [(set (pc)
4031         (label_ref (match_operand 0 "" "")))]
4032   ""
4033   "*
4034 {
4035   check_label_emit ();
4036   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
4037     {
4038       mvs_check_page (0, 6, 4);
4039       return \"L        14,=A(%l0)\;BR  14\";
4040     }
4041   if (mvs_check_page (0, 4, 0))
4042     {
4043       mvs_check_page (0, 2, 4);
4044       return \"L        14,=A(%l0)\;BR  14\";
4045     }
4046   return \"B    %l0\";
4047 }")
4048
4049 ;
4050 ; indirect-jump instruction pattern(s).
4051 ;
4052
4053 (define_insn "indirect_jump"
4054   [(set (pc) (match_operand:SI 0 "general_operand" "r"))]
4055   "(GET_CODE (operands[0]) != MEM )"
4056   "*
4057 {
4058   check_label_emit ();
4059   mvs_check_page (0, 2, 0);
4060   return \"BR   %0\";
4061 }")
4062
4063 ;
4064 ; tablejump instruction pattern(s).
4065 ;
4066
4067 (define_insn "tablejump"
4068   [(set (pc)
4069         (match_operand:SI 0 "general_operand" "am"))
4070    (use (label_ref (match_operand 1 "" "")))]
4071   ""
4072   "*
4073 {
4074   check_label_emit ();
4075   if (REG_P (operands[0]))
4076     {
4077       mvs_check_page (0, 6, 0);
4078       return \"BR       %0\;DS  0F\";
4079     }
4080   mvs_check_page (0, 10, 0);
4081   return \"L    14,%0\;BR       14\;DS  0F\";
4082 }")
4083
4084 ;;
4085 ;;- Jump to subroutine.
4086 ;;
4087 ;; For the C/370 environment the internal functions, ie. sqrt, are called with
4088 ;; a non-standard form.  So, we must fix it here.  There's no BM like IBM.
4089 ;;
4090
4091 ;
4092 ; call instruction pattern(s).
4093 ;
4094
4095 (define_insn "call"
4096   [(call (match_operand:QI 0 "memory_operand" "m")
4097          (match_operand:SI 1 "immediate_operand" "i"))]
4098   ""
4099   "*
4100 {
4101   static char temp[128];
4102   int i = STACK_POINTER_OFFSET;
4103
4104   check_label_emit ();
4105   if (mvs_function_check (XSTR (operands[0], 0)))
4106     {
4107       mvs_check_page (0, 22, 4);
4108       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%0\;BALR    14,15\;LD       0,136(,13)\",
4109              i - 4, i - 4 );
4110     }
4111   else
4112     {
4113       mvs_check_page (0, 10, 4);
4114       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%0\;BALR    14,15\", i );
4115     }
4116   return temp;
4117 }")
4118
4119 ;
4120 ; call_value instruction pattern(s).
4121 ;
4122
4123 (define_insn "call_value"
4124   [(set (match_operand 0 "" "rf")
4125         (call (match_operand:QI 1 "memory_operand" "m")
4126               (match_operand:SI 2 "general_operand" "i")))]
4127   ""
4128   "*
4129 {
4130   static char temp[128];
4131   int i = STACK_POINTER_OFFSET;
4132
4133   check_label_emit ();
4134   if (mvs_function_check (XSTR (operands[1], 0)))
4135     {
4136       mvs_check_page (0, 22, 4);
4137       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%1\;BALR    14,15\;LD       0,136(,13)\",
4138            i - 4, i - 4 );
4139     }
4140   else
4141     {
4142       mvs_check_page (0, 10, 4);
4143       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%1\;BALR    14,15\", i );
4144     }
4145   return temp;
4146 }")
4147
4148 (define_insn ""
4149   [(call (mem:QI (match_operand:SI 0 "" "i"))
4150          (match_operand:SI 1 "general_operand" "g"))]
4151   "GET_CODE (operands[0]) == SYMBOL_REF"
4152   "*
4153 {
4154   static char temp[128];
4155   int i = STACK_POINTER_OFFSET;
4156
4157   check_label_emit ();
4158   if (mvs_function_check (XSTR (operands[0], 0)))
4159     {
4160       mvs_check_page (0, 22, 4);
4161       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%0\;BALR    14,15\;LD       0,136(,13)\",
4162            i - 4, i - 4 );
4163     }
4164   else
4165     {
4166       mvs_check_page (0, 10, 4);
4167       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%0\;BALR    14,15\", i );
4168     }
4169   return temp;
4170 }")
4171
4172 (define_insn ""
4173   [(set (match_operand 0 "" "rf")
4174         (call (mem:QI (match_operand:SI 1 "" "i"))
4175               (match_operand:SI 2 "general_operand" "g")))]
4176   "GET_CODE (operands[1]) == SYMBOL_REF"
4177   "*
4178 {
4179   static char temp[128];
4180   int i = STACK_POINTER_OFFSET;
4181
4182   check_label_emit ();
4183   if (mvs_function_check (XSTR (operands[1], 0)))
4184     {
4185       mvs_check_page (0, 22, 4);
4186       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%1\;BALR    14,15\;LD       0,136(,13)\",
4187            i - 4, i - 4 );
4188     }
4189   else
4190     {
4191       mvs_check_page (0, 10, 4);
4192       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%1\;BALR    14,15\", i );
4193     }
4194   return temp;
4195 }")
4196
4197
4198 ;;
4199 ;;- Miscellaneous instructions.
4200 ;;
4201
4202 ;
4203 ; nop instruction pattern(s).
4204 ;
4205
4206 (define_insn "nop"
4207   [(const_int 0)]
4208   ""
4209   "*
4210 {
4211   check_label_emit ();
4212   mvs_check_page (0, 2, 0);
4213   return \"LR   0,0\";
4214 }")
4215