gcc/config/i370/i370.md

   1 ;;- Machine description for GNU compiler -- System/370 version.
   2 ;;  Copyright (C) 1989, 93, 94, 95, 97, 1999 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     op0 = operands[0];
1217   else
1218     op0 = change_address (operands[0], VOIDmode,
1219                           copy_to_mode_reg (SImode, op0));
1220
1221   op1 = XEXP (operands[1], 0);
1222   if (GET_CODE (op1) == REG
1223       || (GET_CODE (op1) == PLUS && GET_CODE (XEXP (op1, 0)) == REG
1224           && GET_CODE (XEXP (op1, 1)) == CONST_INT
1225           && (unsigned) INTVAL (XEXP (op1, 1)) < 4096))
1226     op1 = operands[1];
1227   else
1228     op1 = change_address (operands[1], VOIDmode,
1229                           copy_to_mode_reg (SImode, op1));
1230
1231   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 256)
1232     emit_insn (gen_rtx (PARALLEL, VOIDmode,
1233                         gen_rtvec (2,
1234                                    gen_rtx (SET, VOIDmode, op0, op1),
1235                                    gen_rtx (USE, VOIDmode, operands[2]))));
1236
1237   else
1238     {
1239       rtx reg1 = gen_reg_rtx (DImode);
1240       rtx reg2 = gen_reg_rtx (DImode);
1241       rtx subreg = gen_rtx (SUBREG, SImode, reg1, 1);
1242
1243       emit_insn (gen_rtx (SET, VOIDmode, subreg, operands[2]));
1244       emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (SUBREG, SImode, reg2, 1),
1245                           subreg));
1246       emit_insn (gen_rtx (PARALLEL, VOIDmode,
1247                           gen_rtvec (5,
1248                                      gen_rtx (SET, VOIDmode, op0, op1),
1249                                      gen_rtx (USE, VOIDmode, reg1),
1250                                      gen_rtx (USE, VOIDmode, reg2),
1251                                      gen_rtx (CLOBBER, VOIDmode, reg1),
1252                                      gen_rtx (CLOBBER, VOIDmode, reg2))));
1253     }
1254   DONE;
1255 }")
1256
1257 ; Move a block that is less than 256 bytes in length.
1258
1259 (define_insn ""
1260   [(set (match_operand:BLK 0 "s_operand" "=m")
1261         (match_operand:BLK 1 "s_operand" "m"))
1262    (use (match_operand 2 "immediate_operand" "I"))]
1263   "((unsigned) INTVAL (operands[2]) < 256)"
1264   "*
1265 {
1266   check_label_emit ();
1267   mvs_check_page (0, 6, 0);
1268   return \"MVC  %O0(%c2,%R0),%1\";
1269 }")
1270
1271 ; Move a block that is larger than 255 bytes in length.
1272
1273 (define_insn ""
1274   [(set (match_operand:BLK 0 "general_operand" "=m")
1275         (match_operand:BLK 1 "general_operand" "m"))
1276    (use (match_operand:DI 2 "register_operand" "d"))
1277    (use (match_operand:DI 3 "register_operand" "d"))
1278    (clobber (match_dup 2))
1279    (clobber (match_dup 3))]
1280   ""
1281   "*
1282 {
1283   check_label_emit ();
1284   mvs_check_page (0, 10, 0);
1285   return \"LA   %2,%0\;LA       %3,%1\;MVCL     %2,%3\";
1286 }")
1287
1288 ;;
1289 ;;- Conversion instructions.
1290 ;;
1291
1292 ;
1293 ; extendsidi2 instruction pattern(s).
1294 ;
1295
1296 (define_expand "extendsidi2"
1297   [(set (match_operand:DI 0 "general_operand" "")
1298         (sign_extend:DI (match_operand:SI 1 "general_operand" "")))]
1299   ""
1300   "
1301 {
1302   if (GET_CODE (operands[1]) != CONST_INT)
1303     {
1304       emit_insn (gen_rtx (SET, VOIDmode,
1305                   operand_subword (operands[0], 0, 1, DImode), operands[1]));
1306       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
1307                         gen_rtx (ASHIFTRT, DImode, operands[0],
1308                                 GEN_INT (32))));
1309     }
1310   else
1311     {
1312       if (INTVAL (operands[1]) < 0)
1313         {
1314           emit_insn (gen_rtx (SET, VOIDmode,
1315                                   operand_subword (operands[0], 0, 1, DImode),
1316                                GEN_INT (-1)));
1317         }
1318       else
1319         {
1320           emit_insn (gen_rtx (SET, VOIDmode,
1321                                 operand_subword (operands[0], 0, 1, DImode),
1322                                GEN_INT (0)));
1323         }
1324       emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (SImode, operands[0]),
1325                            operands[1]));
1326     }
1327   DONE;
1328 }")
1329
1330 ;
1331 ; extendhisi2 instruction pattern(s).
1332 ;
1333
1334 (define_insn "extendhisi2"
1335   [(set (match_operand:SI 0 "general_operand" "=d,m")
1336         (sign_extend:SI (match_operand:HI 1 "general_operand" "g,d")))]
1337   ""
1338   "*
1339 {
1340   check_label_emit ();
1341   if (REG_P (operands[0]))
1342     {
1343       if (REG_P (operands[1]))
1344         if (REGNO (operands[0]) != REGNO (operands[1]))
1345           {
1346             mvs_check_page (0, 2, 0);
1347             return \"LR %0,%1\;SLL      %0,16\;SRA      %0,16\";
1348           }
1349         else
1350           return \"\"; /* Should be empty.  16-bits regs are always 32-bits.  */
1351       if (operands[1] == const0_rtx)
1352         {
1353           CC_STATUS_INIT;
1354           mvs_check_page (0, 2, 0);
1355           return \"SLR  %0,%0\";
1356         }
1357       if (GET_CODE (operands[1]) == CONST_INT
1358           && (unsigned) INTVAL (operands[1]) < 4096)
1359         {
1360           mvs_check_page (0, 4, 0);
1361           return \"LA   %0,%c1\";
1362         }
1363       if (GET_CODE (operands[1]) == CONST_INT)
1364         {
1365           mvs_check_page (0, 4, 0);
1366           return \"LH   %0,%H1\";
1367         }
1368       mvs_check_page (0, 4, 0);
1369       return \"LH       %0,%1\";
1370     }
1371   mvs_check_page (0, 4, 0);
1372   return \"SLL  %1,16\;SRA      %1,16\;ST       %1,%0\";
1373 }")
1374
1375 ;
1376 ; extendqisi2 instruction pattern(s).
1377 ;
1378
1379 (define_insn "extendqisi2"
1380   [(set (match_operand:SI 0 "general_operand" "=d")
1381         (sign_extend:SI (match_operand:QI 1 "general_operand" "0mi")))]
1382   ""
1383   "*
1384 {
1385   check_label_emit ();
1386   CC_STATUS_SET (operands[0], operands[1]);
1387   if (REG_P (operands[1]))
1388     {
1389       mvs_check_page (0, 8, 0);
1390       return \"SLL      %0,24\;SRA      %0,24\";
1391     }
1392   if (s_operand (operands[1]))
1393     {
1394       mvs_check_page (0, 8, 0);
1395       return \"ICM      %0,8,%1\;SRA    %0,24\";
1396     }
1397   mvs_check_page (0, 12, 0);
1398   return \"IC   %0,%1\;SLL      %0,24\;SRA      %0,24\";
1399 }")
1400
1401 ;
1402 ; extendqihi2 instruction pattern(s).
1403 ;
1404
1405 (define_insn "extendqihi2"
1406   [(set (match_operand:HI 0 "general_operand" "=d")
1407         (sign_extend:HI (match_operand:QI 1 "general_operand" "0m")))]
1408   ""
1409   "*
1410 {
1411   check_label_emit ();
1412   CC_STATUS_SET (operands[0], operands[1]);
1413   if (REG_P (operands[1]))
1414     {
1415       mvs_check_page (0, 8, 0);
1416       return \"SLL      %0,24\;SRA      %0,24\";
1417     }
1418   if (s_operand (operands[1]))
1419     {
1420       mvs_check_page (0, 8, 0);
1421       return \"ICM      %0,8,%1\;SRA    %0,24\";
1422     }
1423   mvs_check_page (0, 12, 0);
1424   return \"IC   %0,%1\;SLL      %0,24\;SRA      %0,24\";
1425 }")
1426
1427 ;
1428 ; zero_extendsidi2 instruction pattern(s).
1429 ;
1430
1431 (define_expand "zero_extendsidi2"
1432   [(set (match_operand:DI 0 "general_operand" "")
1433         (zero_extend:DI (match_operand:SI 1 "general_operand" "")))]
1434   ""
1435   "
1436 {
1437       emit_insn (gen_rtx (SET, VOIDmode,
1438                   operand_subword (operands[0], 0, 1, DImode), operands[1]));
1439       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
1440                         gen_rtx (LSHIFTRT, DImode, operands[0],
1441                                 GEN_INT (32))));
1442   DONE;
1443 }")
1444
1445 ;
1446 ; zero_extendhisi2 instruction pattern(s).
1447 ;
1448
1449 (define_insn "zero_extendhisi2"
1450   [(set (match_operand:SI 0 "general_operand" "=d")
1451         (zero_extend:SI (match_operand:HI 1 "general_operand" "0")))]
1452   ""
1453   "*
1454 {
1455   check_label_emit ();
1456   CC_STATUS_SET (operands[0], operands[1]);
1457   mvs_check_page (0, 4, 4);
1458   return \"N    %1,=X'0000FFFF'\";
1459 }")
1460
1461 ;
1462 ; zero_extendqisi2 instruction pattern(s).
1463 ;
1464
1465 (define_insn "zero_extendqisi2"
1466   [(set (match_operand:SI 0 "general_operand" "=d,&d")
1467         (zero_extend:SI (match_operand:QI 1 "general_operand" "0i,m")))]
1468   ""
1469   "*
1470 {
1471   check_label_emit ();
1472   if (REG_P (operands[1]))
1473     {
1474       CC_STATUS_SET (operands[0], operands[1]);
1475       mvs_check_page (0, 4, 4);
1476       return \"N        %0,=X'000000FF'\";
1477     }
1478   if (GET_CODE (operands[1]) == CONST_INT)
1479     {
1480       mvs_check_page (0, 4, 0);
1481       return \"LA       %0,%c1\";
1482     }
1483   CC_STATUS_INIT;
1484   mvs_check_page (0, 8, 0);
1485   return \"SLR  %0,%0\;IC       %0,%1\";
1486 }")
1487
1488 ;
1489 ; zero_extendqihi2 instruction pattern(s).
1490 ;
1491
1492 (define_insn "zero_extendqihi2"
1493   [(set (match_operand:HI 0 "general_operand" "=d,&d")
1494         (zero_extend:HI (match_operand:QI 1 "general_operand" "0i,m")))]
1495   ""
1496   "*
1497 {
1498   check_label_emit ();
1499   if (REG_P (operands[1]))
1500     {
1501       CC_STATUS_SET (operands[0], operands[1]);
1502       mvs_check_page (0, 4, 4);
1503       return \"N        %0,=X'000000FF'\";
1504     }
1505   if (GET_CODE (operands[1]) == CONST_INT)
1506     {
1507       mvs_check_page (0, 4, 0);
1508       return \"LA       %0,%c1\";
1509     }
1510   CC_STATUS_INIT;
1511   mvs_check_page (0, 8, 0);
1512   return \"SLR  %0,%0\;IC       %0,%1\";
1513 }")
1514
1515 ;
1516 ; truncsihi2 instruction pattern(s).
1517 ;
1518
1519 (define_insn "truncsihi2"
1520   [(set (match_operand:HI 0 "general_operand" "=d,m")
1521         (truncate:HI (match_operand:SI 1 "general_operand" "0,d")))]
1522   ""
1523   "*
1524 {
1525   check_label_emit ();
1526   if (REG_P (operands[0]))
1527     {
1528       CC_STATUS_SET (operands[0], operands[1]);
1529       mvs_check_page (0, 8, 0);
1530       return \"SLL      %0,16\;SRA      %0,16\";
1531     }
1532   mvs_check_page (0, 4, 0);
1533   return \"STH  %1,%0\";
1534 }")
1535
1536 ;
1537 ; fix_truncdfsi2 instruction pattern(s).
1538 ;
1539
1540 (define_insn "fix_truncdfsi2"
1541   [(set (match_operand:SI 0 "general_operand" "=d")
1542         (fix:SI (truncate:DF (match_operand:DF 1 "general_operand" "f"))))
1543         (clobber (reg:DF 16))]
1544   ""
1545   "*
1546 {
1547   check_label_emit ();
1548   CC_STATUS_INIT;
1549   if (REGNO (operands[1]) == 16)
1550     {
1551       mvs_check_page (0, 12, 8);
1552       return \"AD       0,=XL8'4F08000000000000'\;STD   0,140(,13)\;L   %0,144(,13)\";
1553     }
1554   mvs_check_page (0, 14, 8);
1555   return \"LDR  0,%1\;AD        0,=XL8'4F08000000000000'\;STD   0,140(,13)\;L   %0,144(,13)\";
1556 }")
1557
1558 ;
1559 ; floatsidf2 instruction pattern(s).
1560 ;
1561 ; Uses the float field of the TCA.
1562 ;
1563
1564 (define_insn "floatsidf2"
1565   [(set (match_operand:DF 0 "general_operand" "=f")
1566         (float:DF (match_operand:SI 1 "general_operand" "d")))]
1567   ""
1568   "*
1569 {
1570   check_label_emit ();
1571   CC_STATUS_INIT;
1572   mvs_check_page (0, 16, 8);
1573   return \"ST   %1,508(,12)\;XI 508(12),128\;LD %0,504(,12)\;SD %0,=XL8'4E00000080000000'\";
1574 }")
1575
1576 ;
1577 ; truncdfsf2 instruction pattern(s).
1578 ;
1579
1580 (define_insn "truncdfsf2"
1581   [(set (match_operand:SF 0 "general_operand" "=f")
1582         (float_truncate:SF (match_operand:DF 1 "general_operand" "f")))]
1583   ""
1584   "*
1585 {
1586   check_label_emit ();
1587   mvs_check_page (0, 2, 0);
1588   return \"LRER %0,%1\";
1589 }")
1590
1591 ;
1592 ; extendsfdf2 instruction pattern(s).
1593 ;
1594
1595 (define_insn "extendsfdf2"
1596   [(set (match_operand:DF 0 "general_operand" "=f")
1597         (float_extend:DF (match_operand:SF 1 "general_operand" "fmF")))]
1598   ""
1599   "*
1600 {
1601   check_label_emit ();
1602   CC_STATUS_SET (0, const0_rtx);
1603   if (FP_REG_P (operands[1]))
1604     {
1605       if (REGNO (operands[0]) == REGNO (operands[1]))
1606         {
1607           mvs_check_page (0, 10, 0);
1608           return \"STE  %1,140(,13)\;SDR        %0,%0\;LE       %0,140(,13)\";
1609         }
1610       mvs_check_page (0, 4, 0);
1611       return \"SDR      %0,%0\;LER      %0,%1\";
1612     }
1613   mvs_check_page (0, 6, 0);
1614   return \"SDR  %0,%0\;LE       %0,%1\";
1615 }")
1616
1617 ;;
1618 ;;- Add instructions.
1619 ;;
1620
1621 ;
1622 ; adddi3 instruction pattern(s).
1623 ;
1624
1625 (define_expand "adddi3"
1626   [(set (match_operand:DI 0 "general_operand" "")
1627         (plus:DI (match_operand:DI 1 "general_operand" "")
1628                  (match_operand:DI 2 "general_operand" "")))]
1629   ""
1630   "
1631 {
1632   rtx label = gen_label_rtx ();
1633   rtx op0_high = operand_subword (operands[0], 0, 1, DImode);
1634   rtx op0_low = gen_lowpart (SImode, operands[0]);
1635
1636   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1637                     gen_rtx (PLUS, SImode,
1638                             operand_subword (operands[1], 0, 1, DImode),
1639                             operand_subword (operands[2], 0, 1, DImode))));
1640   emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
1641               gen_rtx (SET, VOIDmode, op0_low,
1642                       gen_rtx (PLUS, SImode, gen_lowpart (SImode, operands[1]),
1643                               gen_lowpart (SImode, operands[2]))),
1644               gen_rtx (USE, VOIDmode, gen_rtx (LABEL_REF, VOIDmode, label)))));
1645   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1646                     gen_rtx (PLUS, SImode, op0_high,
1647                             GEN_INT (1))));
1648   emit_label (label);
1649   DONE;
1650 }")
1651
1652 (define_insn ""
1653   [(set (match_operand:SI 0 "general_operand" "=d")
1654         (plus:SI (match_operand:SI 1 "general_operand" "%0")
1655                  (match_operand:SI 2 "general_operand" "g")))
1656    (use (label_ref (match_operand 3 "" "")))]
1657   ""
1658   "*
1659 {
1660   int onpage;
1661
1662   check_label_emit ();
1663   onpage = mvs_check_label (CODE_LABEL_NUMBER (operands[3]));
1664   if (REG_P (operands[2]))
1665     {
1666       if (!onpage)
1667         {
1668           mvs_check_page (0, 8, 4);
1669           return \"ALR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1670         }
1671       if (mvs_check_page (0, 6, 0))
1672         {
1673           mvs_check_page (0, 2, 4);
1674           return \"ALR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1675         }
1676       return \"ALR      %0,%2\;BC       12,%l3\";
1677     }
1678   if (!onpage)
1679     {
1680       mvs_check_page (0, 10, 4);
1681       return \"AL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1682     }
1683   if (mvs_check_page (0, 8 ,0))
1684     {
1685       mvs_check_page (0, 2, 4);
1686       return \"AL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1687     }
1688   return \"AL   %0,%2\;BC       12,%l3\";
1689 }")
1690
1691 ;
1692 ; addsi3 instruction pattern(s).
1693 ;
1694 ; The following insn is used when it is known that operand one is an address,
1695 ; frame, stack or argument pointer, and operand two is a constant that is
1696 ; small enough to fit in the displacement field.
1697 ; Notice that we can't allow the frame pointer to used as a normal register
1698 ; because of this insn.
1699 ;
1700
1701 (define_insn ""
1702   [(set (match_operand:SI 0 "register_operand" "=d")
1703         (plus:SI (match_operand:SI 1 "general_operand" "%a")
1704                  (match_operand:SI 2 "immediate_operand" "J")))]
1705   "((REGNO (operands[1]) == FRAME_POINTER_REGNUM || REGNO (operands[1]) == ARG_POINTER_REGNUM || REGNO (operands[1]) == STACK_POINTER_REGNUM) && (unsigned) INTVAL (operands[2]) < 4096)"
1706   "*
1707 {
1708   check_label_emit ();
1709   CC_STATUS_INIT;
1710   mvs_check_page (0, 4, 0);
1711   return \"LA   %0,%c2(,%1)\";
1712 }")
1713
1714 ; This insn handles additions that are relative to the frame pointer.
1715
1716 (define_insn ""
1717   [(set (match_operand:SI 0 "register_operand" "=d")
1718          (plus:SI (match_operand:SI 1 "register_operand" "%a")
1719                   (match_operand:SI 2 "immediate_operand" "i")))]
1720   "REGNO (operands[1]) == FRAME_POINTER_REGNUM"
1721   "*
1722 {
1723   check_label_emit ();
1724   if ((unsigned) INTVAL (operands[2]) < 4096)
1725     {
1726       mvs_check_page (0, 4, 0);
1727       return \"LA       %0,%c2(,%1)\";
1728     }
1729   if (REGNO (operands[1]) == REGNO (operands[0]))
1730     {
1731       mvs_check_page (0, 4, 0);
1732       return \"A        %0,%2\";
1733     }
1734   mvs_check_page (0, 6, 0);
1735   return \"L    %0,%2\;AR       %0,%1\";
1736 }")
1737
1738 (define_insn "addsi3"
1739   [(set (match_operand:SI 0 "general_operand" "=d")
1740         (plus:SI (match_operand:SI 1 "general_operand" "%0")
1741                  (match_operand:SI 2 "general_operand" "g")))]
1742   ""
1743   "*
1744 {
1745   check_label_emit ();
1746   if (REG_P (operands[2]))
1747     {
1748       mvs_check_page (0, 2, 0);
1749       return \"AR       %0,%2\";
1750     }
1751   if (GET_CODE (operands[2]) == CONST_INT)
1752     {
1753       if (INTVAL (operands[2]) == -1)
1754         {
1755           CC_STATUS_INIT;
1756           mvs_check_page (0, 2, 0);
1757           return \"BCTR %0,0\";
1758         }
1759     }
1760   mvs_check_page (0, 4, 0);
1761   return \"A    %0,%2\";
1762 }")
1763
1764 ;
1765 ; addhi3 instruction pattern(s).
1766 ;
1767
1768 (define_insn "addhi3"
1769   [(set (match_operand:HI 0 "general_operand" "=d")
1770         (plus:HI (match_operand:HI 1 "general_operand" "%0")
1771                  (match_operand:HI 2 "general_operand" "dmi")))]
1772   ""
1773   "*
1774 {
1775   check_label_emit ();
1776   if (REG_P (operands[2]))
1777     {
1778       mvs_check_page (0, 8, 0);
1779       return \"STH      %2,140(,13)\;AH %0,140(,13)\";
1780     }
1781   if (GET_CODE (operands[2]) == CONST_INT)
1782     {
1783       if (INTVAL (operands[2]) == -1)
1784         {
1785           CC_STATUS_INIT;
1786           mvs_check_page (0, 2, 0);
1787           return \"BCTR %0,0\";
1788         }
1789       mvs_check_page (0, 4, 0);
1790       return \"AH       %0,%H2\";
1791     }
1792   mvs_check_page (0, 4, 0);
1793   return \"AH   %0,%2\";
1794 }")
1795
1796 ;
1797 ; addqi3 instruction pattern(s).
1798 ;
1799
1800 (define_insn "addqi3"
1801   [(set (match_operand:QI 0 "general_operand" "=d")
1802         (plus:QI (match_operand:QI 1 "general_operand" "%a")
1803                  (match_operand:QI 2 "general_operand" "ai")))]
1804   ""
1805   "*
1806 {
1807   check_label_emit ();
1808   CC_STATUS_INIT;
1809   mvs_check_page (0, 4, 0);
1810   if (REG_P (operands[2]))
1811     return \"LA %0,0(%1,%2)\";
1812   return \"LA   %0,%B2(,%1)\";
1813 }")
1814
1815 ;
1816 ; adddf3 instruction pattern(s).
1817 ;
1818
1819 (define_insn "adddf3"
1820   [(set (match_operand:DF 0 "general_operand" "=f")
1821         (plus:DF (match_operand:DF 1 "general_operand" "%0")
1822                  (match_operand:DF 2 "general_operand" "fmF")))]
1823   ""
1824   "*
1825 {
1826   check_label_emit ();
1827   if (FP_REG_P (operands[2]))
1828     {
1829       mvs_check_page (0, 2, 0);
1830       return \"ADR      %0,%2\";
1831     }
1832   mvs_check_page (0, 4, 0);
1833   return \"AD   %0,%2\";
1834 }")
1835
1836 ;
1837 ; addsf3 instruction pattern(s).
1838 ;
1839
1840 (define_insn "addsf3"
1841   [(set (match_operand:SF 0 "general_operand" "=f")
1842         (plus:SF (match_operand:SF 1 "general_operand" "%0")
1843                  (match_operand:SF 2 "general_operand" "fmF")))]
1844   ""
1845   "*
1846 {
1847   check_label_emit ();
1848   if (FP_REG_P (operands[2]))
1849     {
1850       mvs_check_page (0, 2, 0);
1851       return \"AER      %0,%2\";
1852     }
1853   mvs_check_page (0, 4, 0);
1854   return \"AE   %0,%2\";
1855 }")
1856
1857 ;;
1858 ;;- Subtract instructions.
1859 ;;
1860
1861 ;
1862 ; subdi3 instruction pattern(s).
1863 ;
1864
1865 (define_expand "subdi3"
1866   [(set (match_operand:DI 0 "general_operand" "")
1867         (minus:DI (match_operand:DI 1 "general_operand" "")
1868                   (match_operand:DI 2 "general_operand" "")))]
1869   ""
1870   "
1871 {
1872   rtx label = gen_label_rtx ();
1873   rtx op0_high = operand_subword (operands[0], 0, 1, DImode);
1874   rtx op0_low = gen_lowpart (SImode, operands[0]);
1875
1876   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1877                     gen_rtx (MINUS, SImode,
1878                               operand_subword (operands[1], 0, 1, DImode),
1879                               operand_subword (operands[2], 0, 1, DImode))));
1880   emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
1881                     gen_rtx (SET, VOIDmode, op0_low,
1882                               gen_rtx (MINUS, SImode,
1883                                       gen_lowpart (SImode, operands[1]),
1884                                       gen_lowpart (SImode, operands[2]))),
1885                     gen_rtx (USE, VOIDmode,
1886                               gen_rtx (LABEL_REF, VOIDmode, label)))));
1887   emit_insn (gen_rtx (SET, VOIDmode, op0_high,
1888                       gen_rtx (MINUS, SImode, op0_high,
1889                               GEN_INT (1))));
1890   emit_label (label);
1891   DONE;
1892 }")
1893
1894 (define_insn ""
1895   [(set (match_operand:SI 0 "general_operand" "=d")
1896         (minus:SI (match_operand:SI 1 "general_operand" "0")
1897                   (match_operand:SI 2 "general_operand" "g")))
1898    (use (label_ref (match_operand 3 "" "")))]
1899   ""
1900   "*
1901 {
1902   int onpage;
1903
1904   check_label_emit ();
1905   CC_STATUS_INIT;
1906   onpage = mvs_check_label (CODE_LABEL_NUMBER (operands[3]));
1907   if (REG_P (operands[2]))
1908     {
1909       if (!onpage)
1910         {
1911           mvs_check_page (0, 8, 4);
1912           return \"SLR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1913         }
1914       if (mvs_check_page (0, 6, 0))
1915         {
1916           mvs_check_page (0, 2, 4);
1917           return \"SLR  %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1918         }
1919       return \"SLR      %0,%2\;BC       12,%l3\";
1920     }
1921   if (!onpage)
1922     {
1923       mvs_check_page (0, 10, 4);
1924       return \"SL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1925     }
1926   if (mvs_check_page (0, 8, 0))
1927     {
1928       mvs_check_page (0, 2, 4);
1929       return \"SL       %0,%2\;L        14,=A(%l3)\;BCR 12,14\";
1930     }
1931   return \"SL   %0,%2\;BC       12,%l3\";
1932 }")
1933
1934 ;
1935 ; subsi3 instruction pattern(s).
1936 ;
1937
1938 (define_insn "subsi3"
1939   [(set (match_operand:SI 0 "general_operand" "=d")
1940         (minus:SI (match_operand:SI 1 "general_operand" "0")
1941                   (match_operand:SI 2 "general_operand" "g")))]
1942   ""
1943   "*
1944 {
1945   check_label_emit ();
1946   if (REG_P (operands[2]))
1947     {
1948       mvs_check_page (0, 2, 0);
1949       return \"SR       %0,%2\";
1950     }
1951   if (operands[2] == const1_rtx)
1952     {
1953       CC_STATUS_INIT;
1954       mvs_check_page (0, 2, 0);
1955       return \"BCTR     %0,0\";
1956     }
1957   mvs_check_page (0, 4, 0);
1958   return \"S    %0,%2\";
1959 }")
1960
1961 ;
1962 ; subhi3 instruction pattern(s).
1963 ;
1964
1965 (define_insn "subhi3"
1966   [(set (match_operand:HI 0 "general_operand" "=d")
1967         (minus:HI (match_operand:HI 1 "general_operand" "0")
1968                   (match_operand:HI 2 "general_operand" "g")))]
1969   ""
1970   "*
1971 {
1972   check_label_emit ();
1973   if (REG_P (operands[2]))
1974     {
1975       mvs_check_page (0, 8, 0);
1976       return \"STH      %2,140(,13)\;SH %0,140(,13)\";
1977     }
1978   if (operands[2] == const1_rtx)
1979     {
1980       CC_STATUS_INIT;
1981       mvs_check_page (0, 2, 0);
1982       return \"BCTR     %0,0\";
1983     }
1984   if (GET_CODE (operands[2]) == CONST_INT)
1985     {
1986       mvs_check_page (0, 4, 0);
1987       return \"SH       %0,%H2\";
1988     }
1989   mvs_check_page (0, 4, 0);
1990   return \"SH   %0,%2\";
1991 }")
1992
1993 ;
1994 ; subqi3 instruction pattern(s).
1995 ;
1996
1997 (define_expand "subqi3"
1998   [(set (match_operand:QI 0 "general_operand" "=d")
1999         (minus:QI (match_operand:QI 1 "general_operand" "0")
2000                   (match_operand:QI 2 "general_operand" "di")))]
2001   ""
2002   "
2003 {
2004   if (REG_P (operands[2]))
2005     {
2006       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2007                         gen_rtx (MINUS, QImode, operands[1], operands[2])));
2008     }
2009   else
2010     {
2011       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2012                         gen_rtx (PLUS, QImode, operands[1],
2013                                  negate_rtx (QImode, operands[2]))));
2014     }
2015   DONE;
2016 }")
2017
2018 (define_insn ""
2019   [(set (match_operand:QI 0 "register_operand" "=d")
2020         (minus:QI (match_operand:QI 1 "register_operand" "0")
2021                  (match_operand:QI 2 "register_operand" "d")))]
2022   ""
2023   "*
2024 {
2025   check_label_emit ();
2026   CC_STATUS_INIT;
2027   mvs_check_page (0, 2, 0);
2028   return \"SR   %0,%2\";
2029 }")
2030
2031 ;
2032 ; subdf3 instruction pattern(s).
2033 ;
2034
2035 (define_insn "subdf3"
2036   [(set (match_operand:DF 0 "general_operand" "=f")
2037         (minus:DF (match_operand:DF 1 "general_operand" "0")
2038                   (match_operand:DF 2 "general_operand" "fmF")))]
2039   ""
2040   "*
2041 {
2042   check_label_emit ();
2043   if (FP_REG_P (operands[2]))
2044     {
2045       mvs_check_page (0, 2, 0);
2046       return \"SDR      %0,%2\";
2047     }
2048   mvs_check_page (0, 4, 0);
2049   return \"SD   %0,%2\";
2050 }")
2051
2052 ;
2053 ; subsf3 instruction pattern(s).
2054 ;
2055
2056 (define_insn "subsf3"
2057   [(set (match_operand:SF 0 "general_operand" "=f")
2058         (minus:SF (match_operand:SF 1 "general_operand" "0")
2059                   (match_operand:SF 2 "general_operand" "fmF")))]
2060   ""
2061   "*
2062 {
2063   check_label_emit ();
2064   if (FP_REG_P (operands[2]))
2065     {
2066       mvs_check_page (0, 2, 0);
2067       return \"SER      %0,%2\";
2068     }
2069   mvs_check_page (0, 4, 0);
2070   return \"SE   %0,%2\";
2071 }")
2072
2073 ;;
2074 ;;- Multiply instructions.
2075 ;;
2076
2077 ;
2078 ; mulsi3 instruction pattern(s).
2079 ;
2080
2081 (define_expand "mulsi3"
2082   [(set (match_operand:SI 0 "general_operand" "")
2083         (mult:SI (match_operand:SI 1 "general_operand" "")
2084                  (match_operand:SI 2 "general_operand" "")))]
2085   ""
2086   "
2087 {
2088   if (GET_CODE (operands[1]) == CONST_INT
2089       && CONST_OK_FOR_LETTER_P (INTVAL (operands[1]), 'K'))
2090     {
2091       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2092                           gen_rtx (MULT, SImode, operands[2], operands[1])));
2093     }
2094   else if (GET_CODE (operands[2]) == CONST_INT
2095            && CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
2096     {
2097       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2098                           gen_rtx (MULT, SImode, operands[1], operands[2])));
2099     }
2100   else
2101     {
2102       rtx r = gen_reg_rtx (DImode);
2103
2104       emit_insn (gen_rtx (SET, VOIDmode,
2105                           gen_rtx (SUBREG, SImode, r, 1), operands[1]));
2106       emit_insn (gen_rtx (SET, VOIDmode, r,
2107                           gen_rtx (MULT, SImode, r, operands[2])));
2108       emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2109                           gen_rtx (SUBREG, SImode, r, 1)));
2110     }
2111   DONE;
2112 }")
2113
2114 (define_insn ""
2115   [(set (match_operand:SI 0 "register_operand" "=d")
2116         (mult:SI (match_operand:SI 1 "general_operand" "%0")
2117                  (match_operand:SI 2 "immediate_operand" "K")))]
2118   ""
2119   "*
2120 {
2121   check_label_emit ();
2122   mvs_check_page (0, 4, 0);
2123   return \"MH   %0,%H2\";
2124 }")
2125
2126 (define_insn ""
2127   [(set (match_operand:DI 0 "register_operand" "=d")
2128         (mult:DI (match_operand:DI 1 "general_operand" "%0")
2129                  (match_operand:SI 2 "general_operand" "g")))]
2130   ""
2131   "*
2132 {
2133   check_label_emit ();
2134   if (REG_P (operands[2]))
2135     {
2136       mvs_check_page (0, 2, 0);
2137       return \"MR       %0,%2\";
2138     }
2139   mvs_check_page (0, 4, 0);
2140   return \"M    %0,%2\";
2141 }")
2142
2143 ;
2144 ; muldf3 instruction pattern(s).
2145 ;
2146
2147 (define_insn "muldf3"
2148   [(set (match_operand:DF 0 "general_operand" "=f")
2149         (mult:DF (match_operand:DF 1 "general_operand" "%0")
2150                  (match_operand:DF 2 "general_operand" "fmF")))]
2151   ""
2152   "*
2153 {
2154   check_label_emit ();
2155   if (FP_REG_P (operands[2]))
2156     {
2157       mvs_check_page (0, 2, 0);
2158       return \"MDR      %0,%2\";
2159     }
2160   mvs_check_page (0, 4, 0);
2161   return \"MD   %0,%2\";
2162 }")
2163
2164 ;
2165 ; mulsf3 instruction pattern(s).
2166 ;
2167
2168 (define_insn "mulsf3"
2169   [(set (match_operand:SF 0 "general_operand" "=f")
2170         (mult:SF (match_operand:SF 1 "general_operand" "%0")
2171                  (match_operand:SF 2 "general_operand" "fmF")))]
2172   ""
2173   "*
2174 {
2175   check_label_emit ();
2176   if (FP_REG_P (operands[2]))
2177     {
2178       mvs_check_page (0, 2, 0);
2179       return \"MER      %0,%2\";
2180     }
2181   mvs_check_page (0, 4, 0);
2182   return \"ME   %0,%2\";
2183 }")
2184
2185 ;;
2186 ;;- Divide instructions.
2187 ;;
2188
2189 ;
2190 ; divsi3 instruction pattern(s).
2191 ;
2192
2193 (define_expand "divsi3"
2194   [(set (match_operand:SI 0 "general_operand" "")
2195         (div:SI (match_operand:SI 1 "general_operand" "")
2196                 (match_operand:SI 2 "general_operand" "")))]
2197   ""
2198   "
2199 {
2200   rtx r = gen_reg_rtx (DImode);
2201
2202   emit_insn (gen_extendsidi2 (r, operands[1]));
2203   emit_insn (gen_rtx (SET, VOIDmode, r,
2204                         gen_rtx (DIV, SImode, r, operands[2])));
2205   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2206                         gen_rtx (SUBREG, SImode, r, 1)));
2207   DONE;
2208 }")
2209
2210
2211 ;
2212 ; udivsi3 instruction pattern(s).
2213 ;
2214
2215 (define_expand "udivsi3"
2216   [(set (match_operand:SI 0 "general_operand" "")
2217         (udiv:SI (match_operand:SI 1 "general_operand" "")
2218                  (match_operand:SI 2 "general_operand" "")))]
2219   ""
2220   "
2221 {
2222   rtx dr = gen_reg_rtx (DImode);
2223   rtx dr_0 = gen_rtx (SUBREG, SImode, dr, 0);
2224   rtx dr_1 = gen_rtx (SUBREG, SImode, dr, 1);
2225
2226
2227   if (GET_CODE (operands[2]) == CONST_INT)
2228     {
2229       if (INTVAL (operands[2]) > 0)
2230         {
2231           emit_insn (gen_zero_extendsidi2 (dr, operands[1]));
2232           emit_insn (gen_rtx (SET, VOIDmode, dr,
2233                         gen_rtx (DIV, SImode, dr, operands[2])));
2234         }
2235       else
2236         {
2237           rtx label1 = gen_label_rtx ();
2238
2239           emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2240           emit_insn (gen_rtx (SET, VOIDmode, dr_1, const0_rtx));
2241           emit_insn (gen_cmpsi (dr_0, operands[2]));
2242           emit_jump_insn (gen_bltu (label1));
2243           emit_insn (gen_rtx (SET, VOIDmode, dr_1, const1_rtx));
2244           emit_label (label1);
2245         }
2246     }
2247   else
2248     {
2249       rtx label1 = gen_label_rtx ();
2250       rtx label2 = gen_label_rtx ();
2251       rtx label3 = gen_label_rtx ();
2252       rtx sr = gen_reg_rtx (SImode);
2253
2254       emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2255       emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2256       emit_insn (gen_rtx (SET, VOIDmode, dr_1, const0_rtx));
2257       emit_insn (gen_cmpsi (sr, dr_0));
2258       emit_jump_insn (gen_bgtu (label3));
2259       emit_insn (gen_cmpsi (sr, const1_rtx));
2260       emit_jump_insn (gen_blt (label2));
2261       emit_jump_insn (gen_beq (label1));
2262       emit_insn (gen_rtx (SET, VOIDmode, dr,
2263                           gen_rtx (LSHIFTRT, DImode, dr,
2264                                     GEN_INT (32))));
2265       emit_insn (gen_rtx (SET, VOIDmode, dr,
2266                     gen_rtx (DIV, SImode, dr, sr)));
2267       emit_jump_insn (gen_jump (label3));
2268       emit_label (label1);
2269       emit_insn (gen_rtx (SET, VOIDmode, dr_1, dr_0));
2270       emit_jump_insn (gen_jump (label3));
2271       emit_label (label2);
2272       emit_insn (gen_rtx (SET, VOIDmode, dr_1, const1_rtx));
2273       emit_label (label3);
2274     }
2275   emit_insn (gen_rtx (SET, VOIDmode, operands[0], dr_1));
2276
2277   DONE;
2278 }")
2279
2280 ; This is used by divsi3 & udivsi3.
2281
2282 (define_insn ""
2283   [(set (match_operand:DI 0 "register_operand" "=d")
2284         (div:DI (match_operand:DI 1 "register_operand" "0")
2285                 (match_operand:SI 2 "general_operand" "")))]
2286   ""
2287   "*
2288 {
2289   check_label_emit ();
2290   if (REG_P (operands[2]))
2291     {
2292       mvs_check_page (0, 2, 0);
2293       return \"DR       %0,%2\";
2294     }
2295   mvs_check_page (0, 4, 0);
2296   return \"D    %0,%2\";
2297 }")
2298
2299 ;
2300 ; divdf3 instruction pattern(s).
2301 ;
2302
2303 (define_insn "divdf3"
2304   [(set (match_operand:DF 0 "general_operand" "=f")
2305         (div:DF (match_operand:DF 1 "general_operand" "0")
2306                 (match_operand:DF 2 "general_operand" "fmF")))]
2307   ""
2308   "*
2309 {
2310   check_label_emit ();
2311   if (FP_REG_P (operands[2]))
2312     {
2313       mvs_check_page (0, 2, 0);
2314       return \"DDR      %0,%2\";
2315     }
2316   mvs_check_page (0, 4, 0);
2317   return \"DD   %0,%2\";
2318 }")
2319
2320 ;
2321 ; divsf3 instruction pattern(s).
2322 ;
2323
2324 (define_insn "divsf3"
2325   [(set (match_operand:SF 0 "general_operand" "=f")
2326         (div:SF (match_operand:SF 1 "general_operand" "0")
2327                 (match_operand:SF 2 "general_operand" "fmF")))]
2328   ""
2329   "*
2330 {
2331   check_label_emit ();
2332   if (FP_REG_P (operands[2]))
2333     {
2334       mvs_check_page (0, 2, 0);
2335       return \"DER      %0,%2\";
2336     }
2337   mvs_check_page (0, 4, 0);
2338   return \"DE   %0,%2\";
2339 }")
2340
2341 ;;
2342 ;;- Modulo instructions.
2343 ;;
2344
2345 ;
2346 ; modsi3 instruction pattern(s).
2347 ;
2348
2349 (define_expand "modsi3"
2350   [(set (match_operand:SI 0 "general_operand" "")
2351         (mod:SI (match_operand:SI 1 "general_operand" "")
2352                 (match_operand:SI 2 "general_operand" "")))]
2353   ""
2354   "
2355 {
2356   rtx r = gen_reg_rtx (DImode);
2357
2358   emit_insn (gen_extendsidi2 (r, operands[1]));
2359   emit_insn (gen_rtx (SET, VOIDmode, r,
2360                         gen_rtx (MOD, SImode, r, operands[2])));
2361   emit_insn (gen_rtx (SET, VOIDmode, operands[0],
2362                         gen_rtx (SUBREG, SImode, r, 0)));
2363   DONE;
2364 }")
2365
2366 ;
2367 ; umodsi3 instruction pattern(s).
2368 ;
2369
2370 (define_expand "umodsi3"
2371   [(set (match_operand:SI 0 "general_operand" "")
2372         (umod:SI (match_operand:SI 1 "general_operand" "")
2373                  (match_operand:SI 2 "general_operand" "")))]
2374   ""
2375   "
2376 {
2377   rtx dr = gen_reg_rtx (DImode);
2378   rtx dr_0 = gen_rtx (SUBREG, SImode, dr, 0);
2379   rtx dr_1 = gen_rtx (SUBREG, SImode, dr, 1);
2380
2381   emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2382
2383   if (GET_CODE (operands[2]) == CONST_INT)
2384     {
2385       if (INTVAL (operands[2]) > 0)
2386         {
2387           emit_insn (gen_rtx (SET, VOIDmode, dr,
2388                               gen_rtx (LSHIFTRT, DImode, dr,
2389                                         GEN_INT (32))));
2390           emit_insn (gen_rtx (SET, VOIDmode, dr,
2391                         gen_rtx (MOD, SImode, dr, operands[2])));
2392         }
2393       else
2394         {
2395           rtx label1 = gen_label_rtx ();
2396           rtx sr = gen_reg_rtx (SImode);
2397
2398           emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2399           emit_insn (gen_cmpsi (dr_0, sr));
2400           emit_jump_insn (gen_bltu (label1));
2401           emit_insn (gen_rtx (SET, VOIDmode, sr, gen_rtx (ABS, SImode, sr)));
2402           emit_insn (gen_rtx (SET, VOIDmode, dr_0,
2403                               gen_rtx (PLUS, SImode, dr_0, sr)));
2404           emit_label (label1);
2405         }
2406     }
2407   else
2408     {
2409       rtx label1 = gen_label_rtx ();
2410       rtx label2 = gen_label_rtx ();
2411       rtx label3 = gen_label_rtx ();
2412       rtx sr = gen_reg_rtx (SImode);
2413
2414       emit_insn (gen_rtx (SET, VOIDmode, dr_0, operands[1]));
2415       emit_insn (gen_rtx (SET, VOIDmode, sr, operands[2]));
2416       emit_insn (gen_cmpsi (sr, dr_0));
2417       emit_jump_insn (gen_bgtu (label3));
2418       emit_insn (gen_cmpsi (sr, const1_rtx));
2419       emit_jump_insn (gen_blt (label2));
2420       emit_jump_insn (gen_beq (label1));
2421       emit_insn (gen_rtx (SET, VOIDmode, dr,
2422                           gen_rtx (LSHIFTRT, DImode, dr,
2423                                     GEN_INT (32))));
2424       emit_insn (gen_rtx (SET, VOIDmode, dr, gen_rtx (MOD, SImode, dr, sr)));
2425       emit_jump_insn (gen_jump (label3));
2426       emit_label (label1);
2427       emit_insn (gen_rtx (SET, VOIDmode, dr_0, const0_rtx));
2428       emit_jump_insn (gen_jump (label3));
2429       emit_label (label2);
2430       emit_insn (gen_rtx (SET, VOIDmode, dr_0,
2431                           gen_rtx (MINUS, SImode, dr_0, sr)));
2432       emit_label (label3);
2433
2434     }
2435   emit_insn (gen_rtx (SET, VOIDmode, operands[0], dr_0));
2436
2437   DONE;
2438 }")
2439
2440 ; This is used by modsi3 & umodsi3.
2441
2442 (define_insn ""
2443   [(set (match_operand:DI 0 "register_operand" "=d")
2444         (mod:DI (match_operand:DI 1 "register_operand" "0")
2445                 (match_operand:SI 2 "general_operand" "")))]
2446   ""
2447   "*
2448 {
2449   check_label_emit ();
2450   if (REG_P (operands[2]))
2451     {
2452       mvs_check_page (0, 2, 0);
2453       return \"DR       %0,%2\";
2454     }
2455   mvs_check_page (0, 4, 0);
2456   return \"D    %0,%2\";
2457 }")
2458
2459 ;;
2460 ;;- And instructions.
2461 ;;
2462
2463 ;
2464 ; anddi3 instruction pattern(s).
2465 ;
2466
2467 ;(define_expand "anddi3"
2468 ;  [(set (match_operand:DI 0 "general_operand" "")
2469 ;       (and:DI (match_operand:DI 1 "general_operand" "")
2470 ;               (match_operand:DI 2 "general_operand" "")))]
2471 ;  ""
2472 ;  "
2473 ;{
2474 ;  rtx gen_andsi3();
2475 ;
2476 ;  emit_insn (gen_andsi3 (operand_subword (operands[0], 0, 1, DImode),
2477 ;                        operand_subword (operands[1], 0, 1, DImode),
2478 ;                        operand_subword (operands[2], 0, 1, DImode)));
2479 ;  emit_insn (gen_andsi3 (gen_lowpart (SImode, operands[0]),
2480 ;                        gen_lowpart (SImode, operands[1]),
2481 ;                        gen_lowpart (SImode, operands[2])));
2482 ;  DONE;
2483 ;}")
2484
2485 ;
2486 ; andsi3 instruction pattern(s).
2487 ;
2488
2489 (define_insn ""
2490   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2491         (and:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2492                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2493   "TARGET_CHAR_INSTRUCTIONS"
2494   "*
2495 {
2496   check_label_emit ();
2497   if (REG_P (operands[2]))
2498     {
2499       mvs_check_page (0, 2, 0);
2500       return \"NR       %0,%2\";
2501     }
2502   if (REG_P (operands[0]))
2503     {
2504       mvs_check_page (0, 4, 0);
2505       return \"N        %0,%2\";
2506     }
2507   CC_STATUS_INIT;
2508   mvs_check_page (0, 6, 0);
2509   return \"NC   %O0(4,%R0),%2\";
2510 }")
2511
2512 (define_insn "andsi3"
2513   [(set (match_operand:SI 0 "general_operand" "=d")
2514         (and:SI (match_operand:SI 1 "general_operand" "%0")
2515                 (match_operand:SI 2 "general_operand" "g")))]
2516   ""
2517   "*
2518 {
2519   check_label_emit ();
2520   if (REG_P (operands[2]))
2521     {
2522       mvs_check_page (0, 2, 0);
2523       return \"NR       %0,%2\";
2524     }
2525   mvs_check_page (0, 4, 0);
2526   return \"N    %0,%2\";
2527 }")
2528
2529 ;
2530 ; andhi3 instruction pattern(s).
2531 ;
2532
2533 (define_insn ""
2534   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2535         (and:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2536                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2537   "TARGET_CHAR_INSTRUCTIONS"
2538   "*
2539 {
2540   check_label_emit ();
2541   if (REG_P (operands[2]))
2542     {
2543       mvs_check_page (0, 2, 0);
2544       return \"NR       %0,%2\";
2545     }
2546   if (REG_P (operands[0]))
2547     {
2548       mvs_check_page (0, 4, 0);
2549       return \"N        %0,%2\";
2550     }
2551   CC_STATUS_INIT;
2552   if (GET_CODE (operands[2]) == CONST_INT)
2553     {
2554       mvs_check_page (0, 6, 0);
2555       return \"NC       %O0(2,%R0),%H2\";
2556     }
2557   mvs_check_page (0, 6, 0);
2558   return \"NC   %O0(2,%R0),%2\";
2559 }")
2560
2561 (define_insn "andhi3"
2562   [(set (match_operand:HI 0 "general_operand" "=d")
2563         (and:HI (match_operand:HI 1 "general_operand" "%0")
2564                 (match_operand:HI 2 "general_operand" "di")))]
2565   ""
2566   "*
2567 {
2568   check_label_emit ();
2569   if (GET_CODE (operands[2]) == CONST_INT)
2570     {
2571       mvs_check_page (0, 4, 0);
2572       return \"N        %0,%2\";
2573     }
2574   mvs_check_page (0, 2, 0);
2575   return \"NR   %0,%2\";
2576 }")
2577
2578 ;
2579 ; andqi3 instruction pattern(s).
2580 ;
2581
2582 (define_insn ""
2583   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2584         (and:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2585                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2586   "TARGET_CHAR_INSTRUCTIONS"
2587   "*
2588 {
2589   check_label_emit ();
2590   CC_STATUS_INIT;
2591   if (REG_P (operands[2]))
2592     {
2593       mvs_check_page (0, 2, 0);
2594       return \"NR       %0,%2\";
2595     }
2596   if (REG_P (operands[0]))
2597     {
2598       mvs_check_page (0, 4, 0);
2599       return \"N        %0,%2\";
2600     }
2601   if (GET_CODE (operands[2]) == CONST_INT)
2602     {
2603       mvs_check_page (0, 4, 0);
2604       return \"NI       %0,%B2\";
2605     }
2606   mvs_check_page (0, 6, 0);
2607   return \"NC   %O0(1,%R0),%2\";
2608 }")
2609
2610 (define_insn "andqi3"
2611   [(set (match_operand:QI 0 "general_operand" "=d")
2612         (and:QI (match_operand:QI 1 "general_operand" "%0")
2613                 (match_operand:QI 2 "general_operand" "di")))]
2614   ""
2615   "*
2616 {
2617   check_label_emit ();
2618   CC_STATUS_INIT;
2619   if (GET_CODE (operands[2]) == CONST_INT)
2620     {
2621       mvs_check_page (0, 4, 0);
2622       return \"N        %0,%2\";
2623     }
2624   mvs_check_page (0, 2, 0);
2625   return \"NR   %0,%2\";
2626 }")
2627
2628 ;;
2629 ;;- Bit set (inclusive or) instructions.
2630 ;;
2631
2632 ;
2633 ; iordi3 instruction pattern(s).
2634 ;
2635
2636 ;(define_expand "iordi3"
2637 ;  [(set (match_operand:DI 0 "general_operand" "")
2638 ;       (ior:DI (match_operand:DI 1 "general_operand" "")
2639 ;               (match_operand:DI 2 "general_operand" "")))]
2640 ;  ""
2641 ;  "
2642 ;{
2643 ;  rtx gen_iorsi3();
2644 ;
2645 ;  emit_insn (gen_iorsi3 (operand_subword (operands[0], 0, 1, DImode),
2646 ;                        operand_subword (operands[1], 0, 1, DImode),
2647 ;                        operand_subword (operands[2], 0, 1, DImode)));
2648 ;  emit_insn (gen_iorsi3 (gen_lowpart (SImode, operands[0]),
2649 ;                        gen_lowpart (SImode, operands[1]),
2650 ;                        gen_lowpart (SImode, operands[2])));
2651 ;  DONE;
2652 ;}")
2653
2654 ;
2655 ; iorsi3 instruction pattern(s).
2656 ;
2657
2658 (define_insn ""
2659   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2660         (ior:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2661                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2662   "TARGET_CHAR_INSTRUCTIONS"
2663   "*
2664 {
2665   check_label_emit ();
2666   if (REG_P (operands[2]))
2667     {
2668       mvs_check_page (0, 2, 0);
2669       return \"OR       %0,%2\";
2670     }
2671   if (REG_P (operands[0]))
2672     {
2673       mvs_check_page (0, 4, 0);
2674       return \"O        %0,%2\";
2675     }
2676   CC_STATUS_INIT;
2677   mvs_check_page (0, 6, 0);
2678   return \"OC   %O0(4,%R0),%2\";
2679 }")
2680
2681 (define_insn "iorsi3"
2682   [(set (match_operand:SI 0 "general_operand" "=d")
2683         (ior:SI (match_operand:SI 1 "general_operand" "%0")
2684                 (match_operand:SI 2 "general_operand" "g")))]
2685   ""
2686   "*
2687 {
2688   check_label_emit ();
2689   if (REG_P (operands[2]))
2690     {
2691       mvs_check_page (0, 2, 0);
2692       return \"OR       %0,%2\";
2693     }
2694   mvs_check_page (0, 4, 0);
2695   return \"O    %0,%2\";
2696 }")
2697
2698 ;
2699 ; iorhi3 instruction pattern(s).
2700 ;
2701
2702 (define_insn ""
2703   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2704         (ior:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2705                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2706   "TARGET_CHAR_INSTRUCTIONS"
2707   "*
2708 {
2709   check_label_emit ();
2710   if (REG_P (operands[2]))
2711     {
2712       mvs_check_page (0, 2, 0);
2713       return \"OR       %0,%2\";
2714     }
2715   if (REG_P (operands[0]))
2716     {
2717       mvs_check_page (0, 4, 0);
2718       return \"O        %0,%2\";
2719     }
2720   CC_STATUS_INIT;
2721   if (GET_CODE (operands[2]) == CONST_INT)
2722     {
2723       mvs_check_page (0, 6, 0);
2724       return \"OC       %O0(2,%R0),%H2\";
2725     }
2726   mvs_check_page (0, 6, 0);
2727   return \"OC   %O0(2,%R0),%2\";
2728 }")
2729
2730 (define_insn "iorhi3"
2731   [(set (match_operand:HI 0 "general_operand" "=d")
2732         (ior:HI (match_operand:HI 1 "general_operand" "%0")
2733                 (match_operand:HI 2 "general_operand" "di")))]
2734   ""
2735   "*
2736 {
2737   check_label_emit ();
2738   if (GET_CODE (operands[2]) == CONST_INT)
2739     {
2740       mvs_check_page (0, 4, 0);
2741       return \"O        %0,%2\";
2742     }
2743   mvs_check_page (0, 2, 0);
2744   return \"OR   %0,%2\";
2745 }")
2746
2747 ;
2748 ; iorqi3 instruction pattern(s).
2749 ;
2750
2751 (define_insn ""
2752   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2753         (ior:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2754                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2755   "TARGET_CHAR_INSTRUCTIONS"
2756   "*
2757 {
2758   check_label_emit ();
2759   CC_STATUS_INIT;
2760   if (REG_P (operands[2]))
2761     {
2762       mvs_check_page (0, 2, 0);
2763       return \"OR       %0,%2\";
2764     }
2765   if (REG_P (operands[0]))
2766     {
2767       mvs_check_page (0, 4, 0);
2768       return \"O        %0,%2\";
2769     }
2770   CC_STATUS_INIT;
2771   if (GET_CODE (operands[2]) == CONST_INT)
2772     {
2773       mvs_check_page (0, 4, 0);
2774       return \"OI       %0,%B2\";
2775     }
2776   mvs_check_page (0, 6, 0);
2777   return \"OC   %O0(1,%R0),%2\";
2778 }")
2779
2780 (define_insn "iorqi3"
2781   [(set (match_operand:QI 0 "general_operand" "=d")
2782         (ior:QI (match_operand:QI 1 "general_operand" "%0")
2783                 (match_operand:QI 2 "general_operand" "di")))]
2784   ""
2785   "*
2786 {
2787   check_label_emit ();
2788   CC_STATUS_INIT;
2789   if (GET_CODE (operands[2]) == CONST_INT)
2790     {
2791       mvs_check_page (0, 4, 0);
2792       return \"O        %0,%2\";
2793     }
2794   mvs_check_page (0, 2, 0);
2795   return \"OR   %0,%2\";
2796 }")
2797
2798 ;;
2799 ;;- Xor instructions.
2800 ;;
2801
2802 ;
2803 ; xordi3 instruction pattern(s).
2804 ;
2805
2806 ;(define_expand "xordi3"
2807 ;  [(set (match_operand:DI 0 "general_operand" "")
2808 ;       (xor:DI (match_operand:DI 1 "general_operand" "")
2809 ;               (match_operand:DI 2 "general_operand" "")))]
2810 ;  ""
2811 ;  "
2812 ;{
2813 ;  rtx gen_xorsi3();
2814 ;
2815 ;  emit_insn (gen_xorsi3 (operand_subword (operands[0], 0, 1, DImode),
2816 ;                        operand_subword (operands[1], 0, 1, DImode),
2817 ;                        operand_subword (operands[2], 0, 1, DImode)));
2818 ;  emit_insn (gen_xorsi3 (gen_lowpart (SImode, operands[0]),
2819 ;                        gen_lowpart (SImode, operands[1]),
2820 ;                        gen_lowpart (SImode, operands[2])));
2821 ;  DONE;
2822 ;}")
2823
2824 ;
2825 ; xorsi3 instruction pattern(s).
2826 ;
2827
2828 (define_insn ""
2829   [(set (match_operand:SI 0 "r_or_s_operand" "=d,m")
2830         (xor:SI (match_operand:SI 1 "r_or_s_operand" "%0,0")
2831                 (match_operand:SI 2 "r_or_s_operand" "g,mi")))]
2832   "TARGET_CHAR_INSTRUCTIONS"
2833   "*
2834 {
2835   check_label_emit ();
2836   if (REG_P (operands[2]))
2837     {
2838       mvs_check_page (0, 2, 0);
2839       return \"XR       %0,%2\";
2840     }
2841   if (REG_P (operands[0]))
2842     {
2843       mvs_check_page (0, 4, 0);
2844       return \"X        %0,%2\";
2845     }
2846   CC_STATUS_INIT;
2847   mvs_check_page (0, 6, 0);
2848   return \"XC   %O0(4,%R0),%2\";
2849 }")
2850
2851 (define_insn "xorsi3"
2852   [(set (match_operand:SI 0 "general_operand" "=d")
2853         (xor:SI (match_operand:SI 1 "general_operand" "%0")
2854                 (match_operand:SI 2 "general_operand" "g")))]
2855   ""
2856   "*
2857 {
2858   check_label_emit ();
2859   if (REG_P (operands[2]))
2860     {
2861       mvs_check_page (0, 2, 0);
2862       return \"XR       %0,%2\";
2863     }
2864   mvs_check_page (0, 4, 0);
2865   return \"X    %0,%2\";
2866 }")
2867
2868 ;
2869 ; xorhi3 instruction pattern(s).
2870 ;
2871
2872 (define_insn ""
2873   [(set (match_operand:HI 0 "r_or_s_operand" "=d,m")
2874         (xor:HI (match_operand:HI 1 "r_or_s_operand" "%0,0")
2875                 (match_operand:HI 2 "r_or_s_operand" "di,mi")))]
2876   "TARGET_CHAR_INSTRUCTIONS"
2877   "*
2878 {
2879   check_label_emit ();
2880   if (REG_P (operands[2]))
2881     {
2882       mvs_check_page (0, 2, 0);
2883       return \"XR       %0,%2\";
2884     }
2885   if (REG_P (operands[0]))
2886     {
2887       mvs_check_page (0, 4, 0);
2888       return \"X        %0,%2\";
2889     }
2890   CC_STATUS_INIT;
2891   if (GET_CODE (operands[2]) == CONST_INT)
2892     {
2893       mvs_check_page (0, 6, 0);
2894       return \"XC       %O0(2,%R0),%H2\";
2895     }
2896   mvs_check_page (0, 6, 0);
2897   return \"XC   %O0(2,%R0),%2\";
2898 }")
2899
2900 (define_insn "xorhi3"
2901   [(set (match_operand:HI 0 "general_operand" "=d")
2902         (xor:HI (match_operand:HI 1 "general_operand" "%0")
2903                 (match_operand:HI 2 "general_operand" "di")))]
2904   ""
2905   "*
2906 {
2907   check_label_emit ();
2908   if (GET_CODE (operands[2]) == CONST_INT)
2909     {
2910       mvs_check_page (0, 4, 0);
2911       return \"X        %0,%2\";
2912     }
2913   mvs_check_page (0, 2, 0);
2914   return \"XR   %0,%2\";
2915 }")
2916
2917 ;
2918 ; xorqi3 instruction pattern(s).
2919 ;
2920
2921 (define_insn ""
2922   [(set (match_operand:QI 0 "r_or_s_operand" "=d,m")
2923         (xor:QI (match_operand:QI 1 "r_or_s_operand" "%0,0")
2924                 (match_operand:QI 2 "r_or_s_operand" "di,mi")))]
2925   "TARGET_CHAR_INSTRUCTIONS"
2926   "*
2927 {
2928   check_label_emit ();
2929   CC_STATUS_INIT;
2930   if (REG_P (operands[2]))
2931     {
2932       mvs_check_page (0, 2, 0);
2933       return \"XR       %0,%2\";
2934     }
2935   if (REG_P (operands[0]))
2936     {
2937       mvs_check_page (0, 4, 0);
2938       return \"X        %0,%2\";
2939     }
2940   if (GET_CODE (operands[2]) == CONST_INT)
2941     {
2942       mvs_check_page (0, 4, 0);
2943       return \"XI       %0,%B2\";
2944     }
2945   mvs_check_page (0, 6, 0);
2946   return \"XC   %O0(1,%R0),%2\";
2947 }")
2948
2949 (define_insn "xorqi3"
2950   [(set (match_operand:QI 0 "general_operand" "=d")
2951         (xor:QI (match_operand:QI 1 "general_operand" "%0")
2952                 (match_operand:QI 2 "general_operand" "di")))]
2953   ""
2954   "*
2955 {
2956   check_label_emit ();
2957   CC_STATUS_INIT;
2958   if (GET_CODE (operands[2]) == CONST_INT)
2959     {
2960       mvs_check_page (0, 4, 0);
2961       return \"X        %0,%2\";
2962     }
2963   mvs_check_page (0, 2, 0);
2964   return \"XR   %0,%2\";
2965 }")
2966
2967 ;;
2968 ;;- Negate instructions.
2969 ;;
2970
2971 ;
2972 ; negsi2 instruction pattern(s).
2973 ;
2974
2975 (define_insn "negsi2"
2976   [(set (match_operand:SI 0 "general_operand" "=d")
2977         (neg:SI (match_operand:SI 1 "general_operand" "d")))]
2978   ""
2979   "*
2980 {
2981   check_label_emit ();
2982   mvs_check_page (0, 2, 0);
2983   return \"LCR  %0,%1\";
2984 }")
2985
2986 ;
2987 ; neghi2 instruction pattern(s).
2988 ;
2989
2990 (define_insn "neghi2"
2991   [(set (match_operand:HI 0 "general_operand" "=d")
2992         (neg:HI (match_operand:HI 1 "general_operand" "d")))]
2993   ""
2994   "*
2995 {
2996   check_label_emit ();
2997   mvs_check_page (0, 10, 0);
2998   return \"SLL  %1,16\;SRA      %1,16\;LCR      %0,%1\";
2999 }")
3000
3001 ;
3002 ; negdf2 instruction pattern(s).
3003 ;
3004
3005 (define_insn "negdf2"
3006   [(set (match_operand:DF 0 "general_operand" "=f")
3007         (neg:DF (match_operand:DF 1 "general_operand" "f")))]
3008   ""
3009   "*
3010 {
3011   check_label_emit ();
3012   mvs_check_page (0, 2, 0);
3013   return \"LCDR %0,%1\";
3014 }")
3015
3016 ;
3017 ; negsf2 instruction pattern(s).
3018 ;
3019
3020 (define_insn "negsf2"
3021   [(set (match_operand:SF 0 "general_operand" "=f")
3022         (neg:SF (match_operand:SF 1 "general_operand" "f")))]
3023   ""
3024   "*
3025 {
3026   check_label_emit ();
3027   mvs_check_page (0, 2, 0);
3028   return \"LCER %0,%1\";
3029 }")
3030
3031 ;;
3032 ;;- Absolute value instructions.
3033 ;;
3034
3035 ;
3036 ; abssi2 instruction pattern(s).
3037 ;
3038
3039 (define_insn "abssi2"
3040   [(set (match_operand:SI 0 "general_operand" "=d")
3041         (abs:SI (match_operand:SI 1 "general_operand" "d")))]
3042   ""
3043   "*
3044 {
3045   check_label_emit ();
3046   mvs_check_page (0, 2, 0);
3047   return \"LPR  %0,%1\";
3048 }")
3049
3050 ;
3051 ; abshi2 instruction pattern(s).
3052 ;
3053
3054 (define_insn "abshi2"
3055   [(set (match_operand:HI 0 "general_operand" "=d")
3056         (abs:HI (match_operand:HI 1 "general_operand" "d")))]
3057   ""
3058   "*
3059 {
3060   check_label_emit ();
3061   mvs_check_page (0, 10, 0);
3062   return \"SLL  %1,16\;SRA      %1,16\;LPR      %0,%1\";
3063 }")
3064
3065 ;
3066 ; absdf2 instruction pattern(s).
3067 ;
3068
3069 (define_insn "absdf2"
3070   [(set (match_operand:DF 0 "general_operand" "=f")
3071         (abs:DF (match_operand:DF 1 "general_operand" "f")))]
3072   ""
3073   "*
3074 {
3075   check_label_emit ();
3076   mvs_check_page (0, 2, 0);
3077   return \"LPDR %0,%1\";
3078 }")
3079
3080 ;
3081 ; abssf2 instruction pattern(s).
3082 ;
3083
3084 (define_insn "abssf2"
3085   [(set (match_operand:SF 0 "general_operand" "=f")
3086         (abs:SF (match_operand:SF 1 "general_operand" "f")))]
3087   ""
3088   "*
3089 {
3090   check_label_emit ();
3091   mvs_check_page (0, 2, 0);
3092   return \"LPER %0,%1\";
3093 }")
3094
3095 ;;
3096 ;;- One complement instructions.
3097 ;;
3098
3099 ;
3100 ; one_cmpldi2 instruction pattern(s).
3101 ;
3102
3103 ;(define_expand "one_cmpldi2"
3104 ;  [(set (match_operand:DI 0 "general_operand" "")
3105 ;       (not:DI (match_operand:DI 1 "general_operand" "")))]
3106 ;  ""
3107 ;  "
3108 ;{
3109 ;  rtx gen_one_cmplsi2();
3110 ;
3111 ;  emit_insn (gen_one_cmplsi2 (operand_subword (operands[0], 0, 1, DImode),
3112 ;                             operand_subword (operands[1], 0, 1, DImode)));
3113 ;  emit_insn (gen_one_cmplsi2 (gen_lowpart (SImode, operands[0]),
3114 ;                             gen_lowpart (SImode, operands[1])));
3115 ;  DONE;
3116 ;}")
3117
3118 ;
3119 ; one_cmplsi2 instruction pattern(s).
3120 ;
3121
3122 (define_insn ""
3123   [(set (match_operand:SI 0 "r_or_s_operand" "=dm")
3124         (not:SI (match_operand:SI 1 "r_or_s_operand" "0")))]
3125   "TARGET_CHAR_INSTRUCTIONS"
3126   "*
3127 {
3128   check_label_emit ();
3129   if (REG_P (operands[0]))
3130     {
3131       mvs_check_page (0, 4, 4);
3132       return \"X        %0,=F'-1'\";
3133     }
3134   CC_STATUS_INIT;
3135   mvs_check_page (0, 6, 4);
3136   return \"XC   %O0(4,%R0),=F'-1'\";
3137 }")
3138
3139 (define_insn "one_cmplsi2"
3140   [(set (match_operand:SI 0 "general_operand" "=d")
3141         (not:SI (match_operand:SI 1 "general_operand" "0")))]
3142   ""
3143   "*
3144 {
3145   check_label_emit ();
3146   mvs_check_page (0, 4, 4);
3147   return \"X    %0,=F'-1'\";
3148 }")
3149
3150 ;
3151 ; one_cmplhi2 instruction pattern(s).
3152 ;
3153
3154 (define_insn ""
3155   [(set (match_operand:HI 0 "r_or_s_operand" "=dm")
3156         (not:HI (match_operand:HI 1 "r_or_s_operand" "0")))]
3157   "TARGET_CHAR_INSTRUCTIONS"
3158   "*
3159 {
3160   check_label_emit ();
3161   if (REG_P (operands[0]))
3162     {
3163       mvs_check_page (0, 4, 4);
3164       return \"X        %0,=F'-1'\";
3165     }
3166   CC_STATUS_INIT;
3167   mvs_check_page (0, 6, 4);
3168   return \"XC   %O0(2,%R0),=X'FFFF'\";
3169 }")
3170
3171 (define_insn "one_cmplhi2"
3172   [(set (match_operand:HI 0 "general_operand" "=d")
3173         (not:HI (match_operand:HI 1 "general_operand" "0")))]
3174   ""
3175   "*
3176 {
3177   check_label_emit ();
3178   mvs_check_page (0, 4, 4);
3179   return \"X    %0,=F'-1'\";
3180 }")
3181
3182 ;
3183 ; one_cmplqi2 instruction pattern(s).
3184 ;
3185
3186 (define_insn ""
3187   [(set (match_operand:QI 0 "r_or_s_operand" "=dm")
3188         (not:QI (match_operand:QI 1 "r_or_s_operand" "0")))]
3189   "TARGET_CHAR_INSTRUCTIONS"
3190   "*
3191 {
3192   check_label_emit ();
3193   CC_STATUS_INIT;
3194   if (REG_P (operands[0]))
3195     {
3196       mvs_check_page (0, 4, 4);
3197       return \"X        %0,=F'-1'\";
3198     }
3199   mvs_check_page (0, 4, 0);
3200   return \"XI   %0,255\";
3201 }")
3202
3203 (define_insn "one_cmplqi2"
3204   [(set (match_operand:QI 0 "general_operand" "=d")
3205         (not:QI (match_operand:QI 1 "general_operand" "0")))]
3206   ""
3207   "*
3208 {
3209   check_label_emit ();
3210   CC_STATUS_INIT;
3211   mvs_check_page (0, 4, 4);
3212   return \"X    %0,=F'-1'\";
3213 }")
3214
3215 ;;
3216 ;;- Arithmetic shift instructions.
3217 ;;
3218
3219 ;
3220 ; ashldi3 instruction pattern(s).
3221 ;
3222
3223 (define_insn "ashldi3"
3224   [(set (match_operand:DI 0 "general_operand" "=d")
3225         (ashift:DI (match_operand:DI 1 "general_operand" "0")
3226                    (match_operand:SI 2 "general_operand" "Ja")))]
3227   ""
3228   "*
3229 {
3230   check_label_emit ();
3231   CC_STATUS_INIT;
3232   mvs_check_page (0, 4, 0);
3233   if (REG_P (operands[2]))
3234     return \"SLDA       %0,0(%2)\";
3235   return \"SLDA %0,%c2\";
3236 }")
3237
3238 ;
3239 ; ashrdi3 instruction pattern(s).
3240 ;
3241
3242 (define_insn "ashrdi3"
3243   [(set (match_operand:DI 0 "register_operand" "=d")
3244         (ashiftrt:DI (match_operand:DI 1 "general_operand" "0")
3245                      (match_operand:SI 2 "general_operand" "Ja")))]
3246   ""
3247   "*
3248 {
3249   check_label_emit ();
3250   mvs_check_page (0, 4, 0);
3251   if (REG_P (operands[2]))
3252     return \"SRDA       %0,0(%2)\";
3253   return \"SRDA %0,%c2\";
3254 }")
3255
3256 ;
3257 ; ashlsi3 instruction pattern(s).
3258 ;
3259
3260 (define_insn "ashlsi3"
3261   [(set (match_operand:SI 0 "general_operand" "=d")
3262         (ashift:SI (match_operand:SI 1 "general_operand" "0")
3263                    (match_operand:SI 2 "general_operand" "Ja")))]
3264   ""
3265   "*
3266 {
3267   check_label_emit ();
3268   CC_STATUS_INIT;
3269   mvs_check_page (0, 4, 0);
3270   if (REG_P (operands[2]))
3271     return \"SLL        %0,0(%2)\";
3272   return \"SLL  %0,%c2\";
3273 }")
3274
3275 ;
3276 ; ashrsi3 instruction pattern(s).
3277 ;
3278
3279 (define_insn "ashrsi3"
3280   [(set (match_operand:SI 0 "general_operand" "=d")
3281         (ashiftrt:SI (match_operand:SI 1 "general_operand" "0")
3282                      (match_operand:SI 2 "general_operand" "Ja")))]
3283   ""
3284   "*
3285 {
3286   check_label_emit ();
3287   mvs_check_page (0, 4, 0);
3288   if (REG_P (operands[2]))
3289     return \"SRA        %0,0(%2)\";
3290   return \"SRA  %0,%c2\";
3291 }")
3292
3293 ;
3294 ; ashlhi3 instruction pattern(s).
3295 ;
3296
3297 (define_insn "ashlhi3"
3298   [(set (match_operand:HI 0 "general_operand" "=d")
3299         (ashift:HI (match_operand:HI 1 "general_operand" "0")
3300                    (match_operand:SI 2 "general_operand" "Ja")))]
3301   ""
3302   "*
3303 {
3304   check_label_emit ();
3305   mvs_check_page (0, 8, 0);
3306   if (REG_P (operands[2]))
3307     return \"SLL        %0,16(%2)\;SRA  %0,16\";
3308   return \"SLL  %0,16+%c2\;SRA  %0,16\";
3309 }")
3310
3311 ;
3312 ; ashrhi3 instruction pattern(s).
3313 ;
3314
3315 (define_insn "ashrhi3"
3316   [(set (match_operand:HI 0 "general_operand" "=d")
3317         (ashiftrt:HI (match_operand:HI 1 "general_operand" "0")
3318                      (match_operand:SI 2 "general_operand" "Ja")))]
3319   ""
3320   "*
3321 {
3322   check_label_emit ();
3323   mvs_check_page (0, 4, 0);
3324   if (REG_P (operands[2]))
3325     return \"SLL        %0,16\;SRA      %0,16(%2)\";
3326   return \"SLL  %0,16\;SRA      %0,16+%c2\";
3327 }")
3328
3329 ;
3330 ; ashlqi3 instruction pattern(s).
3331 ;
3332
3333 (define_insn "ashlqi3"
3334   [(set (match_operand:QI 0 "general_operand" "=d")
3335         (ashift:QI (match_operand:QI 1 "general_operand" "0")
3336                    (match_operand:SI 2 "general_operand" "Ja")))]
3337   ""
3338   "*
3339 {
3340   check_label_emit ();
3341   CC_STATUS_INIT;
3342   mvs_check_page (0, 4, 0);
3343   if (REG_P (operands[2]))
3344     return \"SLL        %0,0(%2)\";
3345   return \"SLL  %0,%c2\";
3346 }")
3347
3348 ;
3349 ; ashrqi3 instruction pattern(s).
3350 ;
3351
3352 (define_insn "ashrqi3"
3353   [(set (match_operand:QI 0 "general_operand" "=d")
3354         (ashiftrt:QI (match_operand:QI 1 "general_operand" "0")
3355                      (match_operand:SI 2 "general_operand" "Ja")))]
3356   ""
3357   "*
3358 {
3359   check_label_emit ();
3360   mvs_check_page (0, 8, 0);
3361   if (REG_P (operands[2]))
3362     return \"SLL        %0,24\;SRA      %0,24(%2)\";
3363   return \"SLL  %0,24\;SRA      %0,24+%c2\";
3364 }")
3365
3366 ;;
3367 ;;- Logical shift instructions.
3368 ;;
3369
3370 ;
3371 ; lshrdi3 instruction pattern(s).
3372 ;
3373
3374 (define_insn "lshrdi3"
3375   [(set (match_operand:DI 0 "general_operand" "=d")
3376         (lshiftrt:DI (match_operand:DI 1 "general_operand" "0")
3377                      (match_operand:SI 2 "general_operand" "Ja")))]
3378   ""
3379   "*
3380 {
3381   check_label_emit ();
3382   mvs_check_page (0, 4, 0);
3383   if (REG_P (operands[2]))
3384     return \"SRDL       %0,0(%2)\";
3385   return \"SRDL %0,%c2\";
3386 }")
3387
3388
3389 ;
3390 ; lshrsi3 instruction pattern(s).
3391 ;
3392
3393 (define_insn "lshrsi3"
3394   [(set (match_operand:SI 0 "general_operand" "=d")
3395         (lshiftrt:SI (match_operand:SI 1 "general_operand" "0")
3396                      (match_operand:SI 2 "general_operand" "Ja")))]
3397   ""
3398   "*
3399 {
3400   check_label_emit ();
3401   mvs_check_page (0, 4, 0);
3402   if (REG_P (operands[2]))
3403     return \"SRL        %0,0(%2)\";
3404   return \"SRL  %0,%c2\";
3405 }")
3406
3407 ;
3408 ; lshrhi3 instruction pattern(s).
3409 ;
3410
3411 (define_insn "lshrhi3"
3412   [(set (match_operand:HI 0 "general_operand" "=d")
3413         (lshiftrt:HI (match_operand:HI 1 "general_operand" "0")
3414                      (match_operand:SI 2 "general_operand" "Ja")))]
3415   ""
3416   "*
3417 {
3418   check_label_emit ();
3419   CC_STATUS_INIT;
3420   if (REG_P (operands[2]))
3421     {
3422       mvs_check_page (0, 8, 4);
3423       return \"N        %0,=X'0000FFFF'\;SRL    %0,0(%2)\";
3424     }
3425   mvs_check_page (0, 8, 4);
3426   return \"N    %0,=X'0000FFFF'\;SRL    %0,%c2\";
3427 }")
3428
3429 ;
3430 ; lshrqi3 instruction pattern(s).
3431 ;
3432
3433 (define_insn "lshrqi3"
3434   [(set (match_operand:QI 0 "general_operand" "=d")
3435         (lshiftrt:QI (match_operand:QI 1 "general_operand" "0")
3436                      (match_operand:SI 2 "general_operand" "Ja")))]
3437   ""
3438   "*
3439 {
3440   check_label_emit ();
3441   CC_STATUS_INIT;
3442   mvs_check_page (0, 8, 4);
3443   if (REG_P (operands[2]))
3444     return \"N  %0,=X'000000FF'\;SRL    %0,0(%2)\";
3445   return \"N    %0,=X'000000FF'\;SRL    %0,%c2\";
3446 }")
3447
3448 ;;
3449 ;;- Conditional jump instructions.
3450 ;;
3451
3452 ;
3453 ; beq instruction pattern(s).
3454 ;
3455
3456 (define_insn "beq"
3457   [(set (pc)
3458         (if_then_else (eq (cc0)
3459                           (const_int 0))
3460                       (label_ref (match_operand 0 "" ""))
3461                       (pc)))]
3462   ""
3463   "*
3464 {
3465   check_label_emit ();
3466   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3467     {
3468       mvs_check_page (0, 6, 4);
3469       return \"L        14,=A(%l0)\;BER 14\";
3470     }
3471   if (mvs_check_page (0, 4, 0))
3472     {
3473       mvs_check_page (0, 2, 4);
3474       return \"L        14,=A(%l0)\;BER 14\";
3475     }
3476   return \"BE   %l0\";
3477 }")
3478
3479 ;
3480 ; bne instruction pattern(s).
3481 ;
3482
3483 (define_insn "bne"
3484   [(set (pc)
3485         (if_then_else (ne (cc0)
3486                           (const_int 0))
3487                       (label_ref (match_operand 0 "" ""))
3488                       (pc)))]
3489   ""
3490   "*
3491 {
3492   check_label_emit ();
3493   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3494     {
3495       mvs_check_page (0, 6, 4);
3496       return \"L        14,=A(%l0)\;BNER        14\";
3497     }
3498   if (mvs_check_page (0, 4, 0))
3499     {
3500       mvs_check_page (0, 2, 4);
3501       return \"L        14,=A(%l0)\;BNER        14\";
3502     }
3503   return \"BNE  %l0\";
3504 }")
3505
3506 ;
3507 ; bgt instruction pattern(s).
3508 ;
3509
3510 (define_insn "bgt"
3511   [(set (pc)
3512         (if_then_else (gt (cc0)
3513                           (const_int 0))
3514                       (label_ref (match_operand 0 "" ""))
3515                       (pc)))]
3516   ""
3517   "*
3518 {
3519   check_label_emit ();
3520   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3521     {
3522       mvs_check_page (0, 6, 4);
3523       return \"L        14,=A(%l0)\;BHR 14\";
3524     }
3525   if (mvs_check_page (0, 4, 0))
3526     {
3527       mvs_check_page (0, 2, 4);
3528       return \"L        14,=A(%l0)\;BHR 14\";
3529     }
3530   return \"BH   %l0\";
3531 }")
3532
3533 ;
3534 ; bgtu instruction pattern(s).
3535 ;
3536
3537 (define_insn "bgtu"
3538   [(set (pc)
3539         (if_then_else (gtu (cc0)
3540                            (const_int 0))
3541                       (label_ref (match_operand 0 "" ""))
3542                       (pc)))]
3543   ""
3544   "*
3545 {
3546   check_label_emit ();
3547   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3548     {
3549       mvs_check_page (0, 6, 4);
3550       return \"L        14,=A(%l0)\;BHR 14\";
3551     }
3552   if (mvs_check_page (0, 4, 0))
3553     {
3554       mvs_check_page (0, 2, 4);
3555       return \"L        14,=A(%l0)\;BHR 14\";
3556     }
3557   return \"BH   %l0\";
3558 }")
3559
3560 ;
3561 ; blt instruction pattern(s).
3562 ;
3563
3564 (define_insn "blt"
3565   [(set (pc)
3566         (if_then_else (lt (cc0)
3567                           (const_int 0))
3568                       (label_ref (match_operand 0 "" ""))
3569                       (pc)))]
3570   ""
3571   "*
3572 {
3573   check_label_emit ();
3574   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3575     {
3576       mvs_check_page (0, 6, 4);
3577       return \"L        14,=A(%l0)\;BLR 14\";
3578     }
3579   if (mvs_check_page (0, 4, 0))
3580     {
3581       mvs_check_page (0, 2, 4);
3582       return \"L        14,=A(%l0)\;BLR 14\";
3583     }
3584   return \"BL   %l0\";
3585 }")
3586
3587 ;
3588 ; bltu instruction pattern(s).
3589 ;
3590
3591 (define_insn "bltu"
3592   [(set (pc)
3593         (if_then_else (ltu (cc0)
3594                            (const_int 0))
3595                       (label_ref (match_operand 0 "" ""))
3596                       (pc)))]
3597   ""
3598   "*
3599 {
3600   check_label_emit ();
3601   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3602     {
3603       mvs_check_page (0, 6, 4);
3604       return \"L        14,=A(%l0)\;BLR 14\";
3605     }
3606   if (mvs_check_page (0, 4, 0))
3607     {
3608       mvs_check_page (0, 2, 4);
3609       return \"L        14,=A(%l0)\;BLR 14\";
3610     }
3611   return \"BL   %l0\";
3612 }")
3613
3614 ;
3615 ; bge instruction pattern(s).
3616 ;
3617
3618 (define_insn "bge"
3619   [(set (pc)
3620         (if_then_else (ge (cc0)
3621                           (const_int 0))
3622                       (label_ref (match_operand 0 "" ""))
3623                       (pc)))]
3624   ""
3625   "*
3626 {
3627   check_label_emit ();
3628   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3629     {
3630       mvs_check_page (0, 6, 4);
3631       return \"L        14,=A(%l0)\;BNLR        14\";
3632     }
3633   if (mvs_check_page (0, 4, 0))
3634     {
3635       mvs_check_page (0, 2, 4);
3636       return \"L        14,=A(%l0)\;BNLR        14\";
3637     }
3638   return \"BNL  %l0\";
3639 }")
3640
3641 ;
3642 ; bgeu instruction pattern(s).
3643 ;
3644
3645 (define_insn "bgeu"
3646   [(set (pc)
3647         (if_then_else (geu (cc0)
3648                            (const_int 0))
3649                       (label_ref (match_operand 0 "" ""))
3650                       (pc)))]
3651   ""
3652   "*
3653 {
3654   check_label_emit ();
3655   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3656     {
3657       mvs_check_page (0, 6, 4);
3658       return \"L        14,=A(%l0)\;BNLR        14\";
3659     }
3660   if (mvs_check_page (0, 4, 0))
3661     {
3662       mvs_check_page (0, 2, 4);
3663       return \"L        14,=A(%l0)\;BNLR        14\";
3664     }
3665   return \"BNL  %l0\";
3666 }")
3667
3668 ;
3669 ; ble instruction pattern(s).
3670 ;
3671
3672 (define_insn "ble"
3673   [(set (pc)
3674         (if_then_else (le (cc0)
3675                           (const_int 0))
3676                       (label_ref (match_operand 0 "" ""))
3677                       (pc)))]
3678   ""
3679   "*
3680 {
3681   check_label_emit ();
3682   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3683     {
3684       mvs_check_page (0, 6, 4);
3685       return \"L        14,=A(%l0)\;BNHR        14\";
3686     }
3687   if (mvs_check_page (0, 4, 0))
3688     {
3689       mvs_check_page (0, 2, 4);
3690       return \"L        14,=A(%l0)\;BNHR        14\";
3691     }
3692   return \"BNH  %l0\";
3693 }")
3694
3695 ;
3696 ; bleu instruction pattern(s).
3697 ;
3698
3699 (define_insn "bleu"
3700   [(set (pc)
3701         (if_then_else (leu (cc0)
3702                            (const_int 0))
3703                       (label_ref (match_operand 0 "" ""))
3704                       (pc)))]
3705   ""
3706   "*
3707 {
3708   check_label_emit ();
3709   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3710     {
3711       mvs_check_page (0, 6, 4);
3712       return \"L        14,=A(%l0)\;BNHR        14\";
3713     }
3714   if (mvs_check_page (0, 4, 0))
3715     {
3716       mvs_check_page (0, 2, 4);
3717       return \"L        14,=A(%l0)\;BNHR        14\";
3718     }
3719   return \"BNH  %l0\";
3720 }")
3721
3722 ;;
3723 ;;- Negated conditional jump instructions.
3724 ;;
3725
3726 (define_insn ""
3727   [(set (pc)
3728         (if_then_else (eq (cc0)
3729                           (const_int 0))
3730                       (pc)
3731                       (label_ref (match_operand 0 "" ""))))]
3732   ""
3733   "*
3734 {
3735   check_label_emit ();
3736   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3737     {
3738       mvs_check_page (0, 6, 4);
3739       return \"L        14,=A(%l0)\;BNER        14\";
3740     }
3741   if (mvs_check_page (0, 4, 0))
3742     {
3743       mvs_check_page (0, 2, 4);
3744       return \"L        14,=A(%l0)\;BNER        14\";
3745     }
3746   return \"BNE  %l0\";
3747 }")
3748
3749 (define_insn ""
3750   [(set (pc)
3751         (if_then_else (ne (cc0)
3752                           (const_int 0))
3753                       (pc)
3754                       (label_ref (match_operand 0 "" ""))))]
3755   ""
3756   "*
3757 {
3758   check_label_emit ();
3759   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3760     {
3761       mvs_check_page (0, 6, 4);
3762       return \"L        14,=A(%l0)\;BER 14\";
3763     }
3764   if (mvs_check_page (0, 4, 0))
3765     {
3766       mvs_check_page (0, 2, 4);
3767       return \"L        14,=A(%l0)\;BER 14\";
3768     }
3769   return \"BE   %l0\";
3770 }")
3771
3772 (define_insn ""
3773   [(set (pc)
3774         (if_then_else (gt (cc0)
3775                           (const_int 0))
3776                       (pc)
3777                       (label_ref (match_operand 0 "" ""))))]
3778   ""
3779   "*
3780 {
3781   check_label_emit ();
3782   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3783     {
3784       mvs_check_page (0, 6, 4);
3785       return \"L        14,=A(%l0)\;BNHR        14\";
3786     }
3787   if (mvs_check_page (0, 4, 0))
3788     {
3789       mvs_check_page (0, 2, 4);
3790       return \"L        14,=A(%l0)\;BNHR        14\";
3791     }
3792   return \"BNH  %l0\";
3793 }")
3794
3795 (define_insn ""
3796   [(set (pc)
3797         (if_then_else (gtu (cc0)
3798                            (const_int 0))
3799                       (pc)
3800                       (label_ref (match_operand 0 "" ""))))]
3801   ""
3802   "*
3803 {
3804   check_label_emit ();
3805   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3806     {
3807       mvs_check_page (0, 6, 4);
3808       return \"L        14,=A(%l0)\;BNHR        14\";
3809     }
3810   if (mvs_check_page (0, 4, 0))
3811     {
3812       mvs_check_page (0, 2, 4);
3813       return \"L        14,=A(%l0)\;BNHR        14\";
3814     }
3815   return \"BNH  %l0\";
3816 }")
3817
3818 (define_insn ""
3819   [(set (pc)
3820         (if_then_else (lt (cc0)
3821                           (const_int 0))
3822                       (pc)
3823                       (label_ref (match_operand 0 "" ""))))]
3824   ""
3825   "*
3826 {
3827   check_label_emit ();
3828   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3829     {
3830       mvs_check_page (0, 6, 4);
3831       return \"L        14,=A(%l0)\;BNLR        14\";
3832     }
3833   if (mvs_check_page (0, 4, 0))
3834     {
3835       mvs_check_page (0, 2, 4);
3836       return \"L        14,=A(%l0)\;BNLR        14\";
3837     }
3838   return \"BNL  %l0\";
3839 }")
3840
3841 (define_insn ""
3842   [(set (pc)
3843         (if_then_else (ltu (cc0)
3844                            (const_int 0))
3845                       (pc)
3846                       (label_ref (match_operand 0 "" ""))))]
3847   ""
3848   "*
3849 {
3850   check_label_emit ();
3851   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3852     {
3853       mvs_check_page (0, 6, 4);
3854       return \"L        14,=A(%l0)\;BNLR        14\";
3855     }
3856   if (mvs_check_page (0, 4, 0))
3857     {
3858       mvs_check_page (0, 2, 4);
3859       return \"L        14,=A(%l0)\;BNLR        14\";
3860     }
3861   return \"BNL  %l0\";
3862 }")
3863
3864 (define_insn ""
3865   [(set (pc)
3866         (if_then_else (ge (cc0)
3867                           (const_int 0))
3868                       (pc)
3869                       (label_ref (match_operand 0 "" ""))))]
3870   ""
3871   "*
3872 {
3873   check_label_emit ();
3874   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3875     {
3876       mvs_check_page (0, 6, 4);
3877       return \"L        14,=A(%l0)\;BLR 14\";
3878     }
3879   if (mvs_check_page (0, 4, 0))
3880     {
3881       mvs_check_page (0, 2, 4);
3882       return \"L        14,=A(%l0)\;BLR 14\";
3883     }
3884   return \"BL   %l0\";
3885 }")
3886
3887 (define_insn ""
3888   [(set (pc)
3889         (if_then_else (geu (cc0)
3890                            (const_int 0))
3891                       (pc)
3892                       (label_ref (match_operand 0 "" ""))))]
3893   ""
3894   "*
3895 {
3896   check_label_emit ();
3897   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3898     {
3899       mvs_check_page (0, 6, 4);
3900       return \"L        14,=A(%l0)\;BLR 14\";
3901     }
3902   if (mvs_check_page (0, 4, 0))
3903     {
3904       mvs_check_page (0, 2, 4);
3905       return \"L        14,=A(%l0)\;BLR 14\";
3906     }
3907   return \"BL   %l0\";
3908 }")
3909
3910 (define_insn ""
3911   [(set (pc)
3912         (if_then_else (le (cc0)
3913                           (const_int 0))
3914                       (pc)
3915                       (label_ref (match_operand 0 "" ""))))]
3916   ""
3917   "*
3918 {
3919   check_label_emit ();
3920   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3921     {
3922       mvs_check_page (0, 6, 4);
3923       return \"L        14,=A(%l0)\;BHR 14\";
3924     }
3925   if (mvs_check_page (0, 4, 0))
3926     {
3927       mvs_check_page (0, 2, 4);
3928       return \"L        14,=A(%l0)\;BHR 14\";
3929     }
3930   return \"BH   %l0\";
3931 }")
3932
3933 (define_insn ""
3934   [(set (pc)
3935         (if_then_else (leu (cc0)
3936                            (const_int 0))
3937                       (pc)
3938                       (label_ref (match_operand 0 "" ""))))]
3939   ""
3940   "*
3941 {
3942   check_label_emit ();
3943   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
3944     {
3945       mvs_check_page (0, 6, 4);
3946       return \"L        14,=A(%l0)\;BHR 14\";
3947     }
3948   if (mvs_check_page (0, 4, 0))
3949     {
3950       mvs_check_page (0, 2, 4);
3951       return \"L        14,=A(%l0)\;BHR 14\";
3952     }
3953   return \"BH   %l0\";
3954 }")
3955
3956 ;;
3957 ;;- Subtract one and jump if not zero.
3958 ;;
3959
3960 (define_insn ""
3961   [(set (pc)
3962         (if_then_else
3963          (ne (plus:SI (match_operand:SI 0 "register_operand" "+d")
3964                       (const_int -1))
3965              (const_int 0))
3966          (label_ref (match_operand 1 "" ""))
3967          (pc)))
3968    (set (match_dup 0)
3969         (plus:SI (match_dup 0)
3970                  (const_int -1)))]
3971   ""
3972   "*
3973 {
3974   check_label_emit ();
3975   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[1])))
3976     {
3977       mvs_check_page (0, 6, 4);
3978       return \"L        14,=A(%l1)\;BCTR        %0,14\";
3979     }
3980   if (mvs_check_page (0, 4, 0))
3981     {
3982       mvs_check_page (0, 2, 4);
3983       return \"L        14,=A(%l1)\;BCTR        %0,14\";
3984     }
3985   return \"BCT  %0,%l1\";
3986 }")
3987
3988 (define_insn ""
3989   [(set (pc)
3990         (if_then_else
3991          (eq (plus:SI (match_operand:SI 0 "register_operand" "+d")
3992                       (const_int -1))
3993              (const_int 0))
3994          (pc)
3995          (label_ref (match_operand 1 "" ""))))
3996    (set (match_dup 0)
3997         (plus:SI (match_dup 0)
3998                  (const_int -1)))]
3999   ""
4000   "*
4001 {
4002   check_label_emit ();
4003   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[1])))
4004     {
4005       mvs_check_page (0, 6, 4);
4006       return \"L        14,=A(%l1)\;BCTR        %0,14\";
4007     }
4008   if (mvs_check_page (0, 4, 0))
4009     {
4010       mvs_check_page (0, 2, 4);
4011       return \"L        14,=A(%l1)\;BCTR        %0,14\";
4012     }
4013   return \"BCT  %0,%l1\";
4014 }")
4015
4016 ;;
4017 ;;- Unconditional jump instructions.
4018 ;;
4019
4020 ;
4021 ; jump instruction pattern(s).
4022 ;
4023
4024 (define_insn "jump"
4025   [(set (pc)
4026         (label_ref (match_operand 0 "" "")))]
4027   ""
4028   "*
4029 {
4030   check_label_emit ();
4031   if (!mvs_check_label (CODE_LABEL_NUMBER (operands[0])))
4032     {
4033       mvs_check_page (0, 6, 4);
4034       return \"L        14,=A(%l0)\;BR  14\";
4035     }
4036   if (mvs_check_page (0, 4, 0))
4037     {
4038       mvs_check_page (0, 2, 4);
4039       return \"L        14,=A(%l0)\;BR  14\";
4040     }
4041   return \"B    %l0\";
4042 }")
4043
4044 ;
4045 ; indirect-jump instruction pattern(s).
4046 ;
4047
4048 (define_insn "indirect_jump"
4049   [(set (pc) (match_operand:SI 0 "general_operand" "r"))]
4050   "(GET_CODE (operands[0]) != MEM )"
4051   "*
4052 {
4053   check_label_emit ();
4054   mvs_check_page (0, 2, 0);
4055   return \"BR   %0\";
4056 }")
4057
4058 ;
4059 ; tablejump instruction pattern(s).
4060 ;
4061
4062 (define_insn "tablejump"
4063   [(set (pc)
4064         (match_operand:SI 0 "general_operand" "am"))
4065    (use (label_ref (match_operand 1 "" "")))]
4066   ""
4067   "*
4068 {
4069   check_label_emit ();
4070   if (REG_P (operands[0]))
4071     {
4072       mvs_check_page (0, 6, 0);
4073       return \"BR       %0\;DS  0F\";
4074     }
4075   mvs_check_page (0, 10, 0);
4076   return \"L    14,%0\;BR       14\;DS  0F\";
4077 }")
4078
4079 ;;
4080 ;;- Jump to subroutine.
4081 ;;
4082 ;; For the C/370 environment the internal functions, ie. sqrt, are called with
4083 ;; a non-standard form.  So, we must fix it here.  There's no BM like IBM.
4084 ;;
4085
4086 ;
4087 ; call instruction pattern(s).
4088 ;
4089
4090 (define_insn "call"
4091   [(call (match_operand:QI 0 "memory_operand" "m")
4092          (match_operand:SI 1 "immediate_operand" "i"))]
4093   ""
4094   "*
4095 {
4096   static char temp[128];
4097   int i = STACK_POINTER_OFFSET;
4098
4099   check_label_emit ();
4100   if (mvs_function_check (XSTR (operands[0], 0)))
4101     {
4102       mvs_check_page (0, 22, 4);
4103       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%0\;BALR    14,15\;LD       0,136(,13)\",
4104              i - 4, i - 4 );
4105     }
4106   else
4107     {
4108       mvs_check_page (0, 10, 4);
4109       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%0\;BALR    14,15\", i );
4110     }
4111   return temp;
4112 }")
4113
4114 ;
4115 ; call_value instruction pattern(s).
4116 ;
4117
4118 (define_insn "call_value"
4119   [(set (match_operand 0 "" "rf")
4120         (call (match_operand:QI 1 "memory_operand" "m")
4121               (match_operand:SI 2 "general_operand" "i")))]
4122   ""
4123   "*
4124 {
4125   static char temp[128];
4126   int i = STACK_POINTER_OFFSET;
4127
4128   check_label_emit ();
4129   if (mvs_function_check (XSTR (operands[1], 0)))
4130     {
4131       mvs_check_page (0, 22, 4);
4132       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%1\;BALR    14,15\;LD       0,136(,13)\",
4133            i - 4, i - 4 );
4134     }
4135   else
4136     {
4137       mvs_check_page (0, 10, 4);
4138       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%1\;BALR    14,15\", i );
4139     }
4140   return temp;
4141 }")
4142
4143 (define_insn ""
4144   [(call (mem:QI (match_operand:SI 0 "" "i"))
4145          (match_operand:SI 1 "general_operand" "g"))]
4146   "GET_CODE (operands[0]) == SYMBOL_REF"
4147   "*
4148 {
4149   static char temp[128];
4150   int i = STACK_POINTER_OFFSET;
4151
4152   check_label_emit ();
4153   if (mvs_function_check (XSTR (operands[0], 0)))
4154     {
4155       mvs_check_page (0, 22, 4);
4156       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%0\;BALR    14,15\;LD       0,136(,13)\",
4157            i - 4, i - 4 );
4158     }
4159   else
4160     {
4161       mvs_check_page (0, 10, 4);
4162       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%0\;BALR    14,15\", i );
4163     }
4164   return temp;
4165 }")
4166
4167 (define_insn ""
4168   [(set (match_operand 0 "" "rf")
4169         (call (mem:QI (match_operand:SI 1 "" "i"))
4170               (match_operand:SI 2 "general_operand" "g")))]
4171   "GET_CODE (operands[1]) == SYMBOL_REF"
4172   "*
4173 {
4174   static char temp[128];
4175   int i = STACK_POINTER_OFFSET;
4176
4177   check_label_emit ();
4178   if (mvs_function_check (XSTR (operands[1], 0)))
4179     {
4180       mvs_check_page (0, 22, 4);
4181       sprintf ( temp, \"LA      1,136(,13)\;ST  1,%d(,13)\;LA   1,%d(,13)\;L    15,%%1\;BALR    14,15\;LD       0,136(,13)\",
4182            i - 4, i - 4 );
4183     }
4184   else
4185     {
4186       mvs_check_page (0, 10, 4);
4187       sprintf ( temp, \"LA      1,%d(,13)\;L    15,%%1\;BALR    14,15\", i );
4188     }
4189   return temp;
4190 }")
4191
4192
4193 ;;
4194 ;;- Miscellaneous instructions.
4195 ;;
4196
4197 ;
4198 ; nop instruction pattern(s).
4199 ;
4200
4201 (define_insn "nop"
4202   [(const_int 0)]
4203   ""
4204   "*
4205 {
4206   check_label_emit ();
4207   mvs_check_page (0, 2, 0);
4208   return \"LR   0,0\";
4209 }")
4210