gcc/config/alpha/alpha.md

   1 ;; Machine description for DEC Alpha for GNU C compiler
   2 ;; Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3 ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   4
   5 ;; This file is part of GNU CC.
   6
   7 ;; GNU CC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 2, or (at your option)
  10 ;; any later version.
  11
  12 ;; GNU CC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GNU CC; see the file COPYING.  If not, write to
  19 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  20 ;; Boston, MA 02111-1307, USA.
  21
  22 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  23 \f
  24 ;; Processor type -- this attribute must exactly match the processor_type
  25 ;; enumeration in alpha.h.
  26
  27 (define_attr "cpu" "ev4,ev5"
  28   (const (symbol_ref "alpha_cpu")))
  29
  30 ;; Define an insn type attribute.  This is used in function unit delay
  31 ;; computations, among other purposes.  For the most part, we use the names
  32 ;; defined in the EV4 documentation, but add a few that we have to know about
  33 ;; separately.
  34
  35 (define_attr "type"
  36   "ld,st,ibr,fbr,jsr,iadd,ilog,shift,cmov,icmp,imull,imulq,imulh,fadd,fmul,fcpys,fdivs,fdivt,ldsym,isubr,misc"
  37   (const_string "iadd"))
  38
  39 ;; The TRAP_TYPE attribute marks instructions that may generate traps
  40 ;; (which are imprecise and may need a trapb if software complention
  41 ;; is desired).
  42 (define_attr "trap" "yes,no" (const_string "no"))
  43
  44 ;; For the EV4 we include four function units: ABOX, which computes
  45 ;; the address, BBOX, used for branches, EBOX, used for integer
  46 ;; operations, and FBOX, used for FP operations.
  47
  48 ;; Memory delivers its result in three cycles.
  49 (define_function_unit "ev4_abox" 1 0
  50   (and (eq_attr "cpu" "ev4")
  51        (eq_attr "type" "ld,ldsym,st"))
  52   3 1)
  53
  54 ;; Branches have no delay cost, but do tie up the unit for two cycles.
  55 (define_function_unit "ev4_bbox" 1 1
  56   (and (eq_attr "cpu" "ev4")
  57        (eq_attr "type" "ibr,fbr,jsr"))
  58   2 2)
  59
  60 ;; Arithmetic insns are normally have their results available after
  61 ;; two cycles.  There are a number of exceptions.  They are encoded in
  62 ;; ADJUST_COST.  Some of the other insns have similar exceptions.
  63
  64 (define_function_unit "ev4_ebox" 1 0
  65   (and (eq_attr "cpu" "ev4")
  66        (eq_attr "type" "iadd,ilog,shift,cmov,icmp"))
  67   2 1)
  68
  69 ;; These really don't take up the integer pipeline, but they do occupy
  70 ;; IBOX1; we approximate here.
  71
  72 (define_function_unit "ev4_ebox" 1 0
  73   (and (eq_attr "cpu" "ev4")
  74        (eq_attr "type" "imull"))
  75   21 1)
  76
  77 (define_function_unit "ev4_ebox" 1 0
  78   (and (eq_attr "cpu" "ev4")
  79        (eq_attr "type" "imulq,imulh"))
  80   23 1)
  81
  82 (define_function_unit "ev4_imult" 1 0
  83   (and (eq_attr "cpu" "ev4")
  84        (eq_attr "type" "imull"))
  85   21 19)
  86
  87 (define_function_unit "ev4_imult" 1 0
  88   (and (eq_attr "cpu" "ev4")
  89        (eq_attr "type" "imulq,imulh"))
  90   23 21)
  91
  92 (define_function_unit "ev4_fbox" 1 0
  93   (and (eq_attr "cpu" "ev4")
  94        (eq_attr "type" "fadd,fmul,fcpys"))
  95   6 1)
  96
  97 (define_function_unit "ev4_fbox" 1 0
  98   (and (eq_attr "cpu" "ev4")
  99        (eq_attr "type" "fdivs"))
 100   34 0)
 101
 102 (define_function_unit "ev4_fbox" 1 0
 103   (and (eq_attr "cpu" "ev4")
 104        (eq_attr "type" "fdivt"))
 105   63 0)
 106
 107 (define_function_unit "ev4_divider" 1 0
 108   (and (eq_attr "cpu" "ev4")
 109        (eq_attr "type" "fdivs"))
 110   34 30)
 111
 112 (define_function_unit "ev4_divider" 1 0
 113   (and (eq_attr "cpu" "ev4")
 114        (eq_attr "type" "fdivt"))
 115   64 59)
 116 \f
 117 ;; EV5 scheduling.  EV5 can issue 4 insns per clock.
 118
 119 ;; EV5 has two asymetric integer units.  Model this with ebox,e0,e1.
 120 ;; Everything uses ebox, and those that require particular pipes grab
 121 ;; those as well.
 122
 123 (define_function_unit "ev5_ebox" 2 0
 124   (and (eq_attr "cpu" "ev5")
 125        (eq_attr "type" "iadd,ilog,icmp,st,shift,imull,imulq,imulh"))
 126   1 1)
 127
 128 ;; Memory takes at least 2 clocks, and load cannot dual issue with stores.
 129 (define_function_unit "ev5_ebox" 2 0
 130   (and (eq_attr "cpu" "ev5")
 131        (eq_attr "type" "ld,ldsym"))
 132   2 1)
 133
 134 (define_function_unit "ev5_e0" 1 0
 135   (and (eq_attr "cpu" "ev5")
 136        (eq_attr "type" "ld,ldsym"))
 137   0 1
 138   [(eq_attr "type" "st")])
 139
 140 ;; Conditional moves always take 2 ticks.
 141 (define_function_unit "ev5_ebox" 2 0
 142   (and (eq_attr "cpu" "ev5")
 143        (eq_attr "type" "cmov"))
 144   2 1)
 145
 146 ;; Stores, shifts, and multiplies can only issue to E0
 147 (define_function_unit "ev5_e0" 1 0
 148   (and (eq_attr "cpu" "ev5")
 149        (eq_attr "type" "st"))
 150   1 1)
 151
 152 ;; But shifts and multiplies don't conflict with loads.
 153 (define_function_unit "ev5_e0" 1 0
 154   (and (eq_attr "cpu" "ev5")
 155        (eq_attr "type" "shift,imull,imulq,imulh"))
 156   1 1
 157   [(eq_attr "type" "st,shift,imull,imulq,imulh")])
 158
 159 ;; Branches can only issue to E1
 160 (define_function_unit "ev5_e1" 1 0
 161   (and (eq_attr "cpu" "ev5")
 162        (eq_attr "type" "ibr,jsr"))
 163   1 1)
 164
 165 ;; Multiplies also use the integer multiplier.
 166 (define_function_unit "ev5_imult" 1 0
 167   (and (eq_attr "cpu" "ev5")
 168        (eq_attr "type" "imull"))
 169   8 4)
 170
 171 (define_function_unit "ev5_imult" 1 0
 172   (and (eq_attr "cpu" "ev5")
 173        (eq_attr "type" "imulq"))
 174   12 8)
 175
 176 (define_function_unit "ev5_imult" 1 0
 177   (and (eq_attr "cpu" "ev5")
 178        (eq_attr "type" "imulh"))
 179   14 8)
 180
 181 ;; Similarly for the FPU we have two asymetric units.  But fcpys can issue
 182 ;; on either so we have to play the game again.
 183
 184 (define_function_unit "ev5_fpu" 2 0
 185   (and (eq_attr "cpu" "ev5")
 186        (eq_attr "type" "fadd,fmul,fcpys,fbr,fdivs,fdivt"))
 187   4 1)
 188
 189 ;; Multiplies (resp. adds) also use the fmul (resp. fadd) units.
 190 (define_function_unit "ev5_fm" 1 0
 191   (and (eq_attr "cpu" "ev5")
 192        (eq_attr "type" "fmul"))
 193   4 1)
 194
 195 (define_function_unit "ev5_fa" 1 0
 196   (and (eq_attr "cpu" "ev5")
 197        (eq_attr "type" "fadd"))
 198   4 1)
 199
 200 (define_function_unit "ev5_fa" 1 0
 201   (and (eq_attr "cpu" "ev5")
 202        (eq_attr "type" "fbr"))
 203   1 1)
 204
 205 (define_function_unit "ev5_fa" 1 0
 206   (and (eq_attr "cpu" "ev5")
 207        (eq_attr "type" "fdivs"))
 208   15 1)
 209
 210 (define_function_unit "ev5_fa" 1 0
 211   (and (eq_attr "cpu" "ev5")
 212        (eq_attr "type" "fdivt"))
 213   22 1)
 214 \f
 215 ;; First define the arithmetic insns.  Note that the 32-bit forms also
 216 ;; sign-extend.
 217
 218 ;; Note that we can do sign extensions in both FP and integer registers.
 219 ;; However, the result must be in the same type of register as the input.
 220 ;; The register preferencing code can't handle this case very well, so, for
 221 ;; now, don't let the FP case show up here for preferencing.  Also,
 222 ;; sign-extends in FP registers take two instructions.
 223 (define_insn "extendsidi2"
 224   [(set (match_operand:DI 0 "register_operand" "=r,r,*f")
 225         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "r,m,*f")))]
 226   ""
 227   "@
 228    addl %1,$31,%0
 229    ldl %0,%1
 230    cvtql %1,%0\;cvtlq %0,%0"
 231   [(set_attr "type" "iadd,ld,fadd")])
 232
 233 ;; Do addsi3 the way expand_binop would do if we didn't have one.  This
 234 ;; generates better code.  We have the anonymous addsi3 pattern below in
 235 ;; case combine wants to make it.
 236 (define_expand "addsi3"
 237   [(set (match_operand:SI 0 "register_operand" "")
 238         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "")
 239                  (match_operand:SI 2 "add_operand" "")))]
 240   ""
 241   "
 242 { emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (DImode, operands[0]),
 243                       gen_rtx (PLUS, DImode,
 244                                gen_lowpart (DImode, operands[1]),
 245                                gen_lowpart (DImode, operands[2]))));
 246   DONE;
 247 } ")
 248
 249 (define_insn ""
 250   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
 251         (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ,rJ,rJ")
 252                  (match_operand:SI 2 "add_operand" "rI,O,K,L")))]
 253   ""
 254   "@
 255    addl %r1,%2,%0
 256    subl %r1,%n2,%0
 257    lda %0,%2(%r1)
 258    ldah %0,%h2(%r1)")
 259
 260 (define_split
 261   [(set (match_operand:SI 0 "register_operand" "")
 262         (plus:SI (match_operand:SI 1 "register_operand" "")
 263                  (match_operand:SI 2 "const_int_operand" "")))]
 264   "! add_operand (operands[2], SImode)"
 265   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 3)))
 266    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
 267   "
 268 {
 269   HOST_WIDE_INT val = INTVAL (operands[2]);
 270   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
 271   HOST_WIDE_INT rest = val - low;
 272
 273   operands[3] = GEN_INT (rest);
 274   operands[4] = GEN_INT (low);
 275 }")
 276
 277 (define_insn ""
 278   [(set (match_operand:DI 0 "register_operand" "=r,r")
 279         (sign_extend:DI
 280          (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ,rJ")
 281                   (match_operand:SI 2 "sext_add_operand" "rI,O"))))]
 282   ""
 283   "@
 284    addl %r1,%2,%0
 285    subl %r1,%n2,%0")
 286
 287 (define_split
 288   [(set (match_operand:DI 0 "register_operand" "")
 289         (sign_extend:DI
 290          (plus:SI (match_operand:SI 1 "register_operand" "")
 291                   (match_operand:SI 2 "const_int_operand" ""))))
 292    (clobber (match_operand:SI 3 "register_operand" ""))]
 293   "! sext_add_operand (operands[2], SImode) && INTVAL (operands[2]) > 0
 294    && INTVAL (operands[2]) % 4 == 0"
 295   [(set (match_dup 3) (match_dup 4))
 296    (set (match_dup 0) (sign_extend:DI (plus:SI (mult:SI (match_dup 3)
 297                                                         (match_dup 5))
 298                                                (match_dup 1))))]
 299   "
 300 {
 301   HOST_WIDE_INT val = INTVAL (operands[2]) / 4;
 302   int mult = 4;
 303
 304   if (val % 2 == 0)
 305     val /= 2, mult = 8;
 306
 307   operands[4] = GEN_INT (val);
 308   operands[5] = GEN_INT (mult);
 309 }")
 310
 311 (define_split
 312   [(set (match_operand:DI 0 "register_operand" "")
 313         (sign_extend:DI
 314          (plus:SI (match_operator:SI 1 "comparison_operator"
 315                                      [(match_operand 2 "" "")
 316                                       (match_operand 3 "" "")])
 317                   (match_operand:SI 4 "add_operand" ""))))
 318    (clobber (match_operand:DI 5 "register_operand" ""))]
 319   ""
 320   [(set (match_dup 5) (match_dup 6))
 321    (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 7) (match_dup 4))))]
 322   "
 323 {
 324   operands[6] = gen_rtx (GET_CODE (operands[1]), DImode,
 325                          operands[2], operands[3]);
 326   operands[7] = gen_lowpart (SImode, operands[5]);
 327 }")
 328
 329 (define_insn "adddi3"
 330   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r")
 331         (plus:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ,rJ,rJ")
 332                  (match_operand:DI 2 "add_operand" "rI,O,K,L")))]
 333   ""
 334   "@
 335    addq %r1,%2,%0
 336    subq %r1,%n2,%0
 337    lda %0,%2(%r1)
 338    ldah %0,%h2(%r1)")
 339
 340 ;; Don't do this if we are adjusting SP since we don't want to do
 341 ;; it in two steps.
 342 (define_split
 343   [(set (match_operand:DI 0 "register_operand" "")
 344         (plus:DI (match_operand:DI 1 "register_operand" "")
 345                  (match_operand:DI 2 "const_int_operand" "")))]
 346   "! add_operand (operands[2], DImode)
 347    && REGNO (operands[0]) != STACK_POINTER_REGNUM"
 348   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 3)))
 349    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
 350   "
 351 {
 352   HOST_WIDE_INT val = INTVAL (operands[2]);
 353   HOST_WIDE_INT low = (val & 0xffff) - 2 * (val & 0x8000);
 354   HOST_WIDE_INT rest = val - low;
 355
 356   operands[3] = GEN_INT (rest);
 357   operands[4] = GEN_INT (low);
 358 }")
 359
 360 (define_insn ""
 361   [(set (match_operand:SI 0 "register_operand" "=r,r")
 362         (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ,rJ")
 363                           (match_operand:SI 2 "const48_operand" "I,I"))
 364                  (match_operand:SI 3 "sext_add_operand" "rI,O")))]
 365   ""
 366   "@
 367    s%2addl %r1,%3,%0
 368    s%2subl %r1,%n3,%0")
 369
 370 (define_insn ""
 371   [(set (match_operand:DI 0 "register_operand" "=r,r")
 372         (sign_extend:DI
 373          (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ,rJ")
 374                            (match_operand:SI 2 "const48_operand" "I,I"))
 375                   (match_operand:SI 3 "sext_add_operand" "rI,O"))))]
 376   ""
 377   "@
 378    s%2addl %r1,%3,%0
 379    s%2subl %r1,%n3,%0")
 380
 381 (define_split
 382   [(set (match_operand:DI 0 "register_operand" "")
 383         (sign_extend:DI
 384          (plus:SI (mult:SI (match_operator:SI 1 "comparison_operator"
 385                                               [(match_operand 2 "" "")
 386                                                (match_operand 3 "" "")])
 387                            (match_operand:SI 4 "const48_operand" ""))
 388                   (match_operand:SI 5 "add_operand" ""))))
 389    (clobber (match_operand:DI 6 "register_operand" ""))]
 390   ""
 391   [(set (match_dup 6) (match_dup 7))
 392    (set (match_dup 0)
 393         (sign_extend:DI (plus:SI (mult:SI (match_dup 8) (match_dup 4))
 394                                  (match_dup 5))))]
 395   "
 396 {
 397   operands[7] = gen_rtx (GET_CODE (operands[1]), DImode,
 398                          operands[2], operands[3]);
 399   operands[8] = gen_lowpart (SImode, operands[6]);
 400 }")
 401
 402 (define_insn ""
 403   [(set (match_operand:DI 0 "register_operand" "=r,r")
 404         (plus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "rJ,rJ")
 405                           (match_operand:DI 2 "const48_operand" "I,I"))
 406                  (match_operand:DI 3 "reg_or_8bit_operand" "rI,O")))]
 407   ""
 408   "@
 409    s%2addq %r1,%3,%0
 410    s%2subq %1,%n3,%0")
 411
 412 ;; These variants of the above insns can occur if the third operand
 413 ;; is the frame pointer.  This is a kludge, but there doesn't
 414 ;; seem to be a way around it.  Only recognize them while reloading.
 415
 416 (define_insn ""
 417   [(set (match_operand:DI 0 "some_operand" "=&r")
 418         (plus:DI (plus:DI (match_operand:DI 1 "some_operand" "r")
 419                           (match_operand:DI 2 "some_operand" "r"))
 420                  (match_operand:DI 3 "some_operand" "rIOKL")))]
 421   "reload_in_progress"
 422   "#")
 423
 424 (define_split
 425   [(set (match_operand:DI 0 "register_operand" "")
 426         (plus:DI (plus:DI (match_operand:DI 1 "register_operand" "")
 427                           (match_operand:DI 2 "register_operand" ""))
 428                  (match_operand:DI 3 "add_operand" "")))]
 429   "reload_completed"
 430   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
 431    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
 432   "")
 433
 434 (define_insn ""
 435   [(set (match_operand:SI 0 "some_operand" "=&r")
 436         (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "some_operand" "rJ")
 437                                    (match_operand:SI 2 "const48_operand" "I"))
 438                           (match_operand:SI 3 "some_operand" "r"))
 439                  (match_operand:SI 4 "some_operand" "rIOKL")))]
 440   "reload_in_progress"
 441   "#")
 442
 443 (define_split
 444   [(set (match_operand:SI 0 "register_operand" "r")
 445         (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
 446                                    (match_operand:SI 2 "const48_operand" ""))
 447                           (match_operand:SI 3 "register_operand" ""))
 448                  (match_operand:SI 4 "add_operand" "rIOKL")))]
 449   "reload_completed"
 450   [(set (match_dup 0)
 451         (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
 452    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
 453   "")
 454
 455 (define_insn ""
 456   [(set (match_operand:DI 0 "some_operand" "=&r")
 457         (sign_extend:DI
 458          (plus:SI (plus:SI
 459                    (mult:SI (match_operand:SI 1 "some_operand" "rJ")
 460                             (match_operand:SI 2 "const48_operand" "I"))
 461                    (match_operand:SI 3 "some_operand" "r"))
 462                   (match_operand:SI 4 "some_operand" "rIOKL"))))]
 463   "reload_in_progress"
 464   "#")
 465
 466 (define_split
 467   [(set (match_operand:DI 0 "register_operand" "")
 468         (sign_extend:DI
 469          (plus:SI (plus:SI
 470                    (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
 471                             (match_operand:SI 2 "const48_operand" ""))
 472                    (match_operand:SI 3 "register_operand" ""))
 473                   (match_operand:SI 4 "add_operand" ""))))]
 474   "reload_completed"
 475   [(set (match_dup 5)
 476         (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
 477    (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 5) (match_dup 4))))]
 478   "
 479 { operands[5] = gen_lowpart (SImode, operands[0]);
 480 }")
 481
 482 (define_insn ""
 483   [(set (match_operand:DI 0 "some_operand" "=&r")
 484         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "some_operand" "rJ")
 485                                    (match_operand:DI 2 "const48_operand" "I"))
 486                           (match_operand:DI 3 "some_operand" "r"))
 487                  (match_operand:DI 4 "some_operand" "rIOKL")))]
 488   "reload_in_progress"
 489   "#")
 490
 491 (define_split
 492   [(set (match_operand:DI 0 "register_operand" "=")
 493         (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "")
 494                                    (match_operand:DI 2 "const48_operand" ""))
 495                           (match_operand:DI 3 "register_operand" ""))
 496                  (match_operand:DI 4 "add_operand" "")))]
 497   "reload_completed"
 498   [(set (match_dup 0)
 499         (plus:DI (mult:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
 500    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
 501   "")
 502
 503 (define_insn "negsi2"
 504   [(set (match_operand:SI 0 "register_operand" "=r")
 505         (neg:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI")))]
 506   ""
 507   "subl $31,%1,%0")
 508
 509 (define_insn ""
 510   [(set (match_operand:DI 0 "register_operand" "=r")
 511         (sign_extend:DI (neg:SI
 512                          (match_operand:SI 1 "reg_or_8bit_operand" "rI"))))]
 513   ""
 514   "subl $31,%1,%0")
 515
 516 (define_insn "negdi2"
 517   [(set (match_operand:DI 0 "register_operand" "=r")
 518         (neg:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
 519   ""
 520   "subq $31,%1,%0")
 521
 522 (define_expand "subsi3"
 523   [(set (match_operand:SI 0 "register_operand" "")
 524         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "")
 525                   (match_operand:SI 2 "reg_or_8bit_operand" "")))]
 526   ""
 527   "
 528 { emit_insn (gen_rtx (SET, VOIDmode, gen_lowpart (DImode, operands[0]),
 529                       gen_rtx (MINUS, DImode,
 530                                gen_lowpart (DImode, operands[1]),
 531                                gen_lowpart (DImode, operands[2]))));
 532   DONE;
 533
 534 } ")
 535
 536 (define_insn ""
 537   [(set (match_operand:SI 0 "register_operand" "=r")
 538         (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
 539                   (match_operand:SI 2 "reg_or_8bit_operand" "rI")))]
 540   ""
 541   "subl %r1,%2,%0")
 542
 543 (define_insn ""
 544   [(set (match_operand:DI 0 "register_operand" "=r")
 545         (sign_extend:DI (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
 546                                   (match_operand:SI 2 "reg_or_8bit_operand" "rI"))))]
 547   ""
 548   "subl %r1,%2,%0")
 549
 550 (define_insn "subdi3"
 551   [(set (match_operand:DI 0 "register_operand" "=r")
 552         (minus:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
 553                   (match_operand:DI 2 "reg_or_8bit_operand" "rI")))]
 554   ""
 555   "subq %r1,%2,%0")
 556
 557 (define_insn ""
 558   [(set (match_operand:SI 0 "register_operand" "=r")
 559         (minus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
 560                            (match_operand:SI 2 "const48_operand" "I"))
 561                   (match_operand:SI 3 "reg_or_8bit_operand" "rI")))]
 562   ""
 563   "s%2subl %r1,%3,%0")
 564
 565 (define_insn ""
 566   [(set (match_operand:DI 0 "register_operand" "=r")
 567         (sign_extend:DI
 568          (minus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "rJ")
 569                             (match_operand:SI 2 "const48_operand" "I"))
 570                    (match_operand:SI 3 "reg_or_8bit_operand" "rI"))))]
 571   ""
 572   "s%2subl %r1,%3,%0")
 573
 574 (define_insn ""
 575   [(set (match_operand:DI 0 "register_operand" "=r")
 576         (minus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
 577                            (match_operand:DI 2 "const48_operand" "I"))
 578                   (match_operand:DI 3 "reg_or_8bit_operand" "rI")))]
 579   ""
 580   "s%2subq %r1,%3,%0")
 581
 582 (define_insn "mulsi3"
 583   [(set (match_operand:SI 0 "register_operand" "=r")
 584         (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
 585                  (match_operand:SI 2 "reg_or_0_operand" "rJ")))]
 586   ""
 587   "mull %r1,%r2,%0"
 588   [(set_attr "type" "imull")])
 589
 590 (define_insn ""
 591   [(set (match_operand:DI 0 "register_operand" "=r")
 592         (sign_extend:DI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "%rJ")
 593                                  (match_operand:SI 2 "reg_or_0_operand" "rJ"))))]
 594   ""
 595   "mull %r1,%r2,%0"
 596   [(set_attr "type" "imull")])
 597
 598 (define_insn "muldi3"
 599   [(set (match_operand:DI 0 "register_operand" "=r")
 600         (mult:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ")
 601                  (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
 602   ""
 603   "mulq %r1,%r2,%0"
 604   [(set_attr "type" "imulq")])
 605
 606 (define_insn "umuldi3_highpart"
 607   [(set (match_operand:DI 0 "register_operand" "=r")
 608         (truncate:DI
 609          (lshiftrt:TI
 610           (mult:TI (zero_extend:TI (match_operand:DI 1 "register_operand" "r"))
 611                    (zero_extend:TI (match_operand:DI 2 "register_operand" "r")))
 612           (const_int 64))))]
 613   ""
 614   "umulh %1,%2,%0"
 615   [(set_attr "type" "imulh")])
 616
 617 (define_insn ""
 618   [(set (match_operand:DI 0 "register_operand" "=r")
 619         (truncate:DI
 620          (lshiftrt:TI
 621           (mult:TI (zero_extend:TI (match_operand:DI 1 "register_operand" "r"))
 622                    (match_operand:TI 2 "cint8_operand" "I"))
 623           (const_int 64))))]
 624   ""
 625   "umulh %1,%2,%0"
 626   [(set_attr "type" "imulh")])
 627 \f
 628 ;; The divide and remainder operations always take their inputs from
 629 ;; r24 and r25, put their output in r27, and clobber r23 and r28.
 630
 631 ;; ??? comment out the divsi routines since the library functions
 632 ;; don't seem to do the right thing with the high 32-bits of a
 633 ;; register nonzero.
 634
 635 ;(define_expand "divsi3"
 636 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
 637 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
 638 ;   (parallel [(set (reg:SI 27)
 639 ;                  (div:SI (reg:SI 24)
 640 ;                          (reg:SI 25)))
 641 ;             (clobber (reg:DI 23))
 642 ;             (clobber (reg:DI 28))])
 643 ;   (set (match_operand:SI 0 "general_operand" "")
 644 ;       (reg:SI 27))]
 645 ;  "!TARGET_OPEN_VMS"
 646 ;  "")
 647
 648 ;(define_expand "udivsi3"
 649 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
 650 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
 651 ;   (parallel [(set (reg:SI 27)
 652 ;                  (udiv:SI (reg:SI 24)
 653 ;                           (reg:SI 25)))
 654 ;             (clobber (reg:DI 23))
 655 ;             (clobber (reg:DI 28))])
 656 ;   (set (match_operand:SI 0 "general_operand" "")
 657 ;       (reg:SI 27))]
 658 ;  "!TARGET_OPEN_VMS"
 659 ;  "")
 660
 661 ;(define_expand "modsi3"
 662 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
 663 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
 664 ;   (parallel [(set (reg:SI 27)
 665 ;                  (mod:SI (reg:SI 24)
 666 ;                          (reg:SI 25)))
 667 ;             (clobber (reg:DI 23))
 668 ;             (clobber (reg:DI 28))])
 669 ;   (set (match_operand:SI 0 "general_operand" "")
 670 ;       (reg:SI 27))]
 671 ;  "!TARGET_OPEN_VMS"
 672 ;  "")
 673
 674 ;(define_expand "umodsi3"
 675 ;  [(set (reg:SI 24) (match_operand:SI 1 "input_operand" ""))
 676 ;   (set (reg:SI 25) (match_operand:SI 2 "input_operand" ""))
 677 ;   (parallel [(set (reg:SI 27)
 678 ;                  (umod:SI (reg:SI 24)
 679 ;                           (reg:SI 25)))
 680 ;             (clobber (reg:DI 23))
 681 ;             (clobber (reg:DI 28))])
 682 ;   (set (match_operand:SI 0 "general_operand" "")
 683 ;       (reg:SI 27))]
 684 ;  "!TARGET_OPEN_VMS"
 685 ;  "")
 686
 687 (define_expand "divdi3"
 688   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
 689    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
 690    (parallel [(set (reg:DI 27)
 691                    (div:DI (reg:DI 24)
 692                            (reg:DI 25)))
 693               (clobber (reg:DI 23))
 694               (clobber (reg:DI 28))])
 695    (set (match_operand:DI 0 "general_operand" "")
 696         (reg:DI 27))]
 697   "!TARGET_OPEN_VMS"
 698   "")
 699
 700 (define_expand "udivdi3"
 701   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
 702    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
 703    (parallel [(set (reg:DI 27)
 704                    (udiv:DI (reg:DI 24)
 705                             (reg:DI 25)))
 706               (clobber (reg:DI 23))
 707               (clobber (reg:DI 28))])
 708    (set (match_operand:DI 0 "general_operand" "")
 709         (reg:DI 27))]
 710   "!TARGET_OPEN_VMS"
 711   "")
 712
 713 (define_expand "moddi3"
 714   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
 715    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
 716    (parallel [(set (reg:DI 27)
 717                    (mod:DI (reg:DI 24)
 718                            (reg:DI 25)))
 719               (clobber (reg:DI 23))
 720               (clobber (reg:DI 28))])
 721    (set (match_operand:DI 0 "general_operand" "")
 722         (reg:DI 27))]
 723   "!TARGET_OPEN_VMS"
 724   "")
 725
 726 (define_expand "umoddi3"
 727   [(set (reg:DI 24) (match_operand:DI 1 "input_operand" ""))
 728    (set (reg:DI 25) (match_operand:DI 2 "input_operand" ""))
 729    (parallel [(set (reg:DI 27)
 730                    (umod:DI (reg:DI 24)
 731                             (reg:DI 25)))
 732               (clobber (reg:DI 23))
 733               (clobber (reg:DI 28))])
 734    (set (match_operand:DI 0 "general_operand" "")
 735         (reg:DI 27))]
 736   "!TARGET_OPEN_VMS"
 737   "")
 738
 739 ;(define_insn ""
 740 ;  [(set (reg:SI 27)
 741 ;       (match_operator:SI 1 "divmod_operator"
 742 ;                       [(reg:SI 24) (reg:SI 25)]))
 743 ;   (clobber (reg:DI 23))
 744 ;   (clobber (reg:DI 28))]
 745 ;  "!TARGET_OPEN_VMS"
 746 ;  "%E1 $24,$25,$27"
 747 ;  [(set_attr "type" "isubr")])
 748
 749 (define_insn ""
 750   [(set (reg:DI 27)
 751         (match_operator:DI 1 "divmod_operator"
 752                         [(reg:DI 24) (reg:DI 25)]))
 753    (clobber (reg:DI 23))
 754    (clobber (reg:DI 28))]
 755   "!TARGET_OPEN_VMS"
 756   "%E1 $24,$25,$27"
 757   [(set_attr "type" "isubr")])
 758 \f
 759 ;; Next are the basic logical operations.  These only exist in DImode.
 760
 761 (define_insn "anddi3"
 762   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
 763         (and:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ,rJ")
 764                 (match_operand:DI 2 "and_operand" "rI,N,MH")))]
 765   ""
 766   "@
 767    and %r1,%2,%0
 768    bic %r1,%N2,%0
 769    zapnot %r1,%m2,%0"
 770   [(set_attr "type" "ilog,ilog,shift")])
 771
 772 ;; There are times when we can split an AND into two AND insns.  This occurs
 773 ;; when we can first clear any bytes and then clear anything else.  For
 774 ;; example "I & 0xffff07" is "(I & 0xffffff) & 0xffffffffffffff07".
 775 ;; Only do this when running on 64-bit host since the computations are
 776 ;; too messy otherwise.
 777
 778 (define_split
 779   [(set (match_operand:DI 0 "register_operand" "")
 780         (and:DI (match_operand:DI 1 "register_operand" "")
 781                 (match_operand:DI 2 "const_int_operand" "")))]
 782   "HOST_BITS_PER_WIDE_INT == 64 && ! and_operand (operands[2], DImode)"
 783   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
 784    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
 785   "
 786 {
 787   unsigned HOST_WIDE_INT mask1 = INTVAL (operands[2]);
 788   unsigned HOST_WIDE_INT mask2 = mask1;
 789   int i;
 790
 791   /* For each byte that isn't all zeros, make it all ones.  */
 792   for (i = 0; i < 64; i += 8)
 793     if ((mask1 & ((HOST_WIDE_INT) 0xff << i)) != 0)
 794       mask1 |= (HOST_WIDE_INT) 0xff << i;
 795
 796   /* Now turn on any bits we've just turned off.  */
 797   mask2 |= ~ mask1;
 798
 799   operands[3] = GEN_INT (mask1);
 800   operands[4] = GEN_INT (mask2);
 801 }")
 802
 803 (define_insn "zero_extendqihi2"
 804   [(set (match_operand:HI 0 "register_operand" "=r")
 805         (zero_extend:HI (match_operand:QI 1 "register_operand" "r")))]
 806   ""
 807   "zapnot %1,1,%0"
 808   [(set_attr "type" "shift")])
 809
 810 (define_insn ""
 811   [(set (match_operand:SI 0 "register_operand" "=r,r")
 812         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
 813   "TARGET_BYTE_OPS"
 814   "@
 815    zapnot %1,1,%0
 816    ldbu %0,%1"
 817   [(set_attr "type" "shift,ld")])
 818
 819 (define_insn ""
 820   [(set (match_operand:SI 0 "register_operand" "=r")
 821         (zero_extend:SI (match_operand:QI 1 "register_operand" "r")))]
 822   "! TARGET_BYTE_OPS"
 823   "zapnot %1,1,%0"
 824   [(set_attr "type" "shift")])
 825
 826 (define_expand "zero_extendqisi2"
 827   [(set (match_operand:SI 0 "register_operand" "")
 828         (zero_extend:SI (match_operand:QI 1 "register_operand" "")))]
 829   ""
 830   "")
 831
 832 (define_insn ""
 833   [(set (match_operand:DI 0 "register_operand" "=r,r")
 834         (zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
 835   "TARGET_BYTE_OPS"
 836   "@
 837    zapnot %1,1,%0
 838    ldbu %0,%1"
 839   [(set_attr "type" "shift,ld")])
 840
 841 (define_insn ""
 842   [(set (match_operand:DI 0 "register_operand" "=r")
 843         (zero_extend:DI (match_operand:QI 1 "register_operand" "r")))]
 844   "! TARGET_BYTE_OPS"
 845   "zapnot %1,1,%0"
 846   [(set_attr "type" "shift")])
 847
 848 (define_expand "zero_extendqidi2"
 849   [(set (match_operand:DI 0 "register_operand" "")
 850         (zero_extend:DI (match_operand:QI 1 "register_operand" "")))]
 851   ""
 852   "")
 853
 854 (define_insn ""
 855   [(set (match_operand:SI 0 "register_operand" "=r,r")
 856         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
 857   "TARGET_BYTE_OPS"
 858   "@
 859    zapnot %1,3,%0
 860    ldwu %0,%1"
 861   [(set_attr "type" "shift,ld")])
 862
 863 (define_insn ""
 864   [(set (match_operand:SI 0 "register_operand" "=r")
 865         (zero_extend:SI (match_operand:HI 1 "register_operand" "r")))]
 866   "! TARGET_BYTE_OPS"
 867   "zapnot %1,3,%0"
 868   [(set_attr "type" "shift")])
 869
 870 (define_expand "zero_extendhisi2"
 871   [(set (match_operand:SI 0 "register_operand" "")
 872         (zero_extend:SI (match_operand:HI 1 "register_operand" "")))]
 873   ""
 874   "")
 875
 876 (define_insn ""
 877   [(set (match_operand:DI 0 "register_operand" "=r,r")
 878         (zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
 879   "TARGET_BYTE_OPS"
 880   "@
 881    zapnot %1,3,%0
 882    ldwu %0,%1"
 883   [(set_attr "type" "shift,ld")])
 884
 885 (define_insn ""
 886   [(set (match_operand:DI 0 "register_operand" "=r")
 887         (zero_extend:DI (match_operand:HI 1 "register_operand" "r")))]
 888   ""
 889   "zapnot %1,3,%0"
 890   [(set_attr "type" "shift")])
 891
 892 (define_expand "zero_extendhidi2"
 893   [(set (match_operand:DI 0 "register_operand" "")
 894         (zero_extend:DI (match_operand:HI 1 "register_operand" "")))]
 895   ""
 896   "")
 897
 898 (define_insn "zero_extendsidi2"
 899   [(set (match_operand:DI 0 "register_operand" "=r")
 900         (zero_extend:DI (match_operand:SI 1 "register_operand" "r")))]
 901   ""
 902   "zapnot %1,15,%0"
 903   [(set_attr "type" "shift")])
 904
 905 (define_insn  ""
 906   [(set (match_operand:DI 0 "register_operand" "=r")
 907         (and:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
 908                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
 909   ""
 910   "bic %r2,%1,%0"
 911   [(set_attr "type" "ilog")])
 912
 913 (define_insn "iordi3"
 914   [(set (match_operand:DI 0 "register_operand" "=r,r")
 915         (ior:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
 916                 (match_operand:DI 2 "or_operand" "rI,N")))]
 917   ""
 918   "@
 919    bis %r1,%2,%0
 920    ornot %r1,%N2,%0"
 921   [(set_attr "type" "ilog")])
 922
 923 (define_insn "one_cmpldi2"
 924   [(set (match_operand:DI 0 "register_operand" "=r")
 925         (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI")))]
 926   ""
 927   "ornot $31,%1,%0"
 928   [(set_attr "type" "ilog")])
 929
 930 (define_insn ""
 931   [(set (match_operand:DI 0 "register_operand" "=r")
 932         (ior:DI (not:DI (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
 933                 (match_operand:DI 2 "reg_or_0_operand" "rJ")))]
 934   ""
 935   "ornot %r2,%1,%0"
 936   [(set_attr "type" "ilog")])
 937
 938 (define_insn "xordi3"
 939   [(set (match_operand:DI 0 "register_operand" "=r,r")
 940         (xor:DI (match_operand:DI 1 "reg_or_0_operand" "%rJ,rJ")
 941                 (match_operand:DI 2 "or_operand" "rI,N")))]
 942   ""
 943   "@
 944    xor %r1,%2,%0
 945    eqv %r1,%N2,%0"
 946   [(set_attr "type" "ilog")])
 947
 948 (define_insn ""
 949   [(set (match_operand:DI 0 "register_operand" "=r")
 950         (not:DI (xor:DI (match_operand:DI 1 "register_operand" "%rJ")
 951                         (match_operand:DI 2 "register_operand" "rI"))))]
 952   ""
 953   "eqv %r1,%2,%0"
 954   [(set_attr "type" "ilog")])
 955 \f
 956 ;; Next come the shifts and the various extract and insert operations.
 957
 958 (define_insn "ashldi3"
 959   [(set (match_operand:DI 0 "register_operand" "=r,r")
 960         (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ,rJ")
 961                    (match_operand:DI 2 "reg_or_6bit_operand" "P,rI")))]
 962   ""
 963   "*
 964 {
 965   switch (which_alternative)
 966     {
 967     case 0:
 968       if (operands[2] == const1_rtx)
 969         return \"addq %r1,%r1,%0\";
 970       else
 971         return \"s%P2addq %r1,0,%0\";
 972     case 1:
 973       return \"sll %r1,%2,%0\";
 974     }
 975 }"
 976   [(set_attr "type" "iadd,shift")])
 977
 978 ;; ??? The following pattern is made by combine, but earlier phases
 979 ;; (specifically flow) can't handle it.  This occurs in jump.c.  Deal
 980 ;; with this in a better way at some point.
 981 ;;(define_insn ""
 982 ;;  [(set (match_operand:DI 0 "register_operand" "=r")
 983 ;;      (sign_extend:DI
 984 ;;       (subreg:SI (ashift:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
 985 ;;                             (match_operand:DI 2 "const_int_operand" "P"))
 986 ;;                  0)))]
 987 ;;  "INTVAL (operands[2]) >= 1 && INTVAL (operands[2]) <= 3"
 988 ;;  "*
 989 ;;{
 990 ;;  if (operands[2] == const1_rtx)
 991 ;;    return \"addl %r1,%r1,%0\";
 992 ;;  else
 993 ;;    return \"s%P2addl %r1,0,%0\";
 994 ;; }"
 995 ;;  [(set_attr "type" "iadd")])
 996
 997 (define_insn "lshrdi3"
 998   [(set (match_operand:DI 0 "register_operand" "=r")
 999         (lshiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1000                      (match_operand:DI 2 "reg_or_6bit_operand" "rI")))]
1001   ""
1002   "srl %r1,%2,%0"
1003   [(set_attr "type" "shift")])
1004
1005 (define_insn "ashrdi3"
1006   [(set (match_operand:DI 0 "register_operand" "=r")
1007         (ashiftrt:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1008                      (match_operand:DI 2 "reg_or_6bit_operand" "rI")))]
1009   ""
1010   "sra %r1,%2,%0"
1011   [(set_attr "type" "shift")])
1012
1013 (define_expand "extendqihi2"
1014   [(set (match_dup 2)
1015         (ashift:DI (match_operand:QI 1 "some_operand" "")
1016                    (const_int 56)))
1017    (set (match_operand:HI 0 "register_operand" "")
1018         (ashiftrt:DI (match_dup 2)
1019                      (const_int 56)))]
1020   ""
1021   "
1022 {
1023   if (TARGET_BYTE_OPS)
1024     {
1025       emit_insn (gen_extendqihi2x (operands[0],
1026                                    force_reg (QImode, operands[1])));
1027       DONE;
1028     }
1029
1030  /* If we have an unaligned MEM, extend to DImode (which we do
1031      specially) and then copy to the result.  */
1032   if (unaligned_memory_operand (operands[1], HImode))
1033     {
1034       rtx temp = gen_reg_rtx (DImode);
1035
1036       emit_insn (gen_extendqidi2 (temp, operands[1]));
1037       emit_move_insn (operands[0], gen_lowpart (HImode, temp));
1038       DONE;
1039     }
1040
1041   operands[0] = gen_lowpart (DImode, operands[0]);
1042   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1043   operands[2] = gen_reg_rtx (DImode);
1044 }")
1045
1046 (define_insn "extendqidi2x"
1047   [(set (match_operand:DI 0 "register_operand" "=r")
1048         (sign_extend:DI (match_operand:QI 1 "register_operand" "r")))]
1049   "TARGET_BYTE_OPS"
1050   "sextb %1,%0"
1051   [(set_attr "type" "shift")])
1052
1053 (define_insn "extendhidi2x"
1054   [(set (match_operand:DI 0 "register_operand" "=r")
1055         (sign_extend:DI (match_operand:HI 1 "register_operand" "r")))]
1056   "TARGET_BYTE_OPS"
1057   "sextw %1,%0"
1058   [(set_attr "type" "shift")])
1059
1060 (define_insn "extendqisi2x"
1061   [(set (match_operand:SI 0 "register_operand" "=r")
1062         (sign_extend:SI (match_operand:QI 1 "register_operand" "r")))]
1063   "TARGET_BYTE_OPS"
1064   "sextb %1,%0"
1065   [(set_attr "type" "shift")])
1066
1067 (define_insn "extendhisi2x"
1068   [(set (match_operand:SI 0 "register_operand" "=r")
1069         (sign_extend:SI (match_operand:HI 1 "register_operand" "r")))]
1070   "TARGET_BYTE_OPS"
1071   "sextw %1,%0"
1072   [(set_attr "type" "shift")])
1073
1074 (define_insn "extendqihi2x"
1075   [(set (match_operand:HI 0 "register_operand" "=r")
1076         (sign_extend:HI (match_operand:QI 1 "register_operand" "r")))]
1077   "TARGET_BYTE_OPS"
1078   "sextb %1,%0"
1079   [(set_attr "type" "shift")])
1080
1081 (define_expand "extendqisi2"
1082   [(set (match_dup 2)
1083         (ashift:DI (match_operand:QI 1 "some_operand" "")
1084                    (const_int 56)))
1085    (set (match_operand:SI 0 "register_operand" "")
1086         (ashiftrt:DI (match_dup 2)
1087                      (const_int 56)))]
1088   ""
1089   "
1090 {
1091   if (TARGET_BYTE_OPS)
1092     {
1093       emit_insn (gen_extendqisi2x (operands[0],
1094                                    force_reg (QImode, operands[1])));
1095       DONE;
1096     }
1097
1098   /* If we have an unaligned MEM, extend to a DImode form of
1099      the result (which we do specially).  */
1100   if (unaligned_memory_operand (operands[1], QImode))
1101     {
1102       rtx temp = gen_reg_rtx (DImode);
1103
1104       emit_insn (gen_extendqidi2 (temp, operands[1]));
1105       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1106       DONE;
1107     }
1108
1109   operands[0] = gen_lowpart (DImode, operands[0]);
1110   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1111   operands[2] = gen_reg_rtx (DImode);
1112 }")
1113
1114 (define_expand "extendqidi2"
1115   [(set (match_dup 2)
1116         (ashift:DI (match_operand:QI 1 "some_operand" "")
1117                    (const_int 56)))
1118    (set (match_operand:DI 0 "register_operand" "")
1119         (ashiftrt:DI (match_dup 2)
1120                      (const_int 56)))]
1121   ""
1122   "
1123 { extern rtx get_unaligned_address ();
1124
1125   if (TARGET_BYTE_OPS)
1126     {
1127       emit_insn (gen_extendqidi2x (operands[0],
1128                                    force_reg (QImode, operands[1])));
1129       DONE;
1130     }
1131
1132   if (unaligned_memory_operand (operands[1], QImode))
1133     {
1134       rtx seq
1135         = gen_unaligned_extendqidi (operands[0],
1136                                     get_unaligned_address (operands[1], 1));
1137
1138       alpha_set_memflags (seq, operands[1]);
1139       emit_insn (seq);
1140       DONE;
1141     }
1142
1143   operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
1144   operands[2] = gen_reg_rtx (DImode);
1145 }")
1146
1147 (define_expand "extendhisi2"
1148   [(set (match_dup 2)
1149         (ashift:DI (match_operand:HI 1 "some_operand" "")
1150                    (const_int 48)))
1151    (set (match_operand:SI 0 "register_operand" "")
1152         (ashiftrt:DI (match_dup 2)
1153                      (const_int 48)))]
1154   ""
1155   "
1156 {
1157   if (TARGET_BYTE_OPS)
1158     {
1159       emit_insn (gen_extendhisi2x (operands[0],
1160                                    force_reg (HImode, operands[1])));
1161       DONE;
1162     }
1163
1164   /* If we have an unaligned MEM, extend to a DImode form of
1165      the result (which we do specially).  */
1166   if (unaligned_memory_operand (operands[1], HImode))
1167     {
1168       rtx temp = gen_reg_rtx (DImode);
1169
1170       emit_insn (gen_extendhidi2 (temp, operands[1]));
1171       emit_move_insn (operands[0], gen_lowpart (SImode, temp));
1172       DONE;
1173     }
1174
1175   operands[0] = gen_lowpart (DImode, operands[0]);
1176   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1177   operands[2] = gen_reg_rtx (DImode);
1178 }")
1179
1180 (define_expand "extendhidi2"
1181   [(set (match_dup 2)
1182         (ashift:DI (match_operand:HI 1 "some_operand" "")
1183                    (const_int 48)))
1184    (set (match_operand:DI 0 "register_operand" "")
1185         (ashiftrt:DI (match_dup 2)
1186                      (const_int 48)))]
1187   ""
1188   "
1189 { extern rtx get_unaligned_address ();
1190
1191   if (TARGET_BYTE_OPS)
1192     {
1193       emit_insn (gen_extendhidi2x (operands[0],
1194                                    force_reg (HImode, operands[1])));
1195       DONE;
1196     }
1197
1198   if (unaligned_memory_operand (operands[1], HImode))
1199     {
1200       rtx seq
1201         = gen_unaligned_extendhidi (operands[0],
1202                                     get_unaligned_address (operands[1], 2));
1203
1204       alpha_set_memflags (seq, operands[1]);
1205       emit_insn (seq);
1206       DONE;
1207     }
1208
1209   operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
1210   operands[2] = gen_reg_rtx (DImode);
1211 }")
1212
1213 ;; Here's how we sign extend an unaligned byte and halfword.  Doing this
1214 ;; as a pattern saves one instruction.  The code is similar to that for
1215 ;; the unaligned loads (see below).
1216 ;;
1217 ;; Operand 1 is the address + 1 (+2 for HI), operand 0 is the result.
1218 (define_expand "unaligned_extendqidi"
1219   [(set (match_dup 2) (match_operand:DI 1 "address_operand" ""))
1220    (set (match_dup 3)
1221         (mem:DI (and:DI (plus:DI (match_dup 2) (const_int -1))
1222                         (const_int -8))))
1223    (set (match_dup 4)
1224         (ashift:DI (match_dup 3)
1225                    (minus:DI (const_int 56)
1226                              (ashift:DI
1227                               (and:DI (plus:DI (match_dup 2) (const_int -1))
1228                                       (const_int 7))
1229                               (const_int 3)))))
1230    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
1231         (ashiftrt:DI (match_dup 4) (const_int 56)))]
1232   ""
1233   "
1234 { operands[2] = gen_reg_rtx (DImode);
1235   operands[3] = gen_reg_rtx (DImode);
1236   operands[4] = gen_reg_rtx (DImode);
1237 }")
1238
1239 (define_expand "unaligned_extendhidi"
1240   [(set (match_dup 2) (match_operand:DI 1 "address_operand" ""))
1241    (set (match_dup 3)
1242         (mem:DI (and:DI (plus:DI (match_dup 2) (const_int -2))
1243                         (const_int -8))))
1244    (set (match_dup 4)
1245         (ashift:DI (match_dup 3)
1246                    (minus:DI (const_int 56)
1247                              (ashift:DI
1248                               (and:DI (plus:DI (match_dup 2) (const_int -1))
1249                                       (const_int 7))
1250                               (const_int 3)))))
1251    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
1252         (ashiftrt:DI (match_dup 4) (const_int 48)))]
1253   ""
1254   "
1255 { operands[2] = gen_reg_rtx (DImode);
1256   operands[3] = gen_reg_rtx (DImode);
1257   operands[4] = gen_reg_rtx (DImode);
1258 }")
1259
1260 (define_insn ""
1261   [(set (match_operand:DI 0 "register_operand" "=r")
1262         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1263                          (match_operand:DI 2 "mode_width_operand" "n")
1264                          (match_operand:DI 3 "mul8_operand" "I")))]
1265   ""
1266   "ext%M2l %r1,%s3,%0"
1267   [(set_attr "type" "shift")])
1268
1269 (define_insn ""
1270   [(set (match_operand:DI 0 "register_operand" "=r")
1271         (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1272                          (match_operand:DI 2 "mode_width_operand" "n")
1273                          (ashift:DI (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1274                                     (const_int 3))))]
1275   ""
1276   "ext%M2l %r1,%3,%0"
1277   [(set_attr "type" "shift")])
1278
1279 (define_insn ""
1280   [(set (match_operand:DI 0 "register_operand" "=r")
1281         (ashift:DI
1282          (match_operand:DI 1 "reg_or_0_operand" "rJ")
1283           (minus:DI (const_int 56)
1284                     (ashift:DI
1285                      (and:DI
1286                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1287                                (const_int -1))
1288                       (const_int 7))
1289                      (const_int 3)))))]
1290   ""
1291   "extqh %r1,%2,%0"
1292   [(set_attr "type" "shift")])
1293
1294 (define_insn ""
1295   [(set (match_operand:DI 0 "register_operand" "=r")
1296         (ashift:DI
1297          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1298                  (const_int 2147483647))
1299          (minus:DI (const_int 56)
1300                     (ashift:DI
1301                      (and:DI
1302                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1303                                (const_int -1))
1304                       (const_int 7))
1305                      (const_int 3)))))]
1306   ""
1307   "extlh %r1,%2,%0"
1308   [(set_attr "type" "shift")])
1309
1310 (define_insn ""
1311   [(set (match_operand:DI 0 "register_operand" "=r")
1312         (ashift:DI
1313          (and:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
1314                  (const_int 65535))
1315          (minus:DI (const_int 56)
1316                     (ashift:DI
1317                      (and:DI
1318                       (plus:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1319                                (const_int -1))
1320                       (const_int 7))
1321                      (const_int 3)))))]
1322   ""
1323   "extwh %r1,%2,%0"
1324   [(set_attr "type" "shift")])
1325
1326 ;; This converts an extXl into an extXh with an appropriate adjustment
1327 ;; to the address calculation.
1328
1329 ;;(define_split
1330 ;;  [(set (match_operand:DI 0 "register_operand" "")
1331 ;;      (ashift:DI (zero_extract:DI (match_operand:DI 1 "register_operand" "")
1332 ;;                                  (match_operand:DI 2 "mode_width_operand" "")
1333 ;;                                  (ashift:DI (match_operand:DI 3 "" "")
1334 ;;                                             (const_int 3)))
1335 ;;                 (match_operand:DI 4 "const_int_operand" "")))
1336 ;;   (clobber (match_operand:DI 5 "register_operand" ""))]
1337 ;;  "INTVAL (operands[4]) == 64 - INTVAL (operands[2])"
1338 ;;  [(set (match_dup 5) (match_dup 6))
1339 ;;   (set (match_dup 0)
1340 ;;      (ashift:DI (zero_extract:DI (match_dup 1) (match_dup 2)
1341 ;;                                  (ashift:DI (plus:DI (match_dup 5)
1342 ;;                                                      (match_dup 7))
1343 ;;                                             (const_int 3)))
1344 ;;                 (match_dup 4)))]
1345 ;;  "
1346 ;;{
1347 ;;  operands[6] = plus_constant (operands[3],
1348 ;;                             INTVAL (operands[2]) / BITS_PER_UNIT);
1349 ;;  operands[7] = GEN_INT (- INTVAL (operands[2]) / BITS_PER_UNIT);
1350 ;;}")
1351
1352 (define_insn ""
1353   [(set (match_operand:DI 0 "register_operand" "=r")
1354         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
1355                    (match_operand:DI 2 "mul8_operand" "I")))]
1356   ""
1357   "insbl %1,%s2,%0"
1358   [(set_attr "type" "shift")])
1359
1360 (define_insn ""
1361   [(set (match_operand:DI 0 "register_operand" "=r")
1362         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
1363                    (match_operand:DI 2 "mul8_operand" "I")))]
1364   ""
1365   "inswl %1,%s2,%0"
1366   [(set_attr "type" "shift")])
1367
1368 (define_insn ""
1369   [(set (match_operand:DI 0 "register_operand" "=r")
1370         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
1371                    (match_operand:DI 2 "mul8_operand" "I")))]
1372   ""
1373   "insll %1,%s2,%0"
1374   [(set_attr "type" "shift")])
1375
1376 (define_insn ""
1377   [(set (match_operand:DI 0 "register_operand" "=r")
1378         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" "r"))
1379                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1380                               (const_int 3))))]
1381   ""
1382   "insbl %1,%2,%0"
1383   [(set_attr "type" "shift")])
1384
1385 (define_insn ""
1386   [(set (match_operand:DI 0 "register_operand" "=r")
1387         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" "r"))
1388                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1389                               (const_int 3))))]
1390   ""
1391   "inswl %1,%2,%0"
1392   [(set_attr "type" "shift")])
1393
1394 (define_insn ""
1395   [(set (match_operand:DI 0 "register_operand" "=r")
1396         (ashift:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
1397                    (ashift:DI (match_operand:DI 2 "reg_or_8bit_operand" "rI")
1398                               (const_int 3))))]
1399   ""
1400   "insll %1,%2,%0"
1401   [(set_attr "type" "shift")])
1402
1403 ;; We do not include the insXh insns because they are complex to express
1404 ;; and it does not appear that we would ever want to generate them.
1405
1406 (define_insn ""
1407   [(set (match_operand:DI 0 "register_operand" "=r")
1408         (and:DI (not:DI (ashift:DI
1409                          (match_operand:DI 2 "mode_mask_operand" "n")
1410                          (ashift:DI
1411                           (match_operand:DI 3 "reg_or_8bit_operand" "rI")
1412                           (const_int 3))))
1413                 (match_operand:DI 1 "reg_or_0_operand" "rJ")))]
1414   ""
1415   "msk%U2l %r1,%3,%0"
1416   [(set_attr "type" "shift")])
1417
1418 ;; We do not include the mskXh insns because it does not appear we would ever
1419 ;; generate one.
1420 \f
1421 ;; Floating-point operations.  All the double-precision insns can extend
1422 ;; from single, so indicate that.  The exception are the ones that simply
1423 ;; play with the sign bits; it's not clear what to do there.
1424
1425 (define_insn "abssf2"
1426   [(set (match_operand:SF 0 "register_operand" "=f")
1427         (abs:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")))]
1428   "TARGET_FP"
1429   "cpys $f31,%R1,%0"
1430   [(set_attr "type" "fcpys")])
1431
1432 (define_insn "absdf2"
1433   [(set (match_operand:DF 0 "register_operand" "=f")
1434         (abs:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1435   "TARGET_FP"
1436   "cpys $f31,%R1,%0"
1437   [(set_attr "type" "fcpys")])
1438
1439 (define_insn "negsf2"
1440   [(set (match_operand:SF 0 "register_operand" "=f")
1441         (neg:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")))]
1442   "TARGET_FP"
1443   "cpysn %R1,%R1,%0"
1444   [(set_attr "type" "fadd")])
1445
1446 (define_insn "negdf2"
1447   [(set (match_operand:DF 0 "register_operand" "=f")
1448         (neg:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1449   "TARGET_FP"
1450   "cpysn %R1,%R1,%0"
1451   [(set_attr "type" "fadd")])
1452
1453 (define_insn ""
1454   [(set (match_operand:SF 0 "register_operand" "=&f")
1455         (plus:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1456                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1457   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1458   "add%,%)%& %R1,%R2,%0"
1459   [(set_attr "type" "fadd")
1460    (set_attr "trap" "yes")])
1461
1462 (define_insn "addsf3"
1463   [(set (match_operand:SF 0 "register_operand" "=f")
1464         (plus:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1465                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1466   "TARGET_FP"
1467   "add%,%)%& %R1,%R2,%0"
1468   [(set_attr "type" "fadd")
1469    (set_attr "trap" "yes")])
1470
1471 (define_insn ""
1472   [(set (match_operand:DF 0 "register_operand" "=&f")
1473         (plus:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1474                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1475   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1476   "add%-%)%& %R1,%R2,%0"
1477   [(set_attr "type" "fadd")
1478    (set_attr "trap" "yes")])
1479
1480 (define_insn "adddf3"
1481   [(set (match_operand:DF 0 "register_operand" "=f")
1482         (plus:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1483                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1484   "TARGET_FP"
1485   "add%-%)%& %R1,%R2,%0"
1486   [(set_attr "type" "fadd")
1487    (set_attr "trap" "yes")])
1488
1489 (define_insn ""
1490   [(set (match_operand:DF 0 "register_operand" "=f")
1491         (plus:DF (float_extend:DF
1492                   (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1493                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1494   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1495   "add%-%)%& %R1,%R2,%0"
1496   [(set_attr "type" "fadd")
1497    (set_attr "trap" "yes")])
1498
1499 (define_insn ""
1500   [(set (match_operand:DF 0 "register_operand" "=f")
1501         (plus:DF (float_extend:DF
1502                   (match_operand:SF 1 "reg_or_fp0_operand" "%fG"))
1503                  (float_extend:DF
1504                   (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1505   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1506   "add%-%)%& %R1,%R2,%0"
1507   [(set_attr "type" "fadd")
1508    (set_attr "trap" "yes")])
1509
1510 (define_insn "fix_truncdfdi2"
1511   [(set (match_operand:DI 0 "register_operand" "=f")
1512         (fix:DI (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1513   "TARGET_FP"
1514   "cvt%-qc %R1,%0"
1515   [(set_attr "type" "fadd")])
1516
1517 (define_insn "fix_truncsfdi2"
1518   [(set (match_operand:DI 0 "register_operand" "=f")
1519         (fix:DI (float_extend:DF
1520                  (match_operand:SF 1 "reg_or_fp0_operand" "fG"))))]
1521   "TARGET_FP"
1522   "cvt%-qc %R1,%0"
1523   [(set_attr "type" "fadd")])
1524
1525 (define_insn ""
1526   [(set (match_operand:SF 0 "register_operand" "=&f")
1527         (float:SF (match_operand:DI 1 "register_operand" "f")))]
1528   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1529   "cvtq%,%+%& %1,%0"
1530   [(set_attr "type" "fadd")
1531    (set_attr "trap" "yes")])
1532
1533 (define_insn "floatdisf2"
1534   [(set (match_operand:SF 0 "register_operand" "=f")
1535         (float:SF (match_operand:DI 1 "register_operand" "f")))]
1536   "TARGET_FP"
1537   "cvtq%,%+%& %1,%0"
1538   [(set_attr "type" "fadd")
1539    (set_attr "trap" "yes")])
1540
1541 (define_insn ""
1542   [(set (match_operand:DF 0 "register_operand" "=&f")
1543         (float:DF (match_operand:DI 1 "register_operand" "f")))]
1544   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1545   "cvtq%-%+%& %1,%0"
1546   [(set_attr "type" "fadd")
1547    (set_attr "trap" "yes")])
1548
1549 (define_insn "floatdidf2"
1550   [(set (match_operand:DF 0 "register_operand" "=f")
1551         (float:DF (match_operand:DI 1 "register_operand" "f")))]
1552   "TARGET_FP"
1553   "cvtq%-%+%& %1,%0"
1554   [(set_attr "type" "fadd")
1555    (set_attr "trap" "yes")])
1556
1557 (define_expand "extendsfdf2"
1558   [(use (match_operand:DF 0 "register_operand" ""))
1559    (use (match_operand:SF 1 "nonimmediate_operand" ""))]
1560   "TARGET_FP"
1561 "
1562 {
1563   if (alpha_tp == ALPHA_TP_INSN)
1564     emit_insn (gen_extendsfdf2_tp (operands[0],
1565                                    force_reg (SFmode, operands[1])));
1566   else
1567     emit_insn (gen_extendsfdf2_no_tp (operands[0], operands[1]));
1568
1569   DONE;
1570 }")
1571 ;; FIXME
1572 (define_insn "extendsfdf2_tp"
1573   [(set (match_operand:DF 0 "register_operand" "=&f")
1574         (float_extend:DF (match_operand:SF 1 "register_operand" "f")))]
1575   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1576   "cvtsts %1,%0"
1577   [(set_attr "type" "fadd")
1578    (set_attr "trap" "yes")])
1579
1580 (define_insn "extendsfdf2_no_tp"
1581   [(set (match_operand:DF 0 "register_operand" "=f,f,m")
1582         (float_extend:DF (match_operand:SF 1 "nonimmediate_operand" "f,m,f")))]
1583   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1584   "@
1585    cpys %1,%1,%0
1586    ld%, %0,%1
1587    st%- %1,%0"
1588   [(set_attr "type" "fcpys,ld,st")
1589    (set_attr "trap" "yes")])
1590
1591 (define_insn ""
1592   [(set (match_operand:SF 0 "register_operand" "=&f")
1593         (float_truncate:SF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1594   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1595   "cvt%-%,%)%& %R1,%0"
1596   [(set_attr "type" "fadd")
1597    (set_attr "trap" "yes")])
1598
1599 (define_insn "truncdfsf2"
1600   [(set (match_operand:SF 0 "register_operand" "=f")
1601         (float_truncate:SF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
1602   "TARGET_FP"
1603   "cvt%-%,%)%& %R1,%0"
1604   [(set_attr "type" "fadd")
1605    (set_attr "trap" "yes")])
1606
1607 (define_insn ""
1608   [(set (match_operand:SF 0 "register_operand" "=&f")
1609         (div:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1610                 (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1611   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1612   "div%,%)%& %R1,%R2,%0"
1613   [(set_attr "type" "fdivs")
1614    (set_attr "trap" "yes")])
1615
1616 (define_insn "divsf3"
1617   [(set (match_operand:SF 0 "register_operand" "=f")
1618         (div:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1619                 (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1620   "TARGET_FP"
1621   "div%,%)%& %R1,%R2,%0"
1622   [(set_attr "type" "fdivs")
1623    (set_attr "trap" "yes")])
1624
1625 (define_insn ""
1626   [(set (match_operand:DF 0 "register_operand" "=&f")
1627         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1628                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1629   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1630   "div%-%)%& %R1,%R2,%0"
1631   [(set_attr "type" "fdivt")
1632    (set_attr "trap" "yes")])
1633
1634 (define_insn "divdf3"
1635   [(set (match_operand:DF 0 "register_operand" "=f")
1636         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1637                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1638   "TARGET_FP"
1639   "div%-%)%& %R1,%R2,%0"
1640   [(set_attr "type" "fdivt")
1641    (set_attr "trap" "yes")])
1642
1643 (define_insn ""
1644   [(set (match_operand:DF 0 "register_operand" "=f")
1645         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1646                 (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1647   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1648   "div%-%)%& %R1,%R2,%0"
1649   [(set_attr "type" "fdivt")
1650    (set_attr "trap" "yes")])
1651
1652 (define_insn ""
1653   [(set (match_operand:DF 0 "register_operand" "=f")
1654         (div:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1655                 (float_extend:DF
1656                  (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1657   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1658   "div%-%)%& %R1,%R2,%0"
1659   [(set_attr "type" "fdivt")
1660    (set_attr "trap" "yes")])
1661
1662 (define_insn ""
1663   [(set (match_operand:DF 0 "register_operand" "=f")
1664         (div:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1665                 (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1666   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1667   "div%-%)%& %R1,%R2,%0"
1668   [(set_attr "type" "fdivt")
1669    (set_attr "trap" "yes")])
1670
1671 (define_insn ""
1672   [(set (match_operand:SF 0 "register_operand" "=&f")
1673         (mult:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1674                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1675   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1676   "mul%,%)%& %R1,%R2,%0"
1677   [(set_attr "type" "fmul")
1678    (set_attr "trap" "yes")])
1679
1680 (define_insn "mulsf3"
1681   [(set (match_operand:SF 0 "register_operand" "=f")
1682         (mult:SF (match_operand:SF 1 "reg_or_fp0_operand" "%fG")
1683                  (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1684   "TARGET_FP"
1685   "mul%,%)%& %R1,%R2,%0"
1686   [(set_attr "type" "fmul")
1687    (set_attr "trap" "yes")])
1688
1689 (define_insn ""
1690   [(set (match_operand:DF 0 "register_operand" "=&f")
1691         (mult:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1692                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1693   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1694   "mul%-%)%& %R1,%R2,%0"
1695   [(set_attr "type" "fmul")
1696    (set_attr "trap" "yes")])
1697
1698 (define_insn "muldf3"
1699   [(set (match_operand:DF 0 "register_operand" "=f")
1700         (mult:DF (match_operand:DF 1 "reg_or_fp0_operand" "%fG")
1701                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1702   "TARGET_FP"
1703   "mul%-%)%& %R1,%R2,%0"
1704   [(set_attr "type" "fmul")
1705    (set_attr "trap" "yes")])
1706
1707 (define_insn ""
1708   [(set (match_operand:DF 0 "register_operand" "=f")
1709         (mult:DF (float_extend:DF
1710                   (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1711                  (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1712   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1713   "mul%-%)%& %R1,%R2,%0"
1714   [(set_attr "type" "fmul")
1715    (set_attr "trap" "yes")])
1716
1717 (define_insn ""
1718   [(set (match_operand:DF 0 "register_operand" "=f")
1719         (mult:DF (float_extend:DF
1720                   (match_operand:SF 1 "reg_or_fp0_operand" "%fG"))
1721                  (float_extend:DF
1722                   (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1723   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1724   "mul%-%)%& %R1,%R2,%0"
1725   [(set_attr "type" "fmul")
1726    (set_attr "trap" "yes")])
1727
1728 (define_insn ""
1729   [(set (match_operand:SF 0 "register_operand" "=&f")
1730         (minus:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1731                   (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1732   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1733   "sub%,%)%& %R1,%R2,%0"
1734   [(set_attr "type" "fadd")
1735    (set_attr "trap" "yes")])
1736
1737 (define_insn "subsf3"
1738   [(set (match_operand:SF 0 "register_operand" "=f")
1739         (minus:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")
1740                   (match_operand:SF 2 "reg_or_fp0_operand" "fG")))]
1741   "TARGET_FP"
1742   "sub%,%)%& %R1,%R2,%0"
1743   [(set_attr "type" "fadd")
1744    (set_attr "trap" "yes")])
1745
1746 (define_insn ""
1747   [(set (match_operand:DF 0 "register_operand" "=&f")
1748         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1749                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1750   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
1751   "sub%-%)%& %R1,%R2,%0"
1752   [(set_attr "type" "fadd")
1753    (set_attr "trap" "yes")])
1754
1755 (define_insn "subdf3"
1756   [(set (match_operand:DF 0 "register_operand" "=f")
1757         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1758                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1759   "TARGET_FP"
1760   "sub%-%)%& %R1,%R2,%0"
1761   [(set_attr "type" "fadd")
1762    (set_attr "trap" "yes")])
1763
1764 (define_insn ""
1765   [(set (match_operand:DF 0 "register_operand" "=f")
1766         (minus:DF (float_extend:DF
1767                    (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1768                   (match_operand:DF 2 "reg_or_fp0_operand" "fG")))]
1769   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1770   "sub%-%)%& %R1,%R2,%0"
1771   [(set_attr "type" "fadd")
1772    (set_attr "trap" "yes")])
1773
1774 (define_insn ""
1775   [(set (match_operand:DF 0 "register_operand" "=f")
1776         (minus:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")
1777                   (float_extend:DF
1778                    (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1779   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1780   "sub%-%)%& %R1,%R2,%0"
1781   [(set_attr "type" "fadd")
1782    (set_attr "trap" "yes")])
1783
1784 (define_insn ""
1785   [(set (match_operand:DF 0 "register_operand" "=f")
1786         (minus:DF (float_extend:DF
1787                    (match_operand:SF 1 "reg_or_fp0_operand" "fG"))
1788                   (float_extend:DF
1789                    (match_operand:SF 2 "reg_or_fp0_operand" "fG"))))]
1790   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
1791   "sub%-%)%& %R1,%R2,%0"
1792   [(set_attr "type" "fadd")
1793    (set_attr "trap" "yes")])
1794 \f
1795 ;; Next are all the integer comparisons, and conditional moves and branches
1796 ;; and some of the related define_expand's and define_split's.
1797
1798 (define_insn ""
1799   [(set (match_operand:DI 0 "register_operand" "=r")
1800         (match_operator:DI 1 "alpha_comparison_operator"
1801                            [(match_operand:DI 2 "reg_or_0_operand" "rJ")
1802                             (match_operand:DI 3 "reg_or_8bit_operand" "rI")]))]
1803   ""
1804   "cmp%C1 %r2,%3,%0"
1805   [(set_attr "type" "icmp")])
1806
1807 (define_insn ""
1808   [(set (match_operand:DI 0 "register_operand" "=r")
1809         (match_operator:DI 1 "alpha_swapped_comparison_operator"
1810                            [(match_operand:DI 2 "reg_or_8bit_operand" "rI")
1811                             (match_operand:DI 3 "reg_or_0_operand" "rJ")]))]
1812   ""
1813   "cmp%c1 %r3,%2,%0"
1814   [(set_attr "type" "icmp")])
1815
1816 ;; This pattern exists so conditional moves of SImode values are handled.
1817 ;; Comparisons are still done in DImode though.
1818
1819 (define_insn ""
1820   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
1821         (if_then_else:DI
1822          (match_operator 2 "signed_comparison_operator"
1823                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
1824                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
1825          (match_operand:SI 1 "reg_or_8bit_operand" "rI,0,rI,0")
1826          (match_operand:SI 5 "reg_or_8bit_operand" "0,rI,0,rI")))]
1827   "operands[3] == const0_rtx || operands[4] == const0_rtx"
1828   "@
1829    cmov%C2 %r3,%1,%0
1830    cmov%D2 %r3,%5,%0
1831    cmov%c2 %r4,%1,%0
1832    cmov%d2 %r4,%5,%0"
1833   [(set_attr "type" "cmov")])
1834
1835 (define_insn ""
1836   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r")
1837         (if_then_else:DI
1838          (match_operator 2 "signed_comparison_operator"
1839                          [(match_operand:DI 3 "reg_or_0_operand" "rJ,rJ,J,J")
1840                           (match_operand:DI 4 "reg_or_0_operand" "J,J,rJ,rJ")])
1841          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0,rI,0")
1842          (match_operand:DI 5 "reg_or_8bit_operand" "0,rI,0,rI")))]
1843   "operands[3] == const0_rtx || operands[4] == const0_rtx"
1844   "@
1845    cmov%C2 %r3,%1,%0
1846    cmov%D2 %r3,%5,%0
1847    cmov%c2 %r4,%1,%0
1848    cmov%d2 %r4,%5,%0"
1849   [(set_attr "type" "cmov")])
1850
1851 (define_insn ""
1852   [(set (match_operand:DI 0 "register_operand" "=r,r")
1853         (if_then_else:DI
1854          (eq (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
1855                               (const_int 1)
1856                               (const_int 0))
1857              (const_int 0))
1858          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
1859          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
1860   ""
1861   "@
1862    cmovlbc %r2,%1,%0
1863    cmovlbs %r2,%3,%0"
1864   [(set_attr "type" "cmov")])
1865
1866 (define_insn ""
1867   [(set (match_operand:DI 0 "register_operand" "=r,r")
1868         (if_then_else:DI
1869          (ne (zero_extract:DI (match_operand:DI 2 "reg_or_0_operand" "rJ,rJ")
1870                               (const_int 1)
1871                               (const_int 0))
1872              (const_int 0))
1873          (match_operand:DI 1 "reg_or_8bit_operand" "rI,0")
1874          (match_operand:DI 3 "reg_or_8bit_operand" "0,rI")))]
1875   ""
1876   "@
1877    cmovlbs %r2,%1,%0
1878    cmovlbc %r2,%3,%0"
1879   [(set_attr "type" "cmov")])
1880
1881 ;; This form is added since combine thinks that an IF_THEN_ELSE with both
1882 ;; arms constant is a single insn, so it won't try to form it if combine
1883 ;; knows they are really two insns.  This occurs in divides by powers
1884 ;; of two.
1885
1886 (define_insn ""
1887   [(set (match_operand:DI 0 "register_operand" "=r")
1888         (if_then_else:DI
1889          (match_operator 2 "signed_comparison_operator"
1890                          [(match_operand:DI 3 "reg_or_0_operand" "rJ")
1891                           (const_int 0)])
1892          (plus:DI (match_dup 0)
1893                   (match_operand:DI 1 "reg_or_8bit_operand" "rI"))
1894          (match_dup 0)))
1895    (clobber (match_scratch:DI 4 "=&r"))]
1896   ""
1897   "addq %0,%1,%4\;cmov%C2 %r3,%4,%0"
1898   [(set_attr "type" "cmov")])
1899
1900 (define_split
1901   [(set (match_operand:DI 0 "register_operand" "")
1902         (if_then_else:DI
1903          (match_operator 2 "signed_comparison_operator"
1904                          [(match_operand:DI 3 "reg_or_0_operand" "")
1905                           (const_int 0)])
1906          (plus:DI (match_dup 0)
1907                   (match_operand:DI 1 "reg_or_8bit_operand" ""))
1908          (match_dup 0)))
1909    (clobber (match_operand:DI 4 "register_operand" ""))]
1910   ""
1911   [(set (match_dup 4) (plus:DI (match_dup 0) (match_dup 1)))
1912    (set (match_dup 0) (if_then_else:DI (match_op_dup 2
1913                                                      [(match_dup 3)
1914                                                       (const_int 0)])
1915                                        (match_dup 4) (match_dup 0)))]
1916   "")
1917
1918 (define_split
1919   [(parallel
1920     [(set (match_operand:DI 0 "register_operand" "")
1921           (if_then_else:DI
1922            (match_operator 1 "comparison_operator"
1923                            [(zero_extract:DI (match_operand:DI 2 "register_operand" "")
1924                                              (const_int 1)
1925                                              (match_operand:DI 3 "const_int_operand" ""))
1926                             (const_int 0)])
1927            (match_operand:DI 4 "reg_or_8bit_operand" "")
1928            (match_operand:DI 5 "reg_or_8bit_operand" "")))
1929      (clobber (match_operand:DI 6 "register_operand" ""))])]
1930   "INTVAL (operands[3]) != 0"
1931   [(set (match_dup 6)
1932         (lshiftrt:DI (match_dup 2) (match_dup 3)))
1933    (set (match_dup 0)
1934         (if_then_else:DI (match_op_dup 1
1935                                        [(zero_extract:DI (match_dup 6)
1936                                                          (const_int 1)
1937                                                          (const_int 0))
1938                                         (const_int 0)])
1939                          (match_dup 4)
1940                          (match_dup 5)))]
1941   "")
1942
1943 ;; For ABS, we have two choices, depending on whether the input and output
1944 ;; registers are the same or not.
1945 (define_expand "absdi2"
1946   [(set (match_operand:DI 0 "register_operand" "")
1947         (abs:DI (match_operand:DI 1 "register_operand" "")))]
1948   ""
1949   "
1950 { if (rtx_equal_p (operands[0], operands[1]))
1951     emit_insn (gen_absdi2_same (operands[0], gen_reg_rtx (DImode)));
1952   else
1953     emit_insn (gen_absdi2_diff (operands[0], operands[1]));
1954
1955   DONE;
1956 }")
1957
1958 (define_expand "absdi2_same"
1959   [(set (match_operand:DI 1 "register_operand" "")
1960         (neg:DI (match_operand:DI 0 "register_operand" "")))
1961    (set (match_dup 0)
1962         (if_then_else:DI (ge (match_dup 0) (const_int 0))
1963                          (match_dup 0)
1964                          (match_dup 1)))]
1965   ""
1966   "")
1967
1968 (define_expand "absdi2_diff"
1969   [(set (match_operand:DI 0 "register_operand" "")
1970         (neg:DI (match_operand:DI 1 "register_operand" "")))
1971    (set (match_dup 0)
1972         (if_then_else:DI (lt (match_dup 1) (const_int 0))
1973                          (match_dup 0)
1974                          (match_dup 1)))]
1975   ""
1976   "")
1977
1978 (define_split
1979   [(set (match_operand:DI 0 "register_operand" "")
1980         (abs:DI (match_dup 0)))
1981    (clobber (match_operand:DI 2 "register_operand" ""))]
1982   ""
1983   [(set (match_dup 1) (neg:DI (match_dup 0)))
1984    (set (match_dup 0) (if_then_else:DI (ge (match_dup 0) (const_int 0))
1985                                        (match_dup 0) (match_dup 1)))]
1986   "")
1987
1988 (define_split
1989   [(set (match_operand:DI 0 "register_operand" "")
1990         (abs:DI (match_operand:DI 1 "register_operand" "")))]
1991   "! rtx_equal_p (operands[0], operands[1])"
1992   [(set (match_dup 0) (neg:DI (match_dup 1)))
1993    (set (match_dup 0) (if_then_else:DI (lt (match_dup 1) (const_int 0))
1994                                        (match_dup 0) (match_dup 1)))]
1995   "")
1996
1997 (define_split
1998   [(set (match_operand:DI 0 "register_operand" "")
1999         (neg:DI (abs:DI (match_dup 0))))
2000    (clobber (match_operand:DI 2 "register_operand" ""))]
2001   ""
2002   [(set (match_dup 1) (neg:DI (match_dup 0)))
2003    (set (match_dup 0) (if_then_else:DI (le (match_dup 0) (const_int 0))
2004                                        (match_dup 0) (match_dup 1)))]
2005   "")
2006
2007 (define_split
2008   [(set (match_operand:DI 0 "register_operand" "")
2009         (neg:DI (abs:DI (match_operand:DI 1 "register_operand" ""))))]
2010   "! rtx_equal_p (operands[0], operands[1])"
2011   [(set (match_dup 0) (neg:DI (match_dup 1)))
2012    (set (match_dup 0) (if_then_else:DI (gt (match_dup 1) (const_int 0))
2013                                        (match_dup 0) (match_dup 1)))]
2014   "")
2015
2016 (define_expand "smaxdi3"
2017   [(set (match_dup 3)
2018         (le:DI (match_operand:DI 1 "reg_or_0_operand" "")
2019                (match_operand:DI 2 "reg_or_8bit_operand" "")))
2020    (set (match_operand:DI 0 "register_operand" "")
2021         (if_then_else:DI (eq (match_dup 3) (const_int 0))
2022                          (match_dup 1) (match_dup 2)))]
2023   ""
2024   "
2025 { operands[3] = gen_reg_rtx (DImode);
2026 }")
2027
2028 (define_split
2029   [(set (match_operand:DI 0 "register_operand" "")
2030         (smax:DI (match_operand:DI 1 "reg_or_0_operand" "")
2031                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2032    (clobber (match_operand:DI 3 "register_operand" ""))]
2033   "operands[2] != const0_rtx"
2034   [(set (match_dup 3) (le:DI (match_dup 1) (match_dup 2)))
2035    (set (match_dup 0) (if_then_else:DI (eq (match_dup 3) (const_int 0))
2036                                        (match_dup 1) (match_dup 2)))]
2037   "")
2038
2039 (define_insn ""
2040   [(set (match_operand:DI 0 "register_operand" "=r")
2041         (smax:DI (match_operand:DI 1 "register_operand" "0")
2042                  (const_int 0)))]
2043   ""
2044   "cmovlt %0,0,%0"
2045   [(set_attr "type" "cmov")])
2046
2047 (define_expand "smindi3"
2048   [(set (match_dup 3)
2049         (lt:DI (match_operand:DI 1 "reg_or_0_operand" "")
2050                (match_operand:DI 2 "reg_or_8bit_operand" "")))
2051    (set (match_operand:DI 0 "register_operand" "")
2052         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2053                          (match_dup 1) (match_dup 2)))]
2054   ""
2055   "
2056 { operands[3] = gen_reg_rtx (DImode);
2057 }")
2058
2059 (define_split
2060   [(set (match_operand:DI 0 "register_operand" "")
2061         (smin:DI (match_operand:DI 1 "reg_or_0_operand" "")
2062                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2063    (clobber (match_operand:DI 3 "register_operand" ""))]
2064   "operands[2] != const0_rtx"
2065   [(set (match_dup 3) (lt:DI (match_dup 1) (match_dup 2)))
2066    (set (match_dup 0) (if_then_else:DI (ne (match_dup 3) (const_int 0))
2067                                        (match_dup 1) (match_dup 2)))]
2068   "")
2069
2070 (define_insn ""
2071   [(set (match_operand:DI 0 "register_operand" "=r")
2072         (smin:DI (match_operand:DI 1 "register_operand" "0")
2073                  (const_int 0)))]
2074   ""
2075   "cmovgt %0,0,%0"
2076   [(set_attr "type" "cmov")])
2077
2078 (define_expand "umaxdi3"
2079   [(set (match_dup 3)
2080         (leu:DI (match_operand:DI 1 "reg_or_0_operand" "")
2081                 (match_operand:DI 2 "reg_or_8bit_operand" "")))
2082    (set (match_operand:DI 0 "register_operand" "")
2083         (if_then_else:DI (eq (match_dup 3) (const_int 0))
2084                          (match_dup 1) (match_dup 2)))]
2085   ""
2086   "
2087 { operands[3] = gen_reg_rtx (DImode);
2088 }")
2089
2090 (define_split
2091   [(set (match_operand:DI 0 "register_operand" "")
2092         (umax:DI (match_operand:DI 1 "reg_or_0_operand" "")
2093                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2094    (clobber (match_operand:DI 3 "register_operand" ""))]
2095   "operands[2] != const0_rtx"
2096   [(set (match_dup 3) (leu:DI (match_dup 1) (match_dup 2)))
2097    (set (match_dup 0) (if_then_else:DI (eq (match_dup 3) (const_int 0))
2098                                        (match_dup 1) (match_dup 2)))]
2099   "")
2100
2101 (define_expand "umindi3"
2102   [(set (match_dup 3)
2103         (ltu:DI (match_operand:DI 1 "reg_or_0_operand" "")
2104                 (match_operand:DI 2 "reg_or_8bit_operand" "")))
2105    (set (match_operand:DI 0 "register_operand" "")
2106         (if_then_else:DI (ne (match_dup 3) (const_int 0))
2107                          (match_dup 1) (match_dup 2)))]
2108   ""
2109   "
2110 { operands[3] = gen_reg_rtx (DImode);
2111 }")
2112
2113 (define_split
2114   [(set (match_operand:DI 0 "register_operand" "")
2115         (umin:DI (match_operand:DI 1 "reg_or_0_operand" "")
2116                  (match_operand:DI 2 "reg_or_8bit_operand" "")))
2117    (clobber (match_operand:DI 3 "register_operand" ""))]
2118   "operands[2] != const0_rtx"
2119   [(set (match_dup 3) (ltu:DI (match_dup 1) (match_dup 2)))
2120    (set (match_dup 0) (if_then_else:DI (ne (match_dup 3) (const_int 0))
2121                                        (match_dup 1) (match_dup 2)))]
2122   "")
2123
2124 (define_insn ""
2125   [(set (pc)
2126         (if_then_else
2127          (match_operator 1 "signed_comparison_operator"
2128                          [(match_operand:DI 2 "reg_or_0_operand" "rJ")
2129                           (const_int 0)])
2130          (label_ref (match_operand 0 "" ""))
2131          (pc)))]
2132   ""
2133   "b%C1 %r2,%0"
2134   [(set_attr "type" "ibr")])
2135
2136 (define_insn ""
2137   [(set (pc)
2138         (if_then_else
2139          (match_operator 1 "signed_comparison_operator"
2140                          [(const_int 0)
2141                           (match_operand:DI 2 "register_operand" "r")])
2142          (label_ref (match_operand 0 "" ""))
2143          (pc)))]
2144   ""
2145   "b%c1 %2,%0"
2146   [(set_attr "type" "ibr")])
2147
2148 (define_insn ""
2149   [(set (pc)
2150         (if_then_else
2151          (ne (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
2152                               (const_int 1)
2153                               (const_int 0))
2154              (const_int 0))
2155          (label_ref (match_operand 0 "" ""))
2156          (pc)))]
2157   ""
2158   "blbs %r1,%0"
2159   [(set_attr "type" "ibr")])
2160
2161 (define_insn ""
2162   [(set (pc)
2163         (if_then_else
2164          (eq (zero_extract:DI (match_operand:DI 1 "reg_or_0_operand" "rJ")
2165                               (const_int 1)
2166                               (const_int 0))
2167              (const_int 0))
2168          (label_ref (match_operand 0 "" ""))
2169          (pc)))]
2170   ""
2171   "blbc %r1,%0"
2172   [(set_attr "type" "ibr")])
2173
2174 (define_split
2175   [(parallel
2176     [(set (pc)
2177           (if_then_else
2178            (match_operator 1 "comparison_operator"
2179                            [(zero_extract:DI (match_operand:DI 2 "register_operand" "")
2180                                              (const_int 1)
2181                                              (match_operand:DI 3 "const_int_operand" ""))
2182                             (const_int 0)])
2183            (label_ref (match_operand 0 "" ""))
2184            (pc)))
2185      (clobber (match_operand:DI 4 "register_operand" ""))])]
2186   "INTVAL (operands[3]) != 0"
2187   [(set (match_dup 4)
2188         (lshiftrt:DI (match_dup 2) (match_dup 3)))
2189    (set (pc)
2190         (if_then_else (match_op_dup 1
2191                                     [(zero_extract:DI (match_dup 4)
2192                                                       (const_int 1)
2193                                                       (const_int 0))
2194                                      (const_int 0)])
2195                       (label_ref (match_dup 0))
2196                       (pc)))]
2197   "")
2198 \f
2199 ;; The following are the corresponding floating-point insns.  Recall
2200 ;; we need to have variants that expand the arguments from SF mode
2201 ;; to DFmode.
2202
2203 (define_insn ""
2204   [(set (match_operand:DF 0 "register_operand" "=&f")
2205         (match_operator:DF 1 "alpha_comparison_operator"
2206                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2207                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2208   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2209   "cmp%-%C1%' %R2,%R3,%0"
2210   [(set_attr "type" "fadd")
2211    (set_attr "trap" "yes")])
2212
2213 (define_insn ""
2214   [(set (match_operand:DF 0 "register_operand" "=f")
2215         (match_operator:DF 1 "alpha_comparison_operator"
2216                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2217                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2218   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2219   "cmp%-%C1%' %R2,%R3,%0"
2220   [(set_attr "type" "fadd")
2221    (set_attr "trap" "yes")])
2222
2223 (define_insn ""
2224   [(set (match_operand:DF 0 "register_operand" "=f")
2225         (match_operator:DF 1 "alpha_comparison_operator"
2226                            [(float_extend:DF
2227                              (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2228                             (match_operand:DF 3 "reg_or_fp0_operand" "fG")]))]
2229   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2230   "cmp%-%C1%' %R2,%R3,%0"
2231   [(set_attr "type" "fadd")
2232    (set_attr "trap" "yes")])
2233
2234 (define_insn ""
2235   [(set (match_operand:DF 0 "register_operand" "=f")
2236         (match_operator:DF 1 "alpha_comparison_operator"
2237                            [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2238                             (float_extend:DF
2239                              (match_operand:SF 3 "reg_or_fp0_operand" "fG"))]))]
2240   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2241   "cmp%-%C1%' %R2,%R3,%0"
2242   [(set_attr "type" "fadd")
2243    (set_attr "trap" "yes")])
2244
2245 (define_insn ""
2246   [(set (match_operand:DF 0 "register_operand" "=f")
2247         (match_operator:DF 1 "alpha_comparison_operator"
2248                            [(float_extend:DF
2249                              (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2250                             (float_extend:DF
2251                              (match_operand:SF 3 "reg_or_fp0_operand" "fG"))]))]
2252   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2253   "cmp%-%C1%' %R2,%R3,%0"
2254   [(set_attr "type" "fadd")
2255    (set_attr "trap" "yes")])
2256
2257 (define_insn ""
2258   [(set (match_operand:DF 0 "register_operand" "=&f,f")
2259         (if_then_else:DF
2260          (match_operator 3 "signed_comparison_operator"
2261                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2262                           (match_operand:DF 2 "fp0_operand" "G,G")])
2263          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2264          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2265   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2266   "@
2267    fcmov%C3 %R4,%R1,%0
2268    fcmov%D3 %R4,%R5,%0"
2269   [(set_attr "type" "fadd")])
2270
2271 (define_insn ""
2272   [(set (match_operand:DF 0 "register_operand" "=f,f")
2273         (if_then_else:DF
2274          (match_operator 3 "signed_comparison_operator"
2275                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2276                           (match_operand:DF 2 "fp0_operand" "G,G")])
2277          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2278          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2279   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2280   "@
2281    fcmov%C3 %R4,%R1,%0
2282    fcmov%D3 %R4,%R5,%0"
2283   [(set_attr "type" "fadd")])
2284
2285 (define_insn ""
2286   [(set (match_operand:SF 0 "register_operand" "=&f,f")
2287         (if_then_else:SF
2288          (match_operator 3 "signed_comparison_operator"
2289                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2290                           (match_operand:DF 2 "fp0_operand" "G,G")])
2291          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2292          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2293   "TARGET_FP && alpha_tp == ALPHA_TP_INSN"
2294   "@
2295    fcmov%C3 %R4,%R1,%0
2296    fcmov%D3 %R4,%R5,%0"
2297   [(set_attr "type" "fadd")])
2298
2299 (define_insn ""
2300   [(set (match_operand:SF 0 "register_operand" "=f,f")
2301         (if_then_else:SF
2302          (match_operator 3 "signed_comparison_operator"
2303                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2304                           (match_operand:DF 2 "fp0_operand" "G,G")])
2305          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2306          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2307   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2308   "@
2309    fcmov%C3 %R4,%R1,%0
2310    fcmov%D3 %R4,%R5,%0"
2311   [(set_attr "type" "fadd")])
2312
2313 (define_insn ""
2314   [(set (match_operand:DF 0 "register_operand" "=f,f")
2315         (if_then_else:DF
2316          (match_operator 3 "signed_comparison_operator"
2317                          [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
2318                           (match_operand:DF 2 "fp0_operand" "G,G")])
2319          (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG,0"))
2320          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2321   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2322   "@
2323    fcmov%C3 %R4,%R1,%0
2324    fcmov%D3 %R4,%R5,%0"
2325   [(set_attr "type" "fadd")])
2326
2327 (define_insn ""
2328   [(set (match_operand:DF 0 "register_operand" "=f,f")
2329         (if_then_else:DF
2330          (match_operator 3 "signed_comparison_operator"
2331                          [(float_extend:DF
2332                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2333                           (match_operand:DF 2 "fp0_operand" "G,G")])
2334          (match_operand:DF 1 "reg_or_fp0_operand" "fG,0")
2335          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2336   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2337   "@
2338    fcmov%C3 %R4,%R1,%0
2339    fcmov%D3 %R4,%R5,%0"
2340   [(set_attr "type" "fadd")])
2341
2342 (define_insn ""
2343   [(set (match_operand:SF 0 "register_operand" "=f,f")
2344         (if_then_else:SF
2345          (match_operator 3 "signed_comparison_operator"
2346                          [(float_extend:DF
2347                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2348                           (match_operand:DF 2 "fp0_operand" "G,G")])
2349          (match_operand:SF 1 "reg_or_fp0_operand" "fG,0")
2350          (match_operand:SF 5 "reg_or_fp0_operand" "0,fG")))]
2351   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2352   "@
2353    fcmov%C3 %R4,%R1,%0
2354    fcmov%D3 %R4,%R5,%0"
2355   [(set_attr "type" "fadd")])
2356
2357 (define_insn ""
2358   [(set (match_operand:DF 0 "register_operand" "=f,f")
2359         (if_then_else:DF
2360          (match_operator 3 "signed_comparison_operator"
2361                          [(float_extend:DF
2362                            (match_operand:SF 4 "reg_or_fp0_operand" "fG,fG"))
2363                           (match_operand:DF 2 "fp0_operand" "G,G")])
2364          (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG,0"))
2365          (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
2366   "TARGET_FP && alpha_tp != ALPHA_TP_INSN"
2367   "@
2368    fcmov%C3 %R4,%R1,%0
2369    fcmov%D3 %R4,%R5,%0"
2370   [(set_attr "type" "fadd")])
2371
2372 (define_expand "maxdf3"
2373   [(set (match_dup 3)
2374         (le:DF (match_operand:DF 1 "reg_or_fp0_operand" "")
2375                (match_operand:DF 2 "reg_or_fp0_operand" "")))
2376    (set (match_operand:DF 0 "register_operand" "")
2377         (if_then_else:DF (eq (match_dup 3) (match_dup 4))
2378                          (match_dup 1) (match_dup 2)))]
2379   "TARGET_FP"
2380   "
2381 { operands[3] = gen_reg_rtx (DFmode);
2382   operands[4] = CONST0_RTX (DFmode);
2383 }")
2384
2385 (define_expand "mindf3"
2386   [(set (match_dup 3)
2387         (lt:DF (match_operand:DF 1 "reg_or_fp0_operand" "")
2388                (match_operand:DF 2 "reg_or_fp0_operand" "")))
2389    (set (match_operand:DF 0 "register_operand" "")
2390         (if_then_else:DF (ne (match_dup 3) (match_dup 4))
2391                          (match_dup 1) (match_dup 2)))]
2392   "TARGET_FP"
2393   "
2394 { operands[3] = gen_reg_rtx (DFmode);
2395   operands[4] = CONST0_RTX (DFmode);
2396 }")
2397
2398 (define_expand "maxsf3"
2399   [(set (match_dup 3)
2400         (le:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" ""))
2401                (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" ""))))
2402    (set (match_operand:SF 0 "register_operand" "")
2403         (if_then_else:SF (eq (match_dup 3) (match_dup 4))
2404                          (match_dup 1) (match_dup 2)))]
2405   "TARGET_FP"
2406   "
2407 { operands[3] = gen_reg_rtx (DFmode);
2408   operands[4] = CONST0_RTX (DFmode);
2409 }")
2410
2411 (define_expand "minsf3"
2412   [(set (match_dup 3)
2413         (lt:DF (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" ""))
2414                (float_extend:DF (match_operand:SF 2 "reg_or_fp0_operand" ""))))
2415    (set (match_operand:SF 0 "register_operand" "")
2416         (if_then_else:SF (ne (match_dup 3) (match_dup 4))
2417                       (match_dup 1) (match_dup 2)))]
2418   "TARGET_FP"
2419   "
2420 { operands[3] = gen_reg_rtx (DFmode);
2421   operands[4] = CONST0_RTX (DFmode);
2422 }")
2423
2424 (define_insn ""
2425   [(set (pc)
2426         (if_then_else
2427          (match_operator 1 "signed_comparison_operator"
2428                          [(match_operand:DF 2 "reg_or_fp0_operand" "fG")
2429                           (match_operand:DF 3 "fp0_operand" "G")])
2430          (label_ref (match_operand 0 "" ""))
2431          (pc)))]
2432   "TARGET_FP"
2433   "fb%C1 %R2,%0"
2434   [(set_attr "type" "fbr")])
2435
2436 (define_insn ""
2437   [(set (pc)
2438         (if_then_else
2439          (match_operator 1 "signed_comparison_operator"
2440                          [(float_extend:DF
2441                            (match_operand:SF 2 "reg_or_fp0_operand" "fG"))
2442                           (match_operand:DF 3 "fp0_operand" "G")])
2443          (label_ref (match_operand 0 "" ""))
2444          (pc)))]
2445   "TARGET_FP"
2446   "fb%C1 %R2,%0"
2447   [(set_attr "type" "fbr")])
2448 \f
2449 ;; These are the main define_expand's used to make conditional branches
2450 ;; and compares.
2451
2452 (define_expand "cmpdf"
2453   [(set (cc0) (compare (match_operand:DF 0 "reg_or_fp0_operand" "")
2454                        (match_operand:DF 1 "reg_or_fp0_operand" "")))]
2455   "TARGET_FP"
2456   "
2457 {
2458   alpha_compare_op0 = operands[0];
2459   alpha_compare_op1 = operands[1];
2460   alpha_compare_fp_p = 1;
2461   DONE;
2462 }")
2463
2464 (define_expand "cmpdi"
2465   [(set (cc0) (compare (match_operand:DI 0 "reg_or_0_operand" "")
2466                        (match_operand:DI 1 "reg_or_8bit_operand" "")))]
2467   ""
2468   "
2469 {
2470   alpha_compare_op0 = operands[0];
2471   alpha_compare_op1 = operands[1];
2472   alpha_compare_fp_p = 0;
2473   DONE;
2474 }")
2475
2476 (define_expand "beq"
2477   [(set (match_dup 1) (match_dup 2))
2478    (set (pc)
2479         (if_then_else (match_dup 3)
2480                       (label_ref (match_operand 0 "" ""))
2481                       (pc)))]
2482   ""
2483   "
2484 {
2485   enum machine_mode mode;
2486   enum rtx_code compare_code = EQ, branch_code = NE;
2487
2488   if (alpha_compare_fp_p)
2489     mode = DFmode;
2490   else
2491     {
2492       mode = DImode;
2493       /* We want to use cmpeq/bne when we can, since there is a zero-delay
2494          bypass between logicals and br/cmov on the 21164.  But we don't
2495          want to force valid immediate constants into registers needlessly.  */
2496       if (GET_CODE (alpha_compare_op1) == CONST_INT
2497           && ((INTVAL (alpha_compare_op1) >= -0x8000
2498                && INTVAL (alpha_compare_op1) < 0)
2499               || (INTVAL (alpha_compare_op1) > 0xff
2500                   && INTVAL (alpha_compare_op1) < 0x8000)))
2501         {
2502           compare_code = PLUS, branch_code = EQ;
2503           alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
2504         }
2505     }
2506
2507   operands[1] = gen_reg_rtx (mode);
2508   operands[2] = gen_rtx (compare_code, mode,
2509                          alpha_compare_op0, alpha_compare_op1);
2510   operands[3] = gen_rtx (branch_code, VOIDmode,
2511                          operands[1], CONST0_RTX (mode));
2512 }")
2513
2514 (define_expand "bne"
2515   [(set (match_dup 1) (match_dup 2))
2516    (set (pc)
2517         (if_then_else (match_dup 3)
2518                       (label_ref (match_operand 0 "" ""))
2519                       (pc)))]
2520   ""
2521   "
2522 {
2523   enum machine_mode mode;
2524   enum rtx_code compare_code = EQ, branch_code = EQ;
2525
2526   if (alpha_compare_fp_p)
2527     mode = DFmode;
2528   else
2529     {
2530       mode = DImode;
2531       /* We want to use cmpeq/bne when we can, since there is a zero-delay
2532          bypass between logicals and br/cmov on the 21164.  But we don't
2533          want to force valid immediate constants into registers needlessly.  */
2534       if (GET_CODE (alpha_compare_op1) == CONST_INT
2535           && ((INTVAL (alpha_compare_op1) >= -0x8000
2536                && INTVAL (alpha_compare_op1) < 0)
2537               || (INTVAL (alpha_compare_op1) > 0xff
2538                   && INTVAL (alpha_compare_op1) < 0x8000)))
2539         {
2540           compare_code = PLUS, branch_code = NE;
2541           alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
2542         }
2543     }
2544
2545   operands[1] = gen_reg_rtx (mode);
2546   operands[2] = gen_rtx (compare_code, mode,
2547                          alpha_compare_op0, alpha_compare_op1);
2548   operands[3] = gen_rtx (branch_code, VOIDmode,
2549                          operands[1], CONST0_RTX (mode));
2550 }")
2551
2552 (define_expand "blt"
2553   [(set (match_dup 1) (match_dup 2))
2554    (set (pc)
2555         (if_then_else (match_dup 3)
2556                       (label_ref (match_operand 0 "" ""))
2557                       (pc)))]
2558   ""
2559   "
2560 {
2561   enum machine_mode mode = alpha_compare_fp_p ? DFmode : DImode;
2562   operands[1] = gen_reg_rtx (mode);
2563   operands[2] = gen_rtx (LT, mode, alpha_compare_op0, alpha_compare_op1);
2564   operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (mode));
2565 }")
2566
2567 (define_expand "ble"
2568   [(set (match_dup 1) (match_dup 2))
2569    (set (pc)
2570         (if_then_else (match_dup 3)
2571                       (label_ref (match_operand 0 "" ""))
2572                       (pc)))]
2573   ""
2574   "
2575 {
2576   enum machine_mode mode = alpha_compare_fp_p ? DFmode : DImode;
2577   operands[1] = gen_reg_rtx (mode);
2578   operands[2] = gen_rtx (LE, mode, alpha_compare_op0, alpha_compare_op1);
2579   operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (mode));
2580 }")
2581
2582 (define_expand "bgt"
2583   [(set (match_dup 1) (match_dup 2))
2584    (set (pc)
2585         (if_then_else (match_dup 3)
2586                       (label_ref (match_operand 0 "" ""))
2587                       (pc)))]
2588   ""
2589   "
2590 {
2591   if (alpha_compare_fp_p)
2592     {
2593       operands[1] = gen_reg_rtx (DFmode);
2594       operands[2] = gen_rtx (LT, DFmode, alpha_compare_op1, alpha_compare_op0);
2595       operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (DFmode));
2596     }
2597   else
2598     {
2599       operands[1] = gen_reg_rtx (DImode);
2600       operands[2] = gen_rtx (LE, DImode, alpha_compare_op0, alpha_compare_op1);
2601       operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2602     }
2603 }")
2604
2605 (define_expand "bge"
2606   [(set (match_dup 1) (match_dup 2))
2607    (set (pc)
2608         (if_then_else (match_dup 3)
2609                       (label_ref (match_operand 0 "" ""))
2610                       (pc)))]
2611   ""
2612   "
2613 {
2614   if (alpha_compare_fp_p)
2615     {
2616       operands[1] = gen_reg_rtx (DFmode);
2617       operands[2] = gen_rtx (LE, DFmode, alpha_compare_op1, alpha_compare_op0);
2618       operands[3] = gen_rtx (NE, VOIDmode, operands[1], CONST0_RTX (DFmode));
2619     }
2620   else
2621     {
2622       operands[1] = gen_reg_rtx (DImode);
2623       operands[2] = gen_rtx (LT, DImode, alpha_compare_op0, alpha_compare_op1);
2624       operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2625     }
2626 }")
2627
2628 (define_expand "bltu"
2629   [(set (match_dup 1) (match_dup 2))
2630    (set (pc)
2631         (if_then_else (match_dup 3)
2632                       (label_ref (match_operand 0 "" ""))
2633                       (pc)))]
2634   ""
2635   "
2636 {
2637   operands[1] = gen_reg_rtx (DImode);
2638   operands[2] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2639   operands[3] = gen_rtx (NE, VOIDmode, operands[1], const0_rtx);
2640 }")
2641
2642 (define_expand "bleu"
2643   [(set (match_dup 1) (match_dup 2))
2644    (set (pc)
2645         (if_then_else (match_dup 3)
2646                       (label_ref (match_operand 0 "" ""))
2647                       (pc)))]
2648   ""
2649   "
2650 {
2651   operands[1] = gen_reg_rtx (DImode);
2652   operands[2] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2653   operands[3] = gen_rtx (NE, VOIDmode, operands[1], const0_rtx);
2654 }")
2655
2656 (define_expand "bgtu"
2657   [(set (match_dup 1) (match_dup 2))
2658    (set (pc)
2659         (if_then_else (match_dup 3)
2660                       (label_ref (match_operand 0 "" ""))
2661                       (pc)))]
2662   ""
2663   "
2664 {
2665   operands[1] = gen_reg_rtx (DImode);
2666   operands[2] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2667   operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2668 }")
2669
2670 (define_expand "bgeu"
2671   [(set (match_dup 1) (match_dup 2))
2672    (set (pc)
2673         (if_then_else (match_dup 3)
2674                       (label_ref (match_operand 0 "" ""))
2675                       (pc)))]
2676   ""
2677   "
2678 {
2679   operands[1] = gen_reg_rtx (DImode);
2680   operands[2] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2681   operands[3] = gen_rtx (EQ, VOIDmode, operands[1], const0_rtx);
2682 }")
2683
2684 (define_expand "seq"
2685   [(set (match_operand:DI 0 "register_operand" "")
2686         (match_dup 1))]
2687   ""
2688   "
2689 {
2690   if (alpha_compare_fp_p)
2691     FAIL;
2692
2693   operands[1] = gen_rtx (EQ, DImode, alpha_compare_op0, alpha_compare_op1);
2694 }")
2695
2696 (define_expand "sne"
2697   [(set (match_operand:DI 0 "register_operand" "")
2698         (match_dup 1))
2699    (set (match_dup 0) (xor:DI (match_dup 0) (const_int 1)))]
2700   ""
2701   "
2702 {
2703   if (alpha_compare_fp_p)
2704     FAIL;
2705
2706   operands[1] = gen_rtx (EQ, DImode, alpha_compare_op0, alpha_compare_op1);
2707 }")
2708
2709 (define_expand "slt"
2710   [(set (match_operand:DI 0 "register_operand" "")
2711         (match_dup 1))]
2712   ""
2713   "
2714 {
2715   if (alpha_compare_fp_p)
2716     FAIL;
2717
2718   operands[1] = gen_rtx (LT, DImode, alpha_compare_op0, alpha_compare_op1);
2719 }")
2720
2721 (define_expand "sle"
2722   [(set (match_operand:DI 0 "register_operand" "")
2723         (match_dup 1))]
2724   ""
2725   "
2726 {
2727   if (alpha_compare_fp_p)
2728     FAIL;
2729
2730   operands[1] = gen_rtx (LE, DImode, alpha_compare_op0, alpha_compare_op1);
2731 }")
2732
2733 (define_expand "sgt"
2734   [(set (match_operand:DI 0 "register_operand" "")
2735         (match_dup 1))]
2736   ""
2737   "
2738 {
2739   if (alpha_compare_fp_p)
2740     FAIL;
2741
2742   operands[1] = gen_rtx (LT, DImode, force_reg (DImode, alpha_compare_op1),
2743                          alpha_compare_op0);
2744 }")
2745
2746 (define_expand "sge"
2747   [(set (match_operand:DI 0 "register_operand" "")
2748         (match_dup 1))]
2749   ""
2750   "
2751 {
2752   if (alpha_compare_fp_p)
2753     FAIL;
2754
2755   operands[1] = gen_rtx (LE, DImode, force_reg (DImode, alpha_compare_op1),
2756                          alpha_compare_op0);
2757 }")
2758
2759 (define_expand "sltu"
2760   [(set (match_operand:DI 0 "register_operand" "")
2761         (match_dup 1))]
2762   ""
2763   "
2764 {
2765   if (alpha_compare_fp_p)
2766     FAIL;
2767
2768   operands[1] = gen_rtx (LTU, DImode, alpha_compare_op0, alpha_compare_op1);
2769 }")
2770
2771 (define_expand "sleu"
2772   [(set (match_operand:DI 0 "register_operand" "")
2773         (match_dup 1))]
2774   ""
2775   "
2776 {
2777   if (alpha_compare_fp_p)
2778     FAIL;
2779
2780   operands[1] = gen_rtx (LEU, DImode, alpha_compare_op0, alpha_compare_op1);
2781 }")
2782
2783 (define_expand "sgtu"
2784   [(set (match_operand:DI 0 "register_operand" "")
2785         (match_dup 1))]
2786   ""
2787   "
2788 {
2789   if (alpha_compare_fp_p)
2790     FAIL;
2791
2792   operands[1] = gen_rtx (LTU, DImode, force_reg (DImode, alpha_compare_op1),
2793                          alpha_compare_op0);
2794 }")
2795
2796 (define_expand "sgeu"
2797   [(set (match_operand:DI 0 "register_operand" "")
2798         (match_dup 1))]
2799   ""
2800   "
2801 {
2802   if (alpha_compare_fp_p)
2803     FAIL;
2804
2805   operands[1] = gen_rtx (LEU, DImode, force_reg (DImode, alpha_compare_op1),
2806                          alpha_compare_op0);
2807 }")
2808 \f
2809 ;; These are the main define_expand's used to make conditional moves.
2810
2811 (define_expand "movsicc"
2812   [(set (match_operand:SI 0 "register_operand" "")
2813         (if_then_else:DI (match_operand 1 "comparison_operator" "")
2814                          (match_operand:SI 2 "reg_or_8bit_operand" "")
2815                          (match_operand:SI 3 "reg_or_8bit_operand" "")))]
2816   ""
2817   "
2818 {
2819   if ((operands[1] = alpha_emit_conditional_move (operands[1], SImode)) == 0)
2820     FAIL;
2821 }")
2822
2823 (define_expand "movdicc"
2824   [(set (match_operand:DI 0 "register_operand" "")
2825         (if_then_else:DI (match_operand 1 "comparison_operator" "")
2826                          (match_operand:DI 2 "reg_or_8bit_operand" "")
2827                          (match_operand:DI 3 "reg_or_8bit_operand" "")))]
2828   ""
2829   "
2830 {
2831   if ((operands[1] = alpha_emit_conditional_move (operands[1], DImode)) == 0)
2832     FAIL;
2833 }")
2834
2835 (define_expand "movsfcc"
2836   [(set (match_operand:SF 0 "register_operand" "")
2837         (if_then_else:SF (match_operand 1 "comparison_operator" "")
2838                          (match_operand:SF 2 "reg_or_8bit_operand" "")
2839                          (match_operand:SF 3 "reg_or_8bit_operand" "")))]
2840   ""
2841   "
2842 {
2843   if ((operands[1] = alpha_emit_conditional_move (operands[1], SFmode)) == 0)
2844     FAIL;
2845 }")
2846
2847 (define_expand "movdfcc"
2848   [(set (match_operand:DF 0 "register_operand" "")
2849         (if_then_else:DF (match_operand 1 "comparison_operator" "")
2850                          (match_operand:DF 2 "reg_or_8bit_operand" "")
2851                          (match_operand:DF 3 "reg_or_8bit_operand" "")))]
2852   ""
2853   "
2854 {
2855   if ((operands[1] = alpha_emit_conditional_move (operands[1], DFmode)) == 0)
2856     FAIL;
2857 }")
2858 \f
2859 ;; These define_split definitions are used in cases when comparisons have
2860 ;; not be stated in the correct way and we need to reverse the second
2861 ;; comparison.  For example, x >= 7 has to be done as x < 6 with the
2862 ;; comparison that tests the result being reversed.  We have one define_split
2863 ;; for each use of a comparison.  They do not match valid insns and need
2864 ;; not generate valid insns.
2865 ;;
2866 ;; We can also handle equality comparisons (and inequality comparisons in
2867 ;; cases where the resulting add cannot overflow) by doing an add followed by
2868 ;; a comparison with zero.  This is faster since the addition takes one
2869 ;; less cycle than a compare when feeding into a conditional move.
2870 ;; For this case, we also have an SImode pattern since we can merge the add
2871 ;; and sign extend and the order doesn't matter.
2872 ;;
2873 ;; We do not do this for floating-point, since it isn't clear how the "wrong"
2874 ;; operation could have been generated.
2875
2876 (define_split
2877   [(set (match_operand:DI 0 "register_operand" "")
2878         (if_then_else:DI
2879          (match_operator 1 "comparison_operator"
2880                          [(match_operand:DI 2 "reg_or_0_operand" "")
2881                           (match_operand:DI 3 "reg_or_cint_operand" "")])
2882          (match_operand:DI 4 "reg_or_cint_operand" "")
2883          (match_operand:DI 5 "reg_or_cint_operand" "")))
2884    (clobber (match_operand:DI 6 "register_operand" ""))]
2885   "operands[3] != const0_rtx"
2886   [(set (match_dup 6) (match_dup 7))
2887    (set (match_dup 0)
2888         (if_then_else:DI (match_dup 8) (match_dup 4) (match_dup 5)))]
2889   "
2890 { enum rtx_code code = GET_CODE (operands[1]);
2891   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2892
2893   /* If we are comparing for equality with a constant and that constant
2894      appears in the arm when the register equals the constant, use the
2895      register since that is more likely to match (and to produce better code
2896      if both would).  */
2897
2898   if (code == EQ && GET_CODE (operands[3]) == CONST_INT
2899       && rtx_equal_p (operands[4], operands[3]))
2900     operands[4] = operands[2];
2901
2902   else if (code == NE && GET_CODE (operands[3]) == CONST_INT
2903            && rtx_equal_p (operands[5], operands[3]))
2904     operands[5] = operands[2];
2905
2906   if (code == NE || code == EQ
2907       || (extended_count (operands[2], DImode, unsignedp) >= 1
2908           && extended_count (operands[3], DImode, unsignedp) >= 1))
2909     {
2910       if (GET_CODE (operands[3]) == CONST_INT)
2911         operands[7] = gen_rtx (PLUS, DImode, operands[2],
2912                                GEN_INT (- INTVAL (operands[3])));
2913       else
2914         operands[7] = gen_rtx (MINUS, DImode, operands[2], operands[3]);
2915
2916       operands[8] = gen_rtx (code, VOIDmode, operands[6], const0_rtx);
2917     }
2918
2919   else if (code == EQ || code == LE || code == LT
2920            || code == LEU || code == LTU)
2921     {
2922       operands[7] = gen_rtx (code, DImode, operands[2], operands[3]);
2923       operands[8] = gen_rtx (NE, VOIDmode, operands[6], const0_rtx);
2924     }
2925   else
2926     {
2927       operands[7] = gen_rtx (reverse_condition (code), DImode, operands[2],
2928                              operands[3]);
2929       operands[8] = gen_rtx (EQ, VOIDmode, operands[6], const0_rtx);
2930     }
2931 }")
2932
2933 (define_split
2934   [(set (match_operand:DI 0 "register_operand" "")
2935         (if_then_else:DI
2936          (match_operator 1 "comparison_operator"
2937                          [(match_operand:SI 2 "reg_or_0_operand" "")
2938                           (match_operand:SI 3 "reg_or_cint_operand" "")])
2939          (match_operand:DI 4 "reg_or_8bit_operand" "")
2940          (match_operand:DI 5 "reg_or_8bit_operand" "")))
2941    (clobber (match_operand:DI 6 "register_operand" ""))]
2942   "operands[3] != const0_rtx
2943    && (GET_CODE (operands[1]) == EQ || GET_CODE (operands[1]) == NE)"
2944   [(set (match_dup 6) (match_dup 7))
2945    (set (match_dup 0)
2946         (if_then_else:DI (match_dup 8) (match_dup 4) (match_dup 5)))]
2947   "
2948 { enum rtx_code code = GET_CODE (operands[1]);
2949   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2950   rtx tem;
2951
2952   if ((code != NE && code != EQ
2953        && ! (extended_count (operands[2], DImode, unsignedp) >= 1
2954              && extended_count (operands[3], DImode, unsignedp) >= 1)))
2955     FAIL;
2956
2957   if (GET_CODE (operands[3]) == CONST_INT)
2958     tem = gen_rtx (PLUS, SImode, operands[2],
2959                    GEN_INT (- INTVAL (operands[3])));
2960   else
2961     tem = gen_rtx (MINUS, SImode, operands[2], operands[3]);
2962
2963   operands[7] = gen_rtx (SIGN_EXTEND, DImode, tem);
2964   operands[8] = gen_rtx (GET_CODE (operands[1]), VOIDmode, operands[6],
2965                          const0_rtx);
2966 }")
2967
2968 (define_split
2969   [(set (pc)
2970         (if_then_else
2971          (match_operator 1 "comparison_operator"
2972                          [(match_operand:DI 2 "reg_or_0_operand" "")
2973                           (match_operand:DI 3 "reg_or_cint_operand" "")])
2974          (label_ref (match_operand 0 "" ""))
2975          (pc)))
2976    (clobber (match_operand:DI 4 "register_operand" ""))]
2977   "operands[3] != const0_rtx"
2978   [(set (match_dup 4) (match_dup 5))
2979    (set (pc) (if_then_else (match_dup 6) (label_ref (match_dup 0)) (pc)))]
2980   "
2981 { enum rtx_code code = GET_CODE (operands[1]);
2982   int unsignedp = (code == GEU || code == LEU || code == GTU || code == LTU);
2983
2984   if (code == NE || code == EQ
2985       || (extended_count (operands[2], DImode, unsignedp) >= 1
2986           && extended_count (operands[3], DImode, unsignedp) >= 1))
2987     {
2988       if (GET_CODE (operands[3]) == CONST_INT)
2989         operands[5] = gen_rtx (PLUS, DImode, operands[2],
2990                                GEN_INT (- INTVAL (operands[3])));
2991       else
2992         operands[5] = gen_rtx (MINUS, DImode, operands[2], operands[3]);
2993
2994       operands[6] = gen_rtx (code, VOIDmode, operands[4], const0_rtx);
2995     }
2996
2997   else if (code == EQ || code == LE || code == LT
2998            || code == LEU || code == LTU)
2999     {
3000       operands[5] = gen_rtx (code, DImode, operands[2], operands[3]);
3001       operands[6] = gen_rtx (NE, VOIDmode, operands[4], const0_rtx);
3002     }
3003   else
3004     {
3005       operands[5] = gen_rtx (reverse_condition (code), DImode, operands[2],
3006                              operands[3]);
3007       operands[6] = gen_rtx (EQ, VOIDmode, operands[4], const0_rtx);
3008     }
3009 }")
3010
3011 (define_split
3012   [(set (pc)
3013         (if_then_else
3014          (match_operator 1 "comparison_operator"
3015                          [(match_operand:SI 2 "reg_or_0_operand" "")
3016                           (match_operand:SI 3 "const_int_operand" "")])
3017          (label_ref (match_operand 0 "" ""))
3018          (pc)))
3019    (clobber (match_operand:DI 4 "register_operand" ""))]
3020   "operands[3] != const0_rtx
3021    && (GET_CODE (operands[1]) == EQ || GET_CODE (operands[1]) == NE)"
3022   [(set (match_dup 4) (match_dup 5))
3023    (set (pc) (if_then_else (match_dup 6) (label_ref (match_dup 0)) (pc)))]
3024   "
3025 { rtx tem;
3026
3027   if (GET_CODE (operands[3]) == CONST_INT)
3028     tem = gen_rtx (PLUS, SImode, operands[2],
3029                    GEN_INT (- INTVAL (operands[3])));
3030   else
3031     tem = gen_rtx (MINUS, SImode, operands[2], operands[3]);
3032
3033   operands[5] = gen_rtx (SIGN_EXTEND, DImode, tem);
3034   operands[6] = gen_rtx (GET_CODE (operands[1]), VOIDmode,
3035                          operands[4], const0_rtx);
3036 }")
3037
3038 ;; We can convert such things as "a > 0xffff" to "t = a & ~ 0xffff; t != 0".
3039 ;; This eliminates one, and sometimes two, insns when the AND can be done
3040 ;; with a ZAP.
3041 (define_split
3042   [(set (match_operand:DI 0 "register_operand" "")
3043         (match_operator 1 "comparison_operator"
3044                         [(match_operand:DI 2 "register_operand" "")
3045                          (match_operand:DI 3 "const_int_operand" "")]))
3046    (clobber (match_operand:DI 4 "register_operand" ""))]
3047   "exact_log2 (INTVAL (operands[3]) + 1) >= 0
3048    && (GET_CODE (operands[1]) == GTU
3049        || GET_CODE (operands[1]) == LEU
3050        || ((GET_CODE (operands[1]) == GT || GET_CODE (operands[1]) == LE)
3051            && extended_count (operands[2], DImode, 1) > 0))"
3052   [(set (match_dup 4) (and:DI (match_dup 2) (match_dup 5)))
3053    (set (match_dup 0) (match_dup 6))]
3054   "
3055 {
3056   operands[5] = GEN_INT (~ INTVAL (operands[3]));
3057   operands[6] = gen_rtx (((GET_CODE (operands[1]) == GTU
3058                            || GET_CODE (operands[1]) == GT)
3059                           ? NE : EQ),
3060                          DImode, operands[4], const0_rtx);
3061 }")
3062 \f
3063 ;; Here are the CALL and unconditional branch insns.  Calls on NT and OSF
3064 ;; work differently, so we have different patterns for each.
3065
3066 (define_expand "call"
3067   [(use (match_operand:DI 0 "" ""))
3068    (use (match_operand 1 "" ""))
3069    (use (match_operand 2 "" ""))
3070    (use (match_operand 3 "" ""))]
3071   ""
3072   "
3073 { if (TARGET_WINDOWS_NT)
3074     emit_call_insn (gen_call_nt (operands[0], operands[1]));
3075   else if (TARGET_OPEN_VMS)
3076     emit_call_insn (gen_call_vms (operands[0], operands[2]));
3077   else
3078     emit_call_insn (gen_call_osf (operands[0], operands[1]));
3079
3080   DONE;
3081 }")
3082
3083 (define_expand "call_osf"
3084   [(parallel [(call (mem:DI (match_operand 0 "" ""))
3085                     (match_operand 1 "" ""))
3086               (clobber (reg:DI 27))
3087               (clobber (reg:DI 26))])]
3088   ""
3089   "
3090 { if (GET_CODE (operands[0]) != MEM)
3091     abort ();
3092
3093   operands[0] = XEXP (operands[0], 0);
3094
3095   if (GET_CODE (operands[0]) != SYMBOL_REF
3096       && ! (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == 27))
3097     {
3098       rtx tem = gen_rtx (REG, DImode, 27);
3099       emit_move_insn (tem, operands[0]);
3100       operands[0] = tem;
3101     }
3102 }")
3103
3104 (define_expand "call_nt"
3105   [(parallel [(call (mem:DI (match_operand:DI 0 "" ""))
3106                     (match_operand 1 "" ""))
3107               (clobber (reg:DI 26))])]
3108   ""
3109   "
3110 { if (GET_CODE (operands[0]) != MEM)
3111     abort ();
3112   operands[0] = XEXP (operands[0], 0);
3113
3114   if (GET_CODE (operands[1]) != SYMBOL_REF
3115       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3116     {
3117       rtx tem = gen_rtx (REG, DImode, 27);
3118       emit_move_insn (tem, operands[1]);
3119       operands[1] = tem;
3120     }
3121 }")
3122
3123 ;;
3124 ;; call openvms/alpha
3125 ;; op 0: symbol ref for called function
3126 ;; op 1: next_arg_reg (argument information value for R25)
3127 ;;
3128 (define_expand "call_vms"
3129   [(parallel [(call (mem:DI (match_operand 0 "" ""))
3130                     (match_operand 1 "" ""))
3131               (use (match_dup 2))
3132               (use (reg:DI 25))
3133               (use (reg:DI 26))
3134               (clobber (reg:DI 27))])]
3135   ""
3136   "
3137 { if (GET_CODE (operands[0]) != MEM)
3138     abort ();
3139
3140   operands[0] = XEXP (operands[0], 0);
3141
3142   /* Always load AI with argument information, then handle symbolic and
3143      indirect call differently.  Load RA and set operands[2] to PV in
3144      both cases.  */
3145
3146   emit_move_insn (gen_rtx (REG, DImode, 25), operands[1]);
3147   if (GET_CODE (operands[0]) == SYMBOL_REF)
3148     {
3149       extern char *savealloc ();
3150       char *symbol = XSTR (operands[0], 0);
3151       char *linksym = savealloc (strlen (symbol) + 5);
3152       rtx linkage;
3153
3154       alpha_need_linkage (symbol, 0);
3155
3156       strcpy (linksym, symbol);
3157       strcat (linksym, \"..lk\");
3158       linkage = gen_rtx (SYMBOL_REF, Pmode, linksym);
3159
3160       emit_move_insn (gen_rtx (REG, Pmode, 26), gen_rtx (MEM, Pmode, linkage));
3161
3162       operands[2]
3163         = validize_mem (gen_rtx (MEM, Pmode, plus_constant (linkage, 8)));
3164     }
3165   else
3166     {
3167       emit_move_insn (gen_rtx (REG, Pmode, 26),
3168                       gen_rtx (MEM, Pmode, plus_constant (operands[0], 8)));
3169
3170       operands[2] = operands[0];
3171     }
3172
3173 }")
3174
3175 (define_expand "call_value"
3176   [(use (match_operand 0 "" ""))
3177    (use (match_operand:DI 1 "" ""))
3178    (use (match_operand 2 "" ""))
3179    (use (match_operand 3 "" ""))
3180    (use (match_operand 4 "" ""))]
3181   ""
3182   "
3183 { if (TARGET_WINDOWS_NT)
3184     emit_call_insn (gen_call_value_nt (operands[0], operands[1], operands[2]));
3185   else if (TARGET_OPEN_VMS)
3186     emit_call_insn (gen_call_value_vms (operands[0], operands[1],
3187                                         operands[3]));
3188   else
3189     emit_call_insn (gen_call_value_osf (operands[0], operands[1],
3190                                         operands[2]));
3191   DONE;
3192 }")
3193
3194 (define_expand "call_value_osf"
3195   [(parallel [(set (match_operand 0 "" "")
3196                    (call (mem:DI (match_operand 1 "" ""))
3197                          (match_operand 2 "" "")))
3198               (clobber (reg:DI 27))
3199               (clobber (reg:DI 26))])]
3200   ""
3201   "
3202 { if (GET_CODE (operands[1]) != MEM)
3203     abort ();
3204
3205   operands[1] = XEXP (operands[1], 0);
3206
3207   if (GET_CODE (operands[1]) != SYMBOL_REF
3208       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3209     {
3210       rtx tem = gen_rtx (REG, DImode, 27);
3211       emit_move_insn (tem, operands[1]);
3212       operands[1] = tem;
3213     }
3214 }")
3215
3216 (define_expand "call_value_nt"
3217   [(parallel [(set (match_operand 0 "" "")
3218                    (call (mem:DI (match_operand:DI 1 "" ""))
3219                          (match_operand 2 "" "")))
3220               (clobber (reg:DI 26))])]
3221   ""
3222   "
3223 { if (GET_CODE (operands[1]) != MEM)
3224     abort ();
3225
3226   operands[1] = XEXP (operands[1], 0);
3227   if (GET_CODE (operands[1]) != SYMBOL_REF
3228       && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27))
3229     {
3230       rtx tem = gen_rtx (REG, DImode, 27);
3231       emit_move_insn (tem, operands[1]);
3232       operands[1] = tem;
3233     }
3234 }")
3235
3236 (define_expand "call_value_vms"
3237   [(parallel [(set (match_operand 0 "" "")
3238                    (call (mem:DI (match_operand:DI 1 "" ""))
3239                          (match_operand 2 "" "")))
3240               (use (match_dup 3))
3241               (use (reg:DI 25))
3242               (use (reg:DI 26))
3243               (clobber (reg:DI 27))])]
3244   ""
3245   "
3246 { if (GET_CODE (operands[1]) != MEM)
3247     abort ();
3248
3249   operands[1] = XEXP (operands[1], 0);
3250
3251   /* Always load AI with argument information, then handle symbolic and
3252      indirect call differently.  Load RA and set operands[3] to PV in
3253      both cases.  */
3254
3255   emit_move_insn (gen_rtx (REG, DImode, 25), operands[2]);
3256   if (GET_CODE (operands[1]) == SYMBOL_REF)
3257     {
3258       extern char *savealloc ();
3259       char *symbol = XSTR (operands[1], 0);
3260       char *linksym = savealloc (strlen (symbol) + 5);
3261       rtx linkage;
3262
3263       alpha_need_linkage (symbol, 0);
3264       strcpy (linksym, symbol);
3265       strcat (linksym, \"..lk\");
3266       linkage = gen_rtx (SYMBOL_REF, Pmode, linksym);
3267
3268       emit_move_insn (gen_rtx (REG, Pmode, 26), gen_rtx (MEM, Pmode, linkage));
3269
3270       operands[3]
3271         = validize_mem (gen_rtx (MEM, Pmode, plus_constant (linkage, 8)));
3272     }
3273   else
3274     {
3275       emit_move_insn (gen_rtx (REG, Pmode, 26),
3276                       gen_rtx (MEM, Pmode, plus_constant (operands[1], 8)));
3277
3278       operands[3] = operands[1];
3279     }
3280 }")
3281
3282 (define_insn ""
3283   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,R,i"))
3284          (match_operand 1 "" ""))
3285    (clobber (reg:DI 27))
3286    (clobber (reg:DI 26))]
3287   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS"
3288   "@
3289    jsr $26,($27),0\;ldgp $29,0($26)
3290    bsr $26,%0..ng
3291    jsr $26,%0\;ldgp $29,0($26)"
3292   [(set_attr "type" "jsr,jsr,ibr")])
3293
3294 (define_insn ""
3295   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,i"))
3296          (match_operand 1 "" ""))
3297    (clobber (reg:DI 26))]
3298   "TARGET_WINDOWS_NT"
3299   "@
3300    jsr $26,(%0)
3301    bsr $26,%0"
3302   [(set_attr "type" "jsr")])
3303
3304 (define_insn ""
3305   [(call (mem:DI (match_operand:DI 0 "call_operand" "r,i"))
3306          (match_operand 1 "" ""))
3307    (use (match_operand:DI 2 "general_operand" "r,m"))
3308    (use (reg:DI 25))
3309    (use (reg:DI 26))
3310    (clobber (reg:DI 27))]
3311   "TARGET_OPEN_VMS"
3312   "@
3313    bis %2,%2,$27\;jsr $26,0\;ldq $27,0($29)
3314    ldq $27,%2\;jsr $26,%0\;ldq $27,0($29)"
3315   [(set_attr "type" "jsr")])
3316
3317 (define_insn ""
3318   [(set (match_operand 0 "register_operand" "=rf,rf,rf")
3319         (call (mem:DI (match_operand:DI 1 "call_operand" "r,R,i"))
3320               (match_operand 2 "" "")))
3321    (clobber (reg:DI 27))
3322    (clobber (reg:DI 26))]
3323   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS"
3324   "@
3325    jsr $26,($27),0\;ldgp $29,0($26)
3326    bsr $26,%1..ng
3327    jsr $26,%1\;ldgp $29,0($26)"
3328   [(set_attr "type" "jsr,jsr,ibr")])
3329
3330 (define_insn ""
3331   [(set (match_operand 0 "register_operand" "=rf,rf")
3332         (call (mem:DI (match_operand:DI 1 "call_operand" "r,i"))
3333               (match_operand 2 "" "")))
3334    (clobber (reg:DI 26))]
3335   "TARGET_WINDOWS_NT"
3336   "@
3337    jsr $26,(%1)
3338    bsr $26,%1"
3339   [(set_attr "type" "jsr")])
3340
3341 (define_insn ""
3342   [(set (match_operand 0 "register_operand" "")
3343         (call (mem:DI (match_operand:DI 1 "call_operand" "r,i"))
3344               (match_operand 2 "" "")))
3345    (use (match_operand:DI 3 "general_operand" "r,m"))
3346    (use (reg:DI 25))
3347    (use (reg:DI 26))
3348    (clobber (reg:DI 27))]
3349   "TARGET_OPEN_VMS"
3350   "@
3351    bis %3,%3,$27\;jsr $26,0\;ldq $27,0($29)
3352    ldq $27,%3\;jsr $26,%1\;ldq $27,0($29)"
3353   [(set_attr "type" "jsr")])
3354
3355 ;; Call subroutine returning any type.
3356
3357 (define_expand "untyped_call"
3358   [(parallel [(call (match_operand 0 "" "")
3359                     (const_int 0))
3360               (match_operand 1 "" "")
3361               (match_operand 2 "" "")])]
3362   ""
3363   "
3364 {
3365   int i;
3366
3367   emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx));
3368
3369   for (i = 0; i < XVECLEN (operands[2], 0); i++)
3370     {
3371       rtx set = XVECEXP (operands[2], 0, i);
3372       emit_move_insn (SET_DEST (set), SET_SRC (set));
3373     }
3374
3375   /* The optimizer does not know that the call sets the function value
3376      registers we stored in the result block.  We avoid problems by
3377      claiming that all hard registers are used and clobbered at this
3378      point.  */
3379   emit_insn (gen_blockage ());
3380
3381   DONE;
3382 }")
3383
3384 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
3385 ;; all of memory.  This blocks insns from being moved across this point.
3386
3387 (define_insn "blockage"
3388   [(unspec_volatile [(const_int 0)] 1)]
3389   ""
3390   "")
3391
3392 (define_insn "jump"
3393   [(set (pc)
3394         (label_ref (match_operand 0 "" "")))]
3395   ""
3396   "br $31,%l0"
3397   [(set_attr "type" "ibr")])
3398
3399 (define_insn "return"
3400   [(return)]
3401   "direct_return ()"
3402   "ret $31,($26),1"
3403   [(set_attr "type" "ibr")])
3404
3405 (define_insn "indirect_jump"
3406   [(set (pc) (match_operand:DI 0 "register_operand" "r"))]
3407   ""
3408   "jmp $31,(%0),0"
3409   [(set_attr "type" "ibr")])
3410
3411 (define_insn "nop"
3412   [(const_int 0)]
3413   ""
3414   "bis $31,$31,$31"
3415   [(set_attr "type" "ilog")])
3416
3417 (define_expand "tablejump"
3418   [(use (match_operand:SI 0 "register_operand" ""))
3419    (use (match_operand:SI 1 "" ""))]
3420   ""
3421   "
3422 {
3423   if (TARGET_WINDOWS_NT)
3424     emit_jump_insn (gen_tablejump_nt (operands[0], operands[1]));
3425   else if (TARGET_OPEN_VMS)
3426     emit_jump_insn (gen_tablejump_vms (operands[0], operands[1]));
3427   else
3428     emit_jump_insn (gen_tablejump_osf (operands[0], operands[1]));
3429
3430   DONE;
3431 }")
3432
3433 (define_expand "tablejump_osf"
3434   [(set (match_dup 3)
3435         (sign_extend:DI (match_operand:SI 0 "register_operand" "")))
3436    (parallel [(set (pc)
3437                    (plus:DI (match_dup 3)
3438                             (label_ref:DI (match_operand 1 "" ""))))
3439               (clobber (match_scratch:DI 2 "=r"))])]
3440   ""
3441   "
3442 { operands[3] = gen_reg_rtx (DImode); }")
3443
3444 (define_expand "tablejump_nt"
3445   [(set (match_dup 3)
3446         (sign_extend:DI (match_operand:SI 0 "register_operand" "")))
3447    (parallel [(set (pc)
3448                    (match_dup 3))
3449               (use (label_ref (match_operand 1 "" "")))])]
3450   ""
3451   "
3452 { operands[3] = gen_reg_rtx (DImode); }")
3453
3454 ;;
3455 ;; tablejump, openVMS way
3456 ;; op 0: offset
3457 ;; op 1: label preceding jump-table
3458 ;;
3459 (define_expand "tablejump_vms"
3460   [(set (match_dup 2)
3461       (match_operand:DI 0 "register_operand" ""))
3462         (set (pc)
3463         (plus:DI (match_dup 2)
3464                 (label_ref:DI (match_operand 1 "" ""))))]
3465   ""
3466   "
3467 { operands[2] = gen_reg_rtx (DImode); }")
3468
3469 (define_insn ""
3470   [(set (pc)
3471         (plus:DI (match_operand:DI 0 "register_operand" "r")
3472                  (label_ref:DI (match_operand 1 "" ""))))
3473    (clobber (match_scratch:DI 2 "=r"))]
3474   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS && next_active_insn (insn) != 0
3475    && GET_CODE (PATTERN (next_active_insn (insn))) == ADDR_DIFF_VEC
3476    && PREV_INSN (next_active_insn (insn)) == operands[1]"
3477   "*
3478 { rtx best_label = 0;
3479   rtx jump_table_insn = next_active_insn (operands[1]);
3480
3481   if (GET_CODE (jump_table_insn) == JUMP_INSN
3482       && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
3483     {
3484       rtx jump_table = PATTERN (jump_table_insn);
3485       int n_labels = XVECLEN (jump_table, 1);
3486       int best_count = -1;
3487       int i, j;
3488
3489       for (i = 0; i < n_labels; i++)
3490         {
3491           int count = 1;
3492
3493           for (j = i + 1; j < n_labels; j++)
3494             if (XEXP (XVECEXP (jump_table, 1, i), 0)
3495                 == XEXP (XVECEXP (jump_table, 1, j), 0))
3496               count++;
3497
3498           if (count > best_count)
3499             best_count = count, best_label = XVECEXP (jump_table, 1, i);
3500         }
3501     }
3502
3503   if (best_label)
3504     {
3505       operands[3] = best_label;
3506       return \"addq %0,$29,%2\;jmp $31,(%2),%3\";
3507     }
3508   else
3509     return \"addq %0,$29,%2\;jmp $31,(%2),0\";
3510 }"
3511   [(set_attr "type" "ibr")])
3512
3513 (define_insn ""
3514   [(set (pc)
3515         (match_operand:DI 0 "register_operand" "r"))
3516    (use (label_ref (match_operand 1 "" "")))]
3517   "TARGET_WINDOWS_NT && next_active_insn (insn) != 0
3518    && GET_CODE (PATTERN (next_active_insn (insn))) == ADDR_DIFF_VEC
3519    && PREV_INSN (next_active_insn (insn)) == operands[1]"
3520   "*
3521 { rtx best_label = 0;
3522   rtx jump_table_insn = next_active_insn (operands[1]);
3523
3524   if (GET_CODE (jump_table_insn) == JUMP_INSN
3525       && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
3526     {
3527       rtx jump_table = PATTERN (jump_table_insn);
3528       int n_labels = XVECLEN (jump_table, 1);
3529       int best_count = -1;
3530       int i, j;
3531
3532       for (i = 0; i < n_labels; i++)
3533         {
3534           int count = 1;
3535
3536           for (j = i + 1; j < n_labels; j++)
3537             if (XEXP (XVECEXP (jump_table, 1, i), 0)
3538                 == XEXP (XVECEXP (jump_table, 1, j), 0))
3539               count++;
3540
3541           if (count > best_count)
3542             best_count = count, best_label = XVECEXP (jump_table, 1, i);
3543         }
3544     }
3545
3546   if (best_label)
3547     {
3548       operands[2] = best_label;
3549       return \"jmp $31,(%0),%2\";
3550     }
3551   else
3552     return \"jmp $31,(%0),0\";
3553 }"
3554   [(set_attr "type" "ibr")])
3555
3556 ;;
3557 ;; op 0 is table offset
3558 ;; op 1 is table label
3559 ;;
3560
3561 (define_insn ""
3562   [(set (pc)
3563         (plus:DI (match_operand 0 "register_operand" "r")
3564                 (label_ref (match_operand 1 "" ""))))]
3565   "TARGET_OPEN_VMS"
3566   "jmp $31,(%0),0"
3567   [(set_attr "type" "ibr")])
3568
3569 ;; Cache flush.  Used by INITIALIZE_TRAMPOLINE.  0x86 is PAL_imb, but we don't
3570 ;; want to have to include pal.h in our .s file.
3571 (define_insn ""
3572   [(unspec_volatile [(const_int 0)] 0)]
3573   ""
3574   "call_pal 0x86"
3575   [(set_attr "type" "isubr")])
3576 \f
3577 ;; Finally, we have the basic data motion insns.  The byte and word insns
3578 ;; are done via define_expand.  Start with the floating-point insns, since
3579 ;; they are simpler.
3580
3581 (define_insn ""
3582   [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m,f,f,f,m")
3583         (match_operand:SF 1 "input_operand" "rG,m,rG,f,G,m,fG"))]
3584   "register_operand (operands[0], SFmode)
3585    || reg_or_fp0_operand (operands[1], SFmode)"
3586   "@
3587    bis %r1,%r1,%0
3588    ldl %0,%1
3589    stl %r1,%0
3590    cpys %1,%1,%0
3591    cpys $f31,$f31,%0
3592    ld%, %0,%1
3593    st%, %R1,%0"
3594   [(set_attr "type" "ilog,ld,st,fcpys,fcpys,ld,st")])
3595
3596 (define_insn ""
3597   [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m,f,f,f,m")
3598         (match_operand:DF 1 "input_operand" "rG,m,rG,f,G,m,fG"))]
3599   "register_operand (operands[0], DFmode)
3600    || reg_or_fp0_operand (operands[1], DFmode)"
3601   "@
3602    bis %r1,%r1,%0
3603    ldq %0,%1
3604    stq %r1,%0
3605    cpys %1,%1,%0
3606    cpys $f31,$f31,%0
3607    ld%- %0,%1
3608    st%- %R1,%0"
3609   [(set_attr "type" "ilog,ld,st,fcpys,fcpys,ld,st")])
3610
3611 (define_expand "movsf"
3612   [(set (match_operand:SF 0 "nonimmediate_operand" "")
3613         (match_operand:SF 1 "general_operand" ""))]
3614   ""
3615   "
3616 {
3617   if (GET_CODE (operands[0]) == MEM
3618       && ! reg_or_fp0_operand (operands[1], SFmode))
3619     operands[1] = force_reg (SFmode, operands[1]);
3620 }")
3621
3622 (define_expand "movdf"
3623   [(set (match_operand:DF 0 "nonimmediate_operand" "")
3624         (match_operand:DF 1 "general_operand" ""))]
3625   ""
3626   "
3627 {
3628   if (GET_CODE (operands[0]) == MEM
3629       && ! reg_or_fp0_operand (operands[1], DFmode))
3630     operands[1] = force_reg (DFmode, operands[1]);
3631 }")
3632
3633 (define_insn ""
3634   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,m,f,f,f,m")
3635         (match_operand:SI 1 "input_operand" "r,J,I,K,L,m,rJ,f,J,m,fG"))]
3636   "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS
3637    && (register_operand (operands[0], SImode)
3638        || reg_or_0_operand (operands[1], SImode))"
3639   "@
3640    bis %1,%1,%0
3641    bis $31,$31,%0
3642    bis $31,%1,%0
3643    lda %0,%1
3644    ldah %0,%h1
3645    ldl %0,%1
3646    stl %r1,%0
3647    cpys %1,%1,%0
3648    cpys $f31,$f31,%0
3649    lds %0,%1
3650    sts %R1,%0"
3651   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ld,st,fcpys,fcpys,ld,st")])
3652
3653 (define_insn ""
3654   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,r,m,f,f,f,m")
3655         (match_operand:SI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,m,fG"))]
3656   "(TARGET_WINDOWS_NT || TARGET_OPEN_VMS)
3657         && (register_operand (operands[0], SImode)
3658                          || reg_or_0_operand (operands[1], SImode))"
3659   "@
3660    bis %1,%1,%0
3661    bis $31,$31,%0
3662    bis $31,%1,%0
3663    lda %0,%1
3664    ldah %0,%h1
3665    lda %0,%1
3666    ldl %0,%1
3667    stl %r1,%0
3668    cpys %1,%1,%0
3669    cpys $f31,$f31,%0
3670    lds %0,%1
3671    sts %R1,%0"
3672   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
3673
3674 (define_insn ""
3675   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
3676         (match_operand:HI 1 "input_operand" "r,J,I,n,f,J"))]
3677   "! TARGET_BYTE_OPS
3678    && (register_operand (operands[0], HImode)
3679        || register_operand (operands[1], HImode))"
3680   "@
3681    bis %1,%1,%0
3682    bis $31,$31,%0
3683    bis $31,%1,%0
3684    lda %0,%L1
3685    cpys %1,%1,%0
3686    cpys $f31,$f31,%0"
3687   [(set_attr "type" "ilog,ilog,ilog,iadd,fcpys,fcpys")])
3688
3689 (define_insn ""
3690   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
3691         (match_operand:HI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
3692   "TARGET_BYTE_OPS
3693    && (register_operand (operands[0], HImode)
3694        || reg_or_0_operand (operands[1], HImode))"
3695   "@
3696    bis %1,%1,%0
3697    bis $31,$31,%0
3698    bis $31,%1,%0
3699    lda %0,%L1
3700    ldwu %0,%1
3701    stw %r1,%0
3702    cpys %1,%1,%0
3703    cpys $f31,$f31,%0"
3704   [(set_attr "type" "ilog,ilog,ilog,iadd,ld,st,fcpys,fcpys")])
3705
3706 (define_insn ""
3707   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
3708         (match_operand:QI 1 "input_operand" "r,J,I,n,f,J"))]
3709   "! TARGET_BYTE_OPS
3710    && (register_operand (operands[0], QImode)
3711        || register_operand (operands[1], QImode))"
3712   "@
3713    bis %1,%1,%0
3714    bis $31,$31,%0
3715    bis $31,%1,%0
3716    lda %0,%L1
3717    cpys %1,%1,%0
3718    cpys $f31,$f31,%0"
3719   [(set_attr "type" "ilog,ilog,ilog,iadd,fcpys,fcpys")])
3720
3721 (define_insn ""
3722   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
3723         (match_operand:QI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
3724   "TARGET_BYTE_OPS
3725    && (register_operand (operands[0], QImode)
3726        || reg_or_0_operand (operands[1], QImode))"
3727   "@
3728    bis %1,%1,%0
3729    bis $31,$31,%0
3730    bis $31,%1,%0
3731    lda %0,%L1
3732    ldbu %0,%1
3733    stb %r1,%0
3734    cpys %1,%1,%0
3735    cpys $f31,$f31,%0"
3736   [(set_attr "type" "ilog,ilog,ilog,iadd,ld,st,fcpys,fcpys")])
3737
3738 ;; We do two major things here: handle mem->mem and construct long
3739 ;; constants.
3740
3741 (define_expand "movsi"
3742   [(set (match_operand:SI 0 "general_operand" "")
3743         (match_operand:SI 1 "general_operand" ""))]
3744   ""
3745   "
3746 {
3747   if (GET_CODE (operands[0]) == MEM
3748       && ! reg_or_0_operand (operands[1], SImode))
3749     operands[1] = force_reg (SImode, operands[1]);
3750
3751   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], SImode))
3752     ;
3753   else if (GET_CODE (operands[1]) == CONST_INT)
3754     {
3755       operands[1]
3756         = alpha_emit_set_const (operands[0], SImode, INTVAL (operands[1]), 3);
3757       if (rtx_equal_p (operands[0], operands[1]))
3758         DONE;
3759     }
3760 }")
3761
3762 ;; Split a load of a large constant into the appropriate two-insn
3763 ;; sequence.
3764
3765 (define_split
3766   [(set (match_operand:SI 0 "register_operand" "")
3767         (match_operand:SI 1 "const_int_operand" ""))]
3768   "! add_operand (operands[1], SImode)"
3769   [(set (match_dup 0) (match_dup 2))
3770    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 3)))]
3771   "
3772 { rtx tem
3773     = alpha_emit_set_const (operands[0], SImode, INTVAL (operands[1]), 2);
3774
3775   if (tem == operands[0])
3776     DONE;
3777   else
3778     FAIL;
3779 }")
3780
3781 (define_insn ""
3782   [(set (match_operand:DI 0 "general_operand" "=r,r,r,r,r,r,r,m,f,f,f,Q")
3783         (match_operand:DI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,Q,fG"))]
3784   "register_operand (operands[0], DImode)
3785    || reg_or_0_operand (operands[1], DImode)"
3786   "@
3787    bis %1,%1,%0
3788    bis $31,$31,%0
3789    bis $31,%1,%0
3790    lda %0,%1
3791    ldah %0,%h1
3792    lda %0,%1
3793    ldq%A1 %0,%1
3794    stq%A0 %r1,%0
3795    cpys %1,%1,%0
3796    cpys $f31,$f31,%0
3797    ldt %0,%1
3798    stt %R1,%0"
3799   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
3800
3801 ;; We do three major things here: handle mem->mem, put 64-bit constants in
3802 ;; memory, and construct long 32-bit constants.
3803
3804 (define_expand "movdi"
3805   [(set (match_operand:DI 0 "general_operand" "")
3806         (match_operand:DI 1 "general_operand" ""))]
3807   ""
3808   "
3809 {
3810   rtx tem;
3811
3812   if (GET_CODE (operands[0]) == MEM
3813       && ! reg_or_0_operand (operands[1], DImode))
3814     operands[1] = force_reg (DImode, operands[1]);
3815
3816   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], DImode))
3817     ;
3818   else if (GET_CODE (operands[1]) == CONST_INT
3819            && (tem = alpha_emit_set_const (operands[0], DImode,
3820                                            INTVAL (operands[1]), 3)) != 0)
3821     {
3822       if (rtx_equal_p (tem, operands[0]))
3823         DONE;
3824       else
3825         operands[1] = tem;
3826     }
3827   else if (CONSTANT_P (operands[1]))
3828     {
3829       if (TARGET_BUILD_CONSTANTS)
3830         {
3831 #if HOST_BITS_PER_WIDE_INT == 64
3832           HOST_WIDE_INT i;
3833
3834           if (GET_CODE (operands[1]) == CONST_INT)
3835             i = INTVAL (operands[1]);
3836           else if (GET_CODE (operands[1]) == CONST_DOUBLE)
3837             i = CONST_DOUBLE_LOW (operands[1]);
3838           else
3839             abort();
3840
3841           tem = alpha_emit_set_long_const (operands[0], i);
3842           if (rtx_equal_p (tem, operands[0]))
3843             DONE;
3844           else
3845             operands[1] = tem;
3846 #else
3847           abort();
3848 #endif
3849         }
3850       else
3851         {
3852           operands[1] = force_const_mem (DImode, operands[1]);
3853           if (reload_in_progress)
3854             {
3855               emit_move_insn (operands[0], XEXP (operands[1], 0));
3856               operands[1] = copy_rtx (operands[1]);
3857               XEXP (operands[1], 0) = operands[0];
3858             }
3859           else
3860             operands[1] = validize_mem (operands[1]);
3861         }
3862     }
3863   else
3864     abort ();
3865 }")
3866
3867 ;; Split a load of a large constant into the appropriate two-insn
3868 ;; sequence.
3869
3870 (define_split
3871   [(set (match_operand:DI 0 "register_operand" "")
3872         (match_operand:DI 1 "const_int_operand" ""))]
3873   "! add_operand (operands[1], DImode)"
3874   [(set (match_dup 0) (match_dup 2))
3875    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
3876   "
3877 { rtx tem
3878     = alpha_emit_set_const (operands[0], DImode, INTVAL (operands[1]), 2);
3879
3880   if (tem == operands[0])
3881     DONE;
3882   else
3883     FAIL;
3884 }")
3885
3886 ;; These are the partial-word cases.
3887 ;;
3888 ;; First we have the code to load an aligned word.  Operand 0 is the register
3889 ;; in which to place the result.  It's mode is QImode or HImode.  Operand 1
3890 ;; is an SImode MEM at the low-order byte of the proper word.  Operand 2 is the
3891 ;; number of bits within the word that the value is.  Operand 3 is an SImode
3892 ;; scratch register.  If operand 0 is a hard register, operand 3 may be the
3893 ;; same register.  It is allowed to conflict with operand 1 as well.
3894
3895 (define_expand "aligned_loadqi"
3896   [(set (match_operand:SI 3 "register_operand" "")
3897         (match_operand:SI 1 "memory_operand" ""))
3898    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3899         (zero_extract:DI (subreg:DI (match_dup 3) 0)
3900                          (const_int 8)
3901                          (match_operand:DI 2 "const_int_operand" "")))]
3902
3903   ""
3904   "")
3905
3906 (define_expand "aligned_loadhi"
3907   [(set (match_operand:SI 3 "register_operand" "")
3908         (match_operand:SI 1 "memory_operand" ""))
3909    (set (subreg:DI (match_operand:HI 0 "register_operand" "") 0)
3910         (zero_extract:DI (subreg:DI (match_dup 3) 0)
3911                          (const_int 16)
3912                          (match_operand:DI 2 "const_int_operand" "")))]
3913
3914   ""
3915   "")
3916
3917 ;; Similar for unaligned loads, where we use the sequence from the
3918 ;; Alpha Architecture manual.
3919 ;;
3920 ;; Operand 1 is the address.  Operands 2 and 3 are temporaries, where
3921 ;; operand 3 can overlap the input and output registers.
3922
3923 (define_expand "unaligned_loadqi"
3924   [(set (match_operand:DI 2 "register_operand" "")
3925         (mem:DI (and:DI (match_operand:DI 1 "address_operand" "")
3926                         (const_int -8))))
3927    (set (match_operand:DI 3 "register_operand" "")
3928         (match_dup 1))
3929    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3930         (zero_extract:DI (match_dup 2)
3931                          (const_int 8)
3932                          (ashift:DI (match_dup 3) (const_int 3))))]
3933   ""
3934   "")
3935
3936 (define_expand "unaligned_loadhi"
3937   [(set (match_operand:DI 2 "register_operand" "")
3938         (mem:DI (and:DI (match_operand:DI 1 "address_operand" "")
3939                         (const_int -8))))
3940    (set (match_operand:DI 3 "register_operand" "")
3941         (match_dup 1))
3942    (set (subreg:DI (match_operand:QI 0 "register_operand" "") 0)
3943         (zero_extract:DI (match_dup 2)
3944                          (const_int 16)
3945                          (ashift:DI (match_dup 3) (const_int 3))))]
3946   ""
3947   "")
3948
3949 ;; Storing an aligned byte or word requires two temporaries.  Operand 0 is the
3950 ;; aligned SImode MEM.  Operand 1 is the register containing the
3951 ;; byte or word to store.  Operand 2 is the number of bits within the word that
3952 ;; the value should be placed.  Operands 3 and 4 are SImode temporaries.
3953
3954 (define_expand "aligned_store"
3955   [(set (match_operand:SI 3 "register_operand" "")
3956         (match_operand:SI 0 "memory_operand" ""))
3957    (set (subreg:DI (match_dup 3) 0)
3958         (and:DI (subreg:DI (match_dup 3) 0) (match_dup 5)))
3959    (set (subreg:DI (match_operand:SI 4 "register_operand" "") 0)
3960         (ashift:DI (zero_extend:DI (match_operand 1 "register_operand" ""))
3961                    (match_operand:DI 2 "const_int_operand" "")))
3962    (set (subreg:DI (match_dup 4) 0)
3963         (ior:DI (subreg:DI (match_dup 4) 0) (subreg:DI (match_dup 3) 0)))
3964    (set (match_dup 0) (match_dup 4))]
3965   ""
3966   "
3967 { operands[5] = GEN_INT (~ (GET_MODE_MASK (GET_MODE (operands[1]))
3968                             << INTVAL (operands[2])));
3969 }")
3970
3971 ;; For the unaligned byte and halfword cases, we use code similar to that
3972 ;; in the ;; Architecture book, but reordered to lower the number of registers
3973 ;; required.  Operand 0 is the address.  Operand 1 is the data to store.
3974 ;; Operands 2, 3, and 4 are DImode temporaries, where operands 2 and 4 may
3975 ;; be the same temporary, if desired.  If the address is in a register,
3976 ;; operand 2 can be that register.
3977
3978 (define_expand "unaligned_storeqi"
3979   [(set (match_operand:DI 3 "register_operand" "")
3980         (mem:DI (and:DI (match_operand:DI 0 "address_operand" "")
3981                         (const_int -8))))
3982    (set (match_operand:DI 2 "register_operand" "")
3983         (match_dup 0))
3984    (set (match_dup 3)
3985         (and:DI (not:DI (ashift:DI (const_int 255)
3986                                    (ashift:DI (match_dup 2) (const_int 3))))
3987                 (match_dup 3)))
3988    (set (match_operand:DI 4 "register_operand" "")
3989         (ashift:DI (zero_extend:DI (match_operand:QI 1 "register_operand" ""))
3990                    (ashift:DI (match_dup 2) (const_int 3))))
3991    (set (match_dup 4) (ior:DI (match_dup 4) (match_dup 3)))
3992    (set (mem:DI (and:DI (match_dup 0) (const_int -8)))
3993         (match_dup 4))]
3994   ""
3995   "")
3996
3997 (define_expand "unaligned_storehi"
3998   [(set (match_operand:DI 3 "register_operand" "")
3999         (mem:DI (and:DI (match_operand:DI 0 "address_operand" "")
4000                         (const_int -8))))
4001    (set (match_operand:DI 2 "register_operand" "")
4002         (match_dup 0))
4003    (set (match_dup 3)
4004         (and:DI (not:DI (ashift:DI (const_int 65535)
4005                                    (ashift:DI (match_dup 2) (const_int 3))))
4006                 (match_dup 3)))
4007    (set (match_operand:DI 4 "register_operand" "")
4008         (ashift:DI (zero_extend:DI (match_operand:HI 1 "register_operand" ""))
4009                    (ashift:DI (match_dup 2) (const_int 3))))
4010    (set (match_dup 4) (ior:DI (match_dup 4) (match_dup 3)))
4011    (set (mem:DI (and:DI (match_dup 0) (const_int -8)))
4012         (match_dup 4))]
4013   ""
4014   "")
4015 \f
4016 ;; Here are the define_expand's for QI and HI moves that use the above
4017 ;; patterns.  We have the normal sets, plus the ones that need scratch
4018 ;; registers for reload.
4019
4020 (define_expand "movqi"
4021   [(set (match_operand:QI 0 "general_operand" "")
4022         (match_operand:QI 1 "general_operand" ""))]
4023   ""
4024   "
4025 { extern rtx get_unaligned_address ();
4026
4027   if (TARGET_BYTE_OPS)
4028     {
4029       if (GET_CODE (operands[0]) == MEM
4030           && ! reg_or_0_operand (operands[1], QImode))
4031         operands[1] = force_reg (QImode, operands[1]);
4032
4033       if (GET_CODE (operands[1]) == CONST_INT
4034                && ! input_operand (operands[1], QImode))
4035         {
4036           operands[1] = alpha_emit_set_const (operands[0], QImode,
4037                                               INTVAL (operands[1]), 3);
4038
4039           if (rtx_equal_p (operands[0], operands[1]))
4040             DONE;
4041         }
4042
4043       goto def;
4044     }
4045
4046   /* If the output is not a register, the input must be.  */
4047   if (GET_CODE (operands[0]) == MEM)
4048     operands[1] = force_reg (QImode, operands[1]);
4049
4050   /* Handle four memory cases, unaligned and aligned for either the input
4051      or the output.  The only case where we can be called during reload is
4052      for aligned loads; all other cases require temporaries.  */
4053
4054   if (GET_CODE (operands[1]) == MEM
4055       || (GET_CODE (operands[1]) == SUBREG
4056           && GET_CODE (SUBREG_REG (operands[1])) == MEM)
4057       || (reload_in_progress && GET_CODE (operands[1]) == REG
4058           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)
4059       || (reload_in_progress && GET_CODE (operands[1]) == SUBREG
4060           && GET_CODE (SUBREG_REG (operands[1])) == REG
4061           && REGNO (SUBREG_REG (operands[1])) >= FIRST_PSEUDO_REGISTER))
4062     {
4063       if (aligned_memory_operand (operands[1], QImode))
4064         {
4065           rtx aligned_mem, bitnum;
4066           rtx scratch = (reload_in_progress
4067                          ? gen_rtx (REG, SImode, REGNO (operands[0]))
4068                          : gen_reg_rtx (SImode));
4069
4070           get_aligned_mem (operands[1], &aligned_mem, &bitnum);
4071
4072           emit_insn (gen_aligned_loadqi (operands[0], aligned_mem, bitnum,
4073                                          scratch));
4074         }
4075       else
4076         {
4077           /* Don't pass these as parameters since that makes the generated
4078              code depend on parameter evaluation order which will cause
4079              bootstrap failures.  */
4080
4081           rtx temp1 = gen_reg_rtx (DImode);
4082           rtx temp2 = gen_reg_rtx (DImode);
4083           rtx seq
4084             = gen_unaligned_loadqi (operands[0],
4085                                     get_unaligned_address (operands[1], 0),
4086                                     temp1, temp2);
4087
4088           alpha_set_memflags (seq, operands[1]);
4089           emit_insn (seq);
4090         }
4091
4092       DONE;
4093     }
4094
4095   else if (GET_CODE (operands[0]) == MEM
4096            || (GET_CODE (operands[0]) == SUBREG
4097                && GET_CODE (SUBREG_REG (operands[0])) == MEM)
4098            || (reload_in_progress && GET_CODE (operands[0]) == REG
4099                && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
4100            || (reload_in_progress && GET_CODE (operands[0]) == SUBREG
4101                && GET_CODE (SUBREG_REG (operands[0])) == REG
4102                && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))
4103     {
4104       if (aligned_memory_operand (operands[0], QImode))
4105         {
4106           rtx aligned_mem, bitnum;
4107           rtx temp1 = gen_reg_rtx (SImode);
4108           rtx temp2 = gen_reg_rtx (SImode);
4109
4110           get_aligned_mem (operands[0], &aligned_mem, &bitnum);
4111
4112           emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
4113                                         temp1, temp2));
4114         }
4115       else
4116         {
4117           rtx temp1 = gen_reg_rtx (DImode);
4118           rtx temp2 = gen_reg_rtx (DImode);
4119           rtx temp3 = gen_reg_rtx (DImode);
4120           rtx seq
4121             = gen_unaligned_storeqi (get_unaligned_address (operands[0], 0),
4122                                            operands[1], temp1, temp2, temp3);
4123
4124           alpha_set_memflags (seq, operands[0]);
4125           emit_insn (seq);
4126         }
4127       DONE;
4128     }
4129  def:;
4130 }")
4131
4132 (define_expand "movhi"
4133   [(set (match_operand:HI 0 "general_operand" "")
4134         (match_operand:HI 1 "general_operand" ""))]
4135   ""
4136   "
4137 { extern rtx get_unaligned_address ();
4138
4139   if (TARGET_BYTE_OPS)
4140     {
4141       if (GET_CODE (operands[0]) == MEM
4142           && ! reg_or_0_operand (operands[1], HImode))
4143         operands[1] = force_reg (HImode, operands[1]);
4144
4145       if (GET_CODE (operands[1]) == CONST_INT
4146                && ! input_operand (operands[1], HImode))
4147         {
4148           operands[1] = alpha_emit_set_const (operands[0], HImode,
4149                                               INTVAL (operands[1]), 3);
4150
4151           if (rtx_equal_p (operands[0], operands[1]))
4152             DONE;
4153         }
4154
4155       goto def;
4156     }
4157
4158   /* If the output is not a register, the input must be.  */
4159   if (GET_CODE (operands[0]) == MEM)
4160     operands[1] = force_reg (HImode, operands[1]);
4161
4162   /* Handle four memory cases, unaligned and aligned for either the input
4163      or the output.  The only case where we can be called during reload is
4164      for aligned loads; all other cases require temporaries.  */
4165
4166   if (GET_CODE (operands[1]) == MEM
4167       || (GET_CODE (operands[1]) == SUBREG
4168           && GET_CODE (SUBREG_REG (operands[1])) == MEM)
4169       || (reload_in_progress && GET_CODE (operands[1]) == REG
4170           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)
4171       || (reload_in_progress && GET_CODE (operands[1]) == SUBREG
4172           && GET_CODE (SUBREG_REG (operands[1])) == REG
4173           && REGNO (SUBREG_REG (operands[1])) >= FIRST_PSEUDO_REGISTER))
4174     {
4175       if (aligned_memory_operand (operands[1], HImode))
4176         {
4177           rtx aligned_mem, bitnum;
4178           rtx scratch = (reload_in_progress
4179                          ? gen_rtx (REG, SImode, REGNO (operands[0]))
4180                          : gen_reg_rtx (SImode));
4181
4182           get_aligned_mem (operands[1], &aligned_mem, &bitnum);
4183
4184           emit_insn (gen_aligned_loadhi (operands[0], aligned_mem, bitnum,
4185                                          scratch));
4186         }
4187       else
4188         {
4189           /* Don't pass these as parameters since that makes the generated
4190              code depend on parameter evaluation order which will cause
4191              bootstrap failures.  */
4192
4193           rtx temp1 = gen_reg_rtx (DImode);
4194           rtx temp2 = gen_reg_rtx (DImode);
4195           rtx seq
4196             = gen_unaligned_loadhi (operands[0],
4197                                     get_unaligned_address (operands[1], 0),
4198                                     temp1, temp2);
4199
4200           alpha_set_memflags (seq, operands[1]);
4201           emit_insn (seq);
4202         }
4203
4204       DONE;
4205     }
4206
4207   else if (GET_CODE (operands[0]) == MEM
4208            || (GET_CODE (operands[0]) == SUBREG
4209                && GET_CODE (SUBREG_REG (operands[0])) == MEM)
4210            || (reload_in_progress && GET_CODE (operands[0]) == REG
4211                && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
4212            || (reload_in_progress && GET_CODE (operands[0]) == SUBREG
4213                && GET_CODE (SUBREG_REG (operands[0])) == REG
4214                && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))
4215     {
4216       if (aligned_memory_operand (operands[0], HImode))
4217         {
4218           rtx aligned_mem, bitnum;
4219           rtx temp1 = gen_reg_rtx (SImode);
4220           rtx temp2 = gen_reg_rtx (SImode);
4221
4222           get_aligned_mem (operands[0], &aligned_mem, &bitnum);
4223
4224           emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
4225                                         temp1, temp2));
4226         }
4227       else
4228         {
4229           rtx temp1 = gen_reg_rtx (DImode);
4230           rtx temp2 = gen_reg_rtx (DImode);
4231           rtx temp3 = gen_reg_rtx (DImode);
4232           rtx seq
4233             = gen_unaligned_storehi (get_unaligned_address (operands[0], 0),
4234                                      operands[1], temp1, temp2, temp3);
4235
4236           alpha_set_memflags (seq, operands[0]);
4237           emit_insn (seq);
4238         }
4239
4240       DONE;
4241     }
4242  def:;
4243 }")
4244
4245 ;; Here are the versions for reload.  Note that in the unaligned cases
4246 ;; we know that the operand must not be a pseudo-register because stack
4247 ;; slots are always aligned references.
4248
4249 (define_expand "reload_inqi"
4250   [(parallel [(match_operand:QI 0 "register_operand" "=r")
4251               (match_operand:QI 1 "unaligned_memory_operand" "m")
4252               (match_operand:TI 2 "register_operand" "=&r")])]
4253   "! TARGET_BYTE_OPS"
4254   "
4255 { extern rtx get_unaligned_address ();
4256   rtx addr = get_unaligned_address (operands[1], 0);
4257   /* It is possible that one of the registers we got for operands[2]
4258      might coincide with that of operands[0] (which is why we made
4259      it TImode).  Pick the other one to use as our scratch.  */
4260   rtx scratch = gen_rtx (REG, DImode,
4261                          REGNO (operands[0]) == REGNO (operands[2])
4262                          ? REGNO (operands[2]) + 1 : REGNO (operands[2]));
4263   rtx seq = gen_unaligned_loadqi (operands[0], addr, scratch,
4264                                   gen_rtx (REG, DImode, REGNO (operands[0])));
4265
4266   alpha_set_memflags (seq, operands[1]);
4267   emit_insn (seq);
4268   DONE;
4269 }")
4270
4271 (define_expand "reload_inhi"
4272   [(parallel [(match_operand:HI 0 "register_operand" "=r")
4273               (match_operand:HI 1 "unaligned_memory_operand" "m")
4274               (match_operand:TI 2 "register_operand" "=&r")])]
4275   "! TARGET_BYTE_OPS"
4276   "
4277 { extern rtx get_unaligned_address ();
4278   rtx addr = get_unaligned_address (operands[1], 0);
4279   /* It is possible that one of the registers we got for operands[2]
4280      might coincide with that of operands[0] (which is why we made
4281      it TImode).  Pick the other one to use as our scratch.  */
4282   rtx scratch = gen_rtx (REG, DImode,
4283                          REGNO (operands[0]) == REGNO (operands[2])
4284                          ? REGNO (operands[2]) + 1 : REGNO (operands[2]));
4285   rtx seq = gen_unaligned_loadhi (operands[0], addr, scratch,
4286                                   gen_rtx (REG, DImode, REGNO (operands[0])));
4287
4288   alpha_set_memflags (seq, operands[1]);
4289   emit_insn (seq);
4290   DONE;
4291 }")
4292
4293 (define_expand "reload_outqi"
4294   [(parallel [(match_operand:QI 0 "any_memory_operand" "=m")
4295               (match_operand:QI 1 "register_operand" "r")
4296               (match_operand:TI 2 "register_operand" "=&r")])]
4297   "! TARGET_BYTE_OPS"
4298   "
4299 { extern rtx get_unaligned_address ();
4300
4301   if (aligned_memory_operand (operands[0], QImode))
4302     {
4303       rtx aligned_mem, bitnum;
4304
4305       get_aligned_mem (operands[0], &aligned_mem, &bitnum);
4306
4307       emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
4308                                     gen_rtx (REG, SImode, REGNO (operands[2])),
4309                                     gen_rtx (REG, SImode,
4310                                              REGNO (operands[2]) + 1)));
4311     }
4312   else
4313     {
4314       rtx addr = get_unaligned_address (operands[0], 0);
4315       rtx scratch1 = gen_rtx (REG, DImode, REGNO (operands[2]));
4316       rtx scratch2 = gen_rtx (REG, DImode, REGNO (operands[2]) + 1);
4317       rtx scratch3 = scratch1;
4318       rtx seq;
4319
4320       if (GET_CODE (addr) == REG)
4321         scratch1 = addr;
4322
4323       seq = gen_unaligned_storeqi (addr, operands[1], scratch1,
4324                                    scratch2, scratch3);
4325       alpha_set_memflags (seq, operands[0]);
4326       emit_insn (seq);
4327     }
4328
4329   DONE;
4330 }")
4331
4332 (define_expand "reload_outhi"
4333   [(parallel [(match_operand:HI 0 "any_memory_operand" "=m")
4334               (match_operand:HI 1 "register_operand" "r")
4335               (match_operand:TI 2 "register_operand" "=&r")])]
4336   "! TARGET_BYTE_OPS"
4337   "
4338 { extern rtx get_unaligned_address ();
4339
4340   if (aligned_memory_operand (operands[0], HImode))
4341     {
4342       rtx aligned_mem, bitnum;
4343
4344       get_aligned_mem (operands[0], &aligned_mem, &bitnum);
4345
4346       emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
4347                                     gen_rtx (REG, SImode, REGNO (operands[2])),
4348                                     gen_rtx (REG, SImode,
4349                                              REGNO (operands[2]) + 1)));
4350     }
4351   else
4352     {
4353       rtx addr = get_unaligned_address (operands[0], 0);
4354       rtx scratch1 = gen_rtx (REG, DImode, REGNO (operands[2]));
4355       rtx scratch2 = gen_rtx (REG, DImode, REGNO (operands[2]) + 1);
4356       rtx scratch3 = scratch1;
4357       rtx seq;
4358
4359       if (GET_CODE (addr) == REG)
4360         scratch1 = addr;
4361
4362       seq = gen_unaligned_storehi (addr, operands[1], scratch1,
4363                                    scratch2, scratch3);
4364       alpha_set_memflags (seq, operands[0]);
4365       emit_insn (seq);
4366     }
4367
4368   DONE;
4369 }")
4370 \f
4371 ;; Subroutine of stack space allocation.  Perform a stack probe.
4372 (define_expand "probe_stack"
4373   [(set (match_dup 1) (match_operand:DI 0 "const_int_operand" ""))]
4374   ""
4375   "
4376 {
4377   operands[1] = gen_rtx (MEM, DImode, plus_constant (stack_pointer_rtx,
4378                                                      INTVAL (operands[0])));
4379   MEM_VOLATILE_P (operands[1]) = 1;
4380
4381   operands[0] = const0_rtx;
4382 }")
4383
4384 ;; This is how we allocate stack space.  If we are allocating a
4385 ;; constant amount of space and we know it is less than 4096
4386 ;; bytes, we need do nothing.
4387 ;;
4388 ;; If it is more than 4096 bytes, we need to probe the stack
4389 ;; periodically.
4390 (define_expand "allocate_stack"
4391   [(set (reg:DI 30)
4392         (plus:DI (reg:DI 30)
4393                  (match_operand:DI 0 "reg_or_cint_operand" "")))]
4394   ""
4395   "
4396 {
4397   if (GET_CODE (operands[0]) == CONST_INT
4398            && INTVAL (operands[0]) < 32768)
4399     {
4400       if (INTVAL (operands[0]) >= 4096)
4401         {
4402           /* We do this the same way as in the prologue and generate explicit
4403              probes.  Then we update the stack by the constant.  */
4404
4405           int probed = 4096;
4406
4407           emit_insn (gen_probe_stack (GEN_INT (- probed)));
4408           while (probed + 8192 < INTVAL (operands[0]))
4409             emit_insn (gen_probe_stack (GEN_INT (- (probed += 8192))));
4410
4411           if (probed + 4096 < INTVAL (operands[0]))
4412             emit_insn (gen_probe_stack (GEN_INT (- INTVAL(operands[0]))));
4413         }
4414
4415       operands[0] = GEN_INT (- INTVAL (operands[0]));
4416     }
4417   else
4418     {
4419       rtx out_label = 0;
4420       rtx loop_label = gen_label_rtx ();
4421       rtx want = gen_reg_rtx (Pmode);
4422       rtx tmp = gen_reg_rtx (Pmode);
4423       rtx memref;
4424
4425       emit_insn (gen_subdi3 (want, stack_pointer_rtx,
4426                              force_reg (Pmode, operands[0])));
4427       emit_insn (gen_adddi3 (tmp, stack_pointer_rtx, GEN_INT (-4096)));
4428
4429       if (GET_CODE (operands[0]) != CONST_INT)
4430         {
4431           out_label = gen_label_rtx ();
4432           emit_insn (gen_cmpdi (want, tmp));
4433           emit_jump_insn (gen_bgeu (out_label));
4434         }
4435
4436       emit_label (loop_label);
4437       memref = gen_rtx (MEM, DImode, tmp);
4438       MEM_VOLATILE_P (memref) = 1;
4439       emit_move_insn (memref, const0_rtx);
4440       emit_insn (gen_adddi3 (tmp, tmp, GEN_INT(-8192)));
4441       emit_insn (gen_cmpdi (tmp, want));
4442       emit_jump_insn (gen_bgtu (loop_label));
4443       memref = gen_rtx (MEM, DImode, want);
4444       MEM_VOLATILE_P (memref) = 1;
4445       emit_move_insn (memref, const0_rtx);
4446
4447       if (out_label)
4448         emit_label (out_label);
4449
4450       emit_move_insn (stack_pointer_rtx, want);
4451
4452       DONE;
4453     }
4454 }")
4455
4456 (define_insn "exception_receiver"
4457   [(unspec_volatile [(const_int 0)] 2)]
4458   "! TARGET_OPEN_VMS && ! TARGET_WINDOWS_NT"
4459   ".long 0xc3a00000\;ldgp $29,0($29)")
4460
4461 (define_expand "nonlocal_goto_receiver"
4462   [(unspec_volatile [(const_int 0)] 1)
4463    (set (reg:DI 27) (mem:DI (reg:DI 29)))
4464    (unspec_volatile [(const_int 0)] 1)
4465    (use (reg:DI 27))]
4466   "TARGET_OPEN_VMS"
4467   "")
4468
4469 (define_insn "arg_home"
4470   [(unspec [(const_int 0)] 0)
4471    (use (reg:DI 1))
4472    (use (reg:DI 25))
4473    (use (reg:DI 16))
4474    (use (reg:DI 17))
4475    (use (reg:DI 18))
4476    (use (reg:DI 19))
4477    (use (reg:DI 20))
4478    (use (reg:DI 21))
4479    (use (reg:DI 48))
4480    (use (reg:DI 49))
4481    (use (reg:DI 50))
4482    (use (reg:DI 51))
4483    (use (reg:DI 52))
4484    (use (reg:DI 53))
4485    (clobber (mem:BLK (const_int 0)))
4486    (clobber (reg:DI 24))
4487    (clobber (reg:DI 25))
4488    (clobber (reg:DI 0))]
4489   "TARGET_OPEN_VMS"
4490   "lda $0,ots$home_args\;ldq $0,8($0)\;jsr $0,ots$home_args")
4491
4492 ;; Close the trap shadow of preceeding instructions.  This is generated
4493 ;; by alpha_reorg.
4494
4495 (define_insn "trapb"
4496   [(unspec_volatile [(const_int 0)] 3)]
4497   ""
4498   "trapb"
4499   [(set_attr "type" "misc")])