gcc/config/vax/vax.md

   1 ;; Machine description for GNU compiler, VAX Version
   2 ;; Copyright (C) 1987, 1988, 1991, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   3 ;; 2002, 2004, 2005 Free Software Foundation, Inc.
   4
   5 ;; This file is part of GCC.
   6
   7 ;; GCC 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 ;; GCC 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 GCC; 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
  23 ;;- Instruction patterns.  When multiple patterns apply,
  24 ;;- the first one in the file is chosen.
  25 ;;-
  26 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  27 ;;-
  28 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  29 ;;- updates for most instructions.
  30
  31 ;; UNSPEC_VOLATILE usage:
  32
  33 (define_constants
  34   [(VUNSPEC_BLOCKAGE 0)     ; `blockage' insn to prevent scheduling across an
  35                             ;   insn in the code.
  36    (VUNSPEC_SYNC_ISTREAM 1) ; sequence of insns to sync the I-stream
  37   ]
  38 )
  39
  40 ;; Integer modes supported on VAX, withd a mapping from machine mode
  41 ;; to mnemonic suffix.  DImode is always a special case.
  42 (define_mode_macro VAXint [QI HI SI])
  43 (define_mode_attr  isfx [(QI "b") (HI "w") (SI "l")])
  44
  45 ;; Similar for float modes supported on VAX.
  46 (define_mode_macro VAXfp [SF DF])
  47 (define_mode_attr  fsfx [(SF "f") (DF "%#")])
  48
  49 ;; Some ouput patterns want integer immediates with a prefix...
  50 (define_mode_attr  iprefx [(QI "B") (HI "H") (SI "N")])
  51
  52 ;; We don't want to allow a constant operand for test insns because
  53 ;; We don't want to allow a constant operand for test insns because
  54 ;; (set (cc0) (const_int foo)) has no mode information.  Such insns will
  55 ;; be folded while optimizing anyway.
  56
  57 (define_insn "tst<mode>"
  58   [(set (cc0)
  59         (match_operand:VAXint 0 "nonimmediate_operand" "g"))]
  60   ""
  61   "tst<VAXint:isfx> %0")
  62
  63 (define_insn "tst<mode>"
  64   [(set (cc0)
  65         (match_operand:VAXfp 0 "general_operand" "gF"))]
  66   ""
  67   "tst<VAXfp:fsfx> %0")
  68
  69 (define_insn "cmp<mode>"
  70   [(set (cc0)
  71         (compare (match_operand:VAXint 0 "nonimmediate_operand" "g")
  72                  (match_operand:VAXint 1 "general_operand" "g")))]
  73   ""
  74   "cmp<VAXint:isfx> %0,%1")
  75
  76 (define_insn "cmp<mode>"
  77   [(set (cc0)
  78         (compare (match_operand:VAXfp 0 "general_operand" "gF,gF")
  79                  (match_operand:VAXfp 1 "general_operand" "G,gF")))]
  80   ""
  81   "@
  82    tst<VAXfp:fsfx> %0
  83    cmp<VAXfp:fsfx> %0,%1")
  84
  85 (define_insn "*bit<mode>"
  86   [(set (cc0)
  87         (and:VAXint (match_operand:VAXint 0 "general_operand" "g")
  88                    (match_operand:VAXint 1 "general_operand" "g")))]
  89   ""
  90   "bit<VAXint:isfx> %0,%1")
  91
  92 ;; The VAX has no sCOND insns.  It does have add/subtract with carry
  93 ;; which could be used to implement the sltu and sgeu patterns.  However,
  94 ;; to do this properly requires a complete rewrite of the compare insns
  95 ;; to keep them together with the sltu/sgeu insns until after the
  96 ;; reload pass is complete.  The previous implementation didn't do this
  97 ;; and has been deleted.
  98
  99 \f
 100 (define_insn "mov<mode>"
 101   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g,g")
 102         (match_operand:VAXfp 1 "general_operand" "G,gF"))]
 103   ""
 104   "@
 105    clr<VAXfp:fsfx> %0
 106    mov<VAXfp:fsfx> %1,%0")
 107
 108 ;; Some VAXen don't support this instruction.
 109 ;;(define_insn "movti"
 110 ;;  [(set (match_operand:TI 0 "general_operand" "=g")
 111 ;;      (match_operand:TI 1 "general_operand" "g"))]
 112 ;;  ""
 113 ;;  "movh %1,%0")
 114
 115 (define_insn "movdi"
 116   [(set (match_operand:DI 0 "nonimmediate_operand" "=g,g")
 117         (match_operand:DI 1 "general_operand" "I,g"))]
 118   ""
 119   "@
 120    clrq %0
 121    movq %D1,%0")
 122
 123 ;; The VAX move instructions have space-time tradeoffs.  On a MicroVAX
 124 ;; register-register mov instructions take 3 bytes and 2 CPU cycles.  clrl
 125 ;; takes 2 bytes and 3 cycles.  mov from constant to register takes 2 cycles
 126 ;; if the constant is smaller than 4 bytes, 3 cycles for a longword
 127 ;; constant.  movz, mneg, and mcom are as fast as mov, so movzwl is faster
 128 ;; than movl for positive constants that fit in 16 bits but not 6 bits.  cvt
 129 ;; instructions take 4 cycles.  inc takes 3 cycles.  The machine description
 130 ;; is willing to trade 1 byte for 1 cycle (clrl instead of movl $0; cvtwl
 131 ;; instead of movl).
 132
 133 ;; Cycle counts for other models may vary (on a VAX 750 they are similar,
 134 ;; but on a VAX 9000 most move and add instructions with one constant
 135 ;; operand take 1 cycle).
 136
 137 ;;  Loads of constants between 64 and 128 used to be done with
 138 ;; "addl3 $63,#,dst" but this is slower than movzbl and takes as much space.
 139
 140 (define_insn "mov<mode>"
 141   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g")
 142         (match_operand:VAXint 1 "general_operand" "g"))]
 143   ""
 144   "* return vax_output_int_move (insn, operands, <MODE>mode);")
 145
 146 (define_insn "movstricthi"
 147   [(set (strict_low_part (match_operand:HI 0 "register_operand" "+g"))
 148         (match_operand:HI 1 "general_operand" "g"))]
 149   ""
 150   "*
 151 {
 152   if (GET_CODE (operands[1]) == CONST_INT)
 153     {
 154       int i = INTVAL (operands[1]);
 155       if (i == 0)
 156         return \"clrw %0\";
 157       else if ((unsigned int)i < 64)
 158         return \"movw %1,%0\";
 159       else if ((unsigned int)~i < 64)
 160         return \"mcomw %H1,%0\";
 161       else if ((unsigned int)i < 256)
 162         return \"movzbw %1,%0\";
 163     }
 164   return \"movw %1,%0\";
 165 }")
 166
 167 (define_insn "movstrictqi"
 168   [(set (strict_low_part (match_operand:QI 0 "register_operand" "+g"))
 169         (match_operand:QI 1 "general_operand" "g"))]
 170   ""
 171   "*
 172 {
 173   if (GET_CODE (operands[1]) == CONST_INT)
 174     {
 175       int i = INTVAL (operands[1]);
 176       if (i == 0)
 177         return \"clrb %0\";
 178       else if ((unsigned int)~i < 64)
 179         return \"mcomb %B1,%0\";
 180     }
 181   return \"movb %1,%0\";
 182 }")
 183
 184 ;; This is here to accept 4 arguments and pass the first 3 along
 185 ;; to the movmemhi1 pattern that really does the work.
 186 (define_expand "movmemhi"
 187   [(set (match_operand:BLK 0 "general_operand" "=g")
 188         (match_operand:BLK 1 "general_operand" "g"))
 189    (use (match_operand:HI 2 "general_operand" "g"))
 190    (match_operand 3 "" "")]
 191   ""
 192   "
 193   emit_insn (gen_movmemhi1 (operands[0], operands[1], operands[2]));
 194   DONE;
 195 ")
 196
 197 ;; The definition of this insn does not really explain what it does,
 198 ;; but it should suffice
 199 ;; that anything generated as this insn will be recognized as one
 200 ;; and that it won't successfully combine with anything.
 201 (define_insn "movmemhi1"
 202   [(set (match_operand:BLK 0 "memory_operand" "=m")
 203         (match_operand:BLK 1 "memory_operand" "m"))
 204    (use (match_operand:HI 2 "general_operand" "g"))
 205    (clobber (reg:SI 0))
 206    (clobber (reg:SI 1))
 207    (clobber (reg:SI 2))
 208    (clobber (reg:SI 3))
 209    (clobber (reg:SI 4))
 210    (clobber (reg:SI 5))]
 211   ""
 212   "movc3 %2,%1,%0")
 213 \f
 214 ;; Extension and truncation insns.
 215
 216 (define_insn "truncsiqi2"
 217   [(set (match_operand:QI 0 "nonimmediate_operand" "=g")
 218         (truncate:QI (match_operand:SI 1 "nonimmediate_operand" "g")))]
 219   ""
 220   "cvtlb %1,%0")
 221
 222 (define_insn "truncsihi2"
 223   [(set (match_operand:HI 0 "nonimmediate_operand" "=g")
 224         (truncate:HI (match_operand:SI 1 "nonimmediate_operand" "g")))]
 225   ""
 226   "cvtlw %1,%0")
 227
 228 (define_insn "trunchiqi2"
 229   [(set (match_operand:QI 0 "nonimmediate_operand" "=g")
 230         (truncate:QI (match_operand:HI 1 "nonimmediate_operand" "g")))]
 231   ""
 232   "cvtwb %1,%0")
 233
 234 (define_insn "extendhisi2"
 235   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 236         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "g")))]
 237   ""
 238   "cvtwl %1,%0")
 239
 240 (define_insn "extendqihi2"
 241   [(set (match_operand:HI 0 "nonimmediate_operand" "=g")
 242         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "g")))]
 243   ""
 244   "cvtbw %1,%0")
 245
 246 (define_insn "extendqisi2"
 247   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 248         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "g")))]
 249   ""
 250   "cvtbl %1,%0")
 251
 252 (define_insn "extendsfdf2"
 253   [(set (match_operand:DF 0 "nonimmediate_operand" "=g")
 254         (float_extend:DF (match_operand:SF 1 "general_operand" "gF")))]
 255   ""
 256   "cvtf%# %1,%0")
 257
 258 (define_insn "truncdfsf2"
 259   [(set (match_operand:SF 0 "nonimmediate_operand" "=g")
 260         (float_truncate:SF (match_operand:DF 1 "general_operand" "gF")))]
 261   ""
 262   "cvt%#f %1,%0")
 263
 264 (define_insn "zero_extendhisi2"
 265   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 266         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "g")))]
 267   ""
 268   "movzwl %1,%0")
 269
 270 (define_insn "zero_extendqihi2"
 271   [(set (match_operand:HI 0 "nonimmediate_operand" "=g")
 272         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "g")))]
 273   ""
 274   "movzbw %1,%0")
 275
 276 (define_insn "zero_extendqisi2"
 277   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 278         (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "g")))]
 279   ""
 280   "movzbl %1,%0")
 281 \f
 282 ;; Fix-to-float conversion insns.
 283
 284 (define_insn "float<VAXint:mode><VAXfp:mode>2"
 285   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g")
 286         (float:VAXfp (match_operand:VAXint 1 "nonimmediate_operand" "g")))]
 287   ""
 288   "cvt<VAXint:isfx><VAXfp:fsfx> %1,%0")
 289
 290 ;; Float-to-fix conversion insns.
 291
 292 (define_insn "fix_trunc<VAXfp:mode><VAXint:mode>2"
 293   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g")
 294         (fix:VAXint (fix:VAXfp (match_operand:VAXfp 1 "general_operand" "gF"))))]
 295   ""
 296   "cvt<VAXfp:fsfx><VAXint:isfx> %1,%0")
 297 \f
 298 ;;- All kinds of add instructions.
 299
 300 (define_insn "add<mode>3"
 301   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g,g,g")
 302         (plus:VAXfp (match_operand:VAXfp 1 "general_operand" "0,gF,gF")
 303                     (match_operand:VAXfp 2 "general_operand" "gF,0,gF")))]
 304   ""
 305   "@
 306    add<VAXfp:fsfx>2 %2,%0
 307    add<VAXfp:fsfx>2 %1,%0
 308    add<VAXfp:fsfx>3 %1,%2,%0")
 309
 310 (define_insn "add<mode>3"
 311   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g")
 312         (plus:VAXint (match_operand:VAXint 1 "general_operand" "g")
 313                     (match_operand:VAXint 2 "general_operand" "g")))]
 314   ""
 315   "* return vax_output_int_add (insn, operands, <MODE>mode);")
 316
 317 ;; The add-with-carry (adwc) instruction only accepts two operands.
 318 (define_insn "adddi3"
 319   [(set (match_operand:DI 0 "nonimmediate_operand" "=ro>,ro>")
 320         (plus:DI (match_operand:DI 1 "general_operand" "%0,ro>")
 321                  (match_operand:DI 2 "general_operand" "Fro,F")))]
 322   ""
 323   "*
 324 {
 325   rtx low[3];
 326   const char *pattern;
 327   int carry = 1;
 328
 329   split_quadword_operands (operands, low, 3);
 330   /* Add low parts.  */
 331   if (rtx_equal_p (operands[0], operands[1]))
 332     {
 333       if (low[2] == const0_rtx)
 334         /* Should examine operand, punt if not POST_INC.  */
 335         pattern = \"tstl %0\", carry = 0;
 336       else if (low[2] == const1_rtx)
 337         pattern = \"incl %0\";
 338       else
 339         pattern = \"addl2 %2,%0\";
 340     }
 341   else
 342     {
 343       if (low[2] == const0_rtx)
 344         pattern = \"movl %1,%0\", carry = 0;
 345       else
 346         pattern = \"addl3 %2,%1,%0\";
 347     }
 348   if (pattern)
 349     output_asm_insn (pattern, low);
 350   if (!carry)
 351     /* If CARRY is 0, we don't have any carry value to worry about.  */
 352     return get_insn_template (CODE_FOR_addsi3, insn);
 353   /* %0 = C + %1 + %2 */
 354   if (!rtx_equal_p (operands[0], operands[1]))
 355     output_asm_insn ((operands[1] == const0_rtx
 356                       ? \"clrl %0\"
 357                       : \"movl %1,%0\"), operands);
 358   return \"adwc %2,%0\";
 359 }")
 360 \f
 361 ;;- All kinds of subtract instructions.
 362
 363 (define_insn "sub<mode>3"
 364   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g,g")
 365         (minus:VAXfp (match_operand:VAXfp 1 "general_operand" "0,gF")
 366                      (match_operand:VAXfp 2 "general_operand" "gF,gF")))]
 367   ""
 368   "@
 369    sub<VAXfp:fsfx>2 %2,%0
 370    sub<VAXfp:fsfx>3 %2,%1,%0")
 371
 372 (define_insn "sub<mode>3"
 373   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g")
 374         (minus:VAXint (match_operand:VAXint 1 "general_operand" "0,g")
 375                      (match_operand:VAXint 2 "general_operand" "g,g")))]
 376   ""
 377   "@
 378    sub<VAXint:isfx>2 %2,%0
 379    sub<VAXint:isfx>3 %2,%1,%0")
 380
 381 ;; The subtract-with-carry (sbwc) instruction only takes two operands.
 382 (define_insn "subdi3"
 383   [(set (match_operand:DI 0 "nonimmediate_operand" "=or>,or>")
 384         (minus:DI (match_operand:DI 1 "general_operand" "0,or>")
 385                   (match_operand:DI 2 "general_operand" "For,F")))]
 386   ""
 387   "*
 388 {
 389   rtx low[3];
 390   const char *pattern;
 391   int carry = 1;
 392
 393   split_quadword_operands (operands, low, 3);
 394   /* Subtract low parts.  */
 395   if (rtx_equal_p (operands[0], operands[1]))
 396     {
 397       if (low[2] == const0_rtx)
 398         pattern = 0, carry = 0;
 399       else if (low[2] == constm1_rtx)
 400         pattern = \"decl %0\";
 401       else
 402         pattern = \"subl2 %2,%0\";
 403     }
 404   else
 405     {
 406       if (low[2] == constm1_rtx)
 407         pattern = \"decl %0\";
 408       else if (low[2] == const0_rtx)
 409         pattern = get_insn_template (CODE_FOR_movsi, insn), carry = 0;
 410       else
 411         pattern = \"subl3 %2,%1,%0\";
 412     }
 413   if (pattern)
 414     output_asm_insn (pattern, low);
 415   if (carry)
 416     {
 417       if (!rtx_equal_p (operands[0], operands[1]))
 418         return \"movl %1,%0\;sbwc %2,%0\";
 419       return \"sbwc %2,%0\";
 420       /* %0 = %2 - %1 - C */
 421     }
 422   return get_insn_template (CODE_FOR_subsi3, insn);
 423 }")
 424 \f
 425 ;;- Multiply instructions.
 426
 427 (define_insn "mul<mode>3"
 428   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g,g,g")
 429         (mult:VAXfp (match_operand:VAXfp 1 "general_operand" "0,gF,gF")
 430                     (match_operand:VAXfp 2 "general_operand" "gF,0,gF")))]
 431   ""
 432   "@
 433    mul<VAXfp:fsfx>2 %2,%0
 434    mul<VAXfp:fsfx>2 %1,%0
 435    mul<VAXfp:fsfx>3 %1,%2,%0")
 436
 437 (define_insn "mul<mode>3"
 438   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g,g")
 439         (mult:VAXint (match_operand:VAXint 1 "general_operand" "0,g,g")
 440                     (match_operand:VAXint 2 "general_operand" "g,0,g")))]
 441   ""
 442   "@
 443    mul<VAXint:isfx>2 %2,%0
 444    mul<VAXint:isfx>2 %1,%0
 445    mul<VAXint:isfx>3 %1,%2,%0")
 446
 447 (define_insn "mulsidi3"
 448   [(set (match_operand:DI 0 "nonimmediate_operand" "=g")
 449         (mult:DI (sign_extend:DI
 450                   (match_operand:SI 1 "nonimmediate_operand" "g"))
 451                  (sign_extend:DI
 452                   (match_operand:SI 2 "nonimmediate_operand" "g"))))]
 453   ""
 454   "emul %1,%2,$0,%0")
 455
 456 (define_insn ""
 457   [(set (match_operand:DI 0 "nonimmediate_operand" "=g")
 458         (plus:DI
 459          (mult:DI (sign_extend:DI
 460                    (match_operand:SI 1 "nonimmediate_operand" "g"))
 461                   (sign_extend:DI
 462                    (match_operand:SI 2 "nonimmediate_operand" "g")))
 463          (sign_extend:DI (match_operand:SI 3 "nonimmediate_operand" "g"))))]
 464   ""
 465   "emul %1,%2,%3,%0")
 466
 467 ;; 'F' constraint means type CONST_DOUBLE
 468 (define_insn ""
 469   [(set (match_operand:DI 0 "nonimmediate_operand" "=g")
 470         (plus:DI
 471          (mult:DI (sign_extend:DI
 472                    (match_operand:SI 1 "nonimmediate_operand" "g"))
 473                   (sign_extend:DI
 474                    (match_operand:SI 2 "nonimmediate_operand" "g")))
 475          (match_operand:DI 3 "immediate_operand" "F")))]
 476   "GET_CODE (operands[3]) == CONST_DOUBLE
 477     && CONST_DOUBLE_HIGH (operands[3]) == (CONST_DOUBLE_LOW (operands[3]) >> 31)"
 478   "*
 479 {
 480   if (CONST_DOUBLE_HIGH (operands[3]))
 481     operands[3] = GEN_INT (CONST_DOUBLE_LOW (operands[3]));
 482   return \"emul %1,%2,%3,%0\";
 483 }")
 484 \f
 485 ;;- Divide instructions.
 486
 487 (define_insn "div<mode>3"
 488   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g,g")
 489         (div:VAXfp (match_operand:VAXfp 1 "general_operand" "0,gF")
 490                    (match_operand:VAXfp 2 "general_operand" "gF,gF")))]
 491   ""
 492   "@
 493    div<VAXfp:fsfx>2 %2,%0
 494    div<VAXfp:fsfx>3 %2,%1,%0")
 495
 496 (define_insn "div<mode>3"
 497   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g")
 498         (div:VAXint (match_operand:VAXint 1 "general_operand" "0,g")
 499                    (match_operand:VAXint 2 "general_operand" "g,g")))]
 500   ""
 501   "@
 502    div<VAXint:isfx>2 %2,%0
 503    div<VAXint:isfx>3 %2,%1,%0")
 504
 505 ;This is left out because it is very slow;
 506 ;we are better off programming around the "lack" of this insn.
 507 ;(define_insn "divmoddisi4"
 508 ;  [(set (match_operand:SI 0 "general_operand" "=g")
 509 ;       (div:SI (match_operand:DI 1 "general_operand" "g")
 510 ;               (match_operand:SI 2 "general_operand" "g")))
 511 ;   (set (match_operand:SI 3 "general_operand" "=g")
 512 ;       (mod:SI (match_operand:DI 1 "general_operand" "g")
 513 ;               (match_operand:SI 2 "general_operand" "g")))]
 514 ;  ""
 515 ;  "ediv %2,%1,%0,%3")
 516 \f
 517 ;; Bit-and on the VAX is done with a clear-bits insn.
 518 (define_expand "and<mode>3"
 519   [(set (match_operand:VAXint 0 "nonimmediate_operand" "")
 520         (and:VAXint (not:VAXint (match_operand:VAXint 1 "general_operand" ""))
 521                    (match_operand:VAXint 2 "general_operand" "")))]
 522   ""
 523   "
 524 {
 525   rtx op1 = operands[1];
 526
 527   /* If there is a constant argument, complement that one.  */
 528   if (GET_CODE (operands[2]) == CONST_INT && GET_CODE (op1) != CONST_INT)
 529     {
 530       operands[1] = operands[2];
 531       operands[2] = op1;
 532       op1 = operands[1];
 533     }
 534
 535   if (GET_CODE (op1) == CONST_INT)
 536     operands[1] = GEN_INT (~INTVAL (op1));
 537   else
 538     operands[1] = expand_unop (<MODE>mode, one_cmpl_optab, op1, 0, 1);
 539 }")
 540
 541 (define_insn "*and<mode>"
 542   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g")
 543         (and:VAXint (not:VAXint (match_operand:VAXint 1 "general_operand" "g,g"))
 544                     (match_operand:VAXint 2 "general_operand" "0,g")))]
 545   ""
 546   "@
 547    bic<VAXint:isfx>2 %1,%0
 548    bic<VAXint:isfx>3 %1,%2,%0")
 549
 550 ;; The following used to be needed because constant propagation can
 551 ;; create them starting from the bic insn patterns above.  This is no
 552 ;; longer a problem.  However, having these patterns allows optimization
 553 ;; opportunities in combine.c.
 554
 555 (define_insn "*and<mode>_const_int"
 556   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g")
 557         (and:VAXint (match_operand:VAXint 1 "general_operand" "0,g")
 558                    (match_operand:VAXint 2 "const_int_operand" "n,n")))]
 559   ""
 560   "@
 561    bic<VAXint:isfx>2 %<VAXint:iprefx>2,%0
 562    bic<VAXint:isfx>3 %<VAXint:iprefx>2,%1,%0")
 563
 564 \f
 565 ;;- Bit set instructions.
 566
 567 (define_insn "ior<mode>3"
 568   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g,g")
 569         (ior:VAXint (match_operand:VAXint 1 "general_operand" "0,g,g")
 570                    (match_operand:VAXint 2 "general_operand" "g,0,g")))]
 571   ""
 572   "@
 573    bis<VAXint:isfx>2 %2,%0
 574    bis<VAXint:isfx>2 %1,%0
 575    bis<VAXint:isfx>3 %2,%1,%0")
 576
 577 ;;- xor instructions.
 578
 579 (define_insn "xor<mode>3"
 580   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g,g")
 581         (xor:VAXint (match_operand:VAXint 1 "general_operand" "0,g,g")
 582                    (match_operand:VAXint 2 "general_operand" "g,0,g")))]
 583   ""
 584   "@
 585    xor<VAXint:isfx>2 %2,%0
 586    xor<VAXint:isfx>2 %1,%0
 587    xor<VAXint:isfx>3 %2,%1,%0")
 588
 589 \f
 590 (define_insn "neg<mode>2"
 591   [(set (match_operand:VAXfp 0 "nonimmediate_operand" "=g")
 592         (neg:VAXfp (match_operand:VAXfp 1 "general_operand" "gF")))]
 593   ""
 594   "mneg<VAXfp:fsfx> %1,%0")
 595
 596 (define_insn "neg<mode>2"
 597   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g")
 598         (neg:VAXint (match_operand:VAXint 1 "general_operand" "g")))]
 599   ""
 600   "mneg<VAXint:isfx> %1,%0")
 601
 602 (define_insn "one_cmpl<mode>2"
 603   [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g")
 604         (not:VAXint (match_operand:VAXint 1 "general_operand" "g")))]
 605   ""
 606   "mcom<VAXint:isfx> %1,%0")
 607
 608 \f
 609 ;; Arithmetic right shift on the VAX works by negating the shift count,
 610 ;; then emitting a right shift with the shift count negated.  This means
 611 ;; that all actual shift counts in the RTL will be positive.  This
 612 ;; prevents converting shifts to ZERO_EXTRACTs with negative positions,
 613 ;; which isn't valid.
 614 (define_expand "ashrsi3"
 615   [(set (match_operand:SI 0 "general_operand" "=g")
 616         (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
 617                    (match_operand:QI 2 "general_operand" "g")))]
 618   ""
 619   "
 620 {
 621   if (GET_CODE (operands[2]) != CONST_INT)
 622     operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
 623 }")
 624
 625 (define_insn ""
 626   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 627         (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
 628                      (match_operand:QI 2 "const_int_operand" "n")))]
 629   ""
 630   "ashl $%n2,%1,%0")
 631
 632 (define_insn ""
 633   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 634         (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
 635                      (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
 636   ""
 637   "ashl %2,%1,%0")
 638
 639 (define_insn "ashlsi3"
 640   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 641         (ashift:SI (match_operand:SI 1 "general_operand" "g")
 642                    (match_operand:QI 2 "general_operand" "g")))]
 643   ""
 644   "*
 645 {
 646   if (operands[2] == const1_rtx && rtx_equal_p (operands[0], operands[1]))
 647     return \"addl2 %0,%0\";
 648   if (GET_CODE (operands[1]) == REG
 649       && GET_CODE (operands[2]) == CONST_INT)
 650     {
 651       int i = INTVAL (operands[2]);
 652       if (i == 1)
 653         return \"addl3 %1,%1,%0\";
 654       if (i == 2)
 655         return \"moval 0[%1],%0\";
 656       if (i == 3)
 657         return \"movad 0[%1],%0\";
 658     }
 659   return \"ashl %2,%1,%0\";
 660 }")
 661
 662 ;; Arithmetic right shift on the VAX works by negating the shift count.
 663 (define_expand "ashrdi3"
 664   [(set (match_operand:DI 0 "general_operand" "=g")
 665         (ashiftrt:DI (match_operand:DI 1 "general_operand" "g")
 666                      (match_operand:QI 2 "general_operand" "g")))]
 667   ""
 668   "
 669 {
 670   operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
 671 }")
 672
 673 (define_insn "ashldi3"
 674   [(set (match_operand:DI 0 "nonimmediate_operand" "=g")
 675         (ashift:DI (match_operand:DI 1 "general_operand" "g")
 676                    (match_operand:QI 2 "general_operand" "g")))]
 677   ""
 678   "ashq %2,%1,%0")
 679
 680 (define_insn ""
 681   [(set (match_operand:DI 0 "nonimmediate_operand" "=g")
 682         (ashiftrt:DI (match_operand:DI 1 "general_operand" "g")
 683                      (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
 684   ""
 685   "ashq %2,%1,%0")
 686
 687 ;; We used to have expand_shift handle logical right shifts by using extzv,
 688 ;; but this make it very difficult to do lshrdi3.  Since the VAX is the
 689 ;; only machine with this kludge, it's better to just do this with a
 690 ;; define_expand and remove that case from expand_shift.
 691
 692 (define_expand "lshrsi3"
 693   [(set (match_dup 3)
 694         (minus:QI (const_int 32)
 695                   (match_dup 4)))
 696    (set (match_operand:SI 0 "general_operand" "=g")
 697         (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
 698                          (match_dup 3)
 699                          (match_operand:SI 2 "register_operand" "g")))]
 700   ""
 701   "
 702 {
 703   operands[3] = gen_reg_rtx (QImode);
 704   operands[4] = gen_lowpart (QImode, operands[2]);
 705 }")
 706
 707 ;; Rotate right on the VAX works by negating the shift count.
 708 (define_expand "rotrsi3"
 709   [(set (match_operand:SI 0 "general_operand" "=g")
 710         (rotatert:SI (match_operand:SI 1 "general_operand" "g")
 711                      (match_operand:QI 2 "general_operand" "g")))]
 712   ""
 713   "
 714 {
 715   if (GET_CODE (operands[2]) != CONST_INT)
 716     operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
 717 }")
 718
 719 (define_insn "rotlsi3"
 720   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 721         (rotate:SI (match_operand:SI 1 "general_operand" "g")
 722                    (match_operand:QI 2 "general_operand" "g")))]
 723   ""
 724   "rotl %2,%1,%0")
 725
 726 (define_insn ""
 727   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 728         (rotatert:SI (match_operand:SI 1 "general_operand" "g")
 729                      (match_operand:QI 2 "const_int_operand" "n")))]
 730   ""
 731   "rotl %R2,%1,%0")
 732
 733 (define_insn ""
 734   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 735         (rotatert:SI (match_operand:SI 1 "general_operand" "g")
 736                      (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
 737   ""
 738   "rotl %2,%1,%0")
 739
 740 ;This insn is probably slower than a multiply and an add.
 741 ;(define_insn ""
 742 ;  [(set (match_operand:SI 0 "general_operand" "=g")
 743 ;       (mult:SI (plus:SI (match_operand:SI 1 "general_operand" "g")
 744 ;                         (match_operand:SI 2 "general_operand" "g"))
 745 ;                (match_operand:SI 3 "general_operand" "g")))]
 746 ;  ""
 747 ;  "index %1,$0x80000000,$0x7fffffff,%3,%2,%0")
 748 \f
 749 ;; Special cases of bit-field insns which we should
 750 ;; recognize in preference to the general case.
 751 ;; These handle aligned 8-bit and 16-bit fields,
 752 ;; which can usually be done with move instructions.
 753
 754 (define_insn ""
 755   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+ro")
 756                          (match_operand:QI 1 "const_int_operand" "n")
 757                          (match_operand:SI 2 "const_int_operand" "n"))
 758         (match_operand:SI 3 "general_operand" "g"))]
 759    "(INTVAL (operands[1]) == 8 || INTVAL (operands[1]) == 16)
 760    && INTVAL (operands[2]) % INTVAL (operands[1]) == 0
 761    && (GET_CODE (operands[0]) == REG
 762        || ! mode_dependent_address_p (XEXP (operands[0], 0)))"
 763   "*
 764 {
 765   if (REG_P (operands[0]))
 766     {
 767       if (INTVAL (operands[2]) != 0)
 768         return \"insv %3,%2,%1,%0\";
 769     }
 770   else
 771     operands[0]
 772       = adjust_address (operands[0],
 773                         INTVAL (operands[1]) == 8 ? QImode : HImode,
 774                         INTVAL (operands[2]) / 8);
 775
 776   CC_STATUS_INIT;
 777   if (INTVAL (operands[1]) == 8)
 778     return \"movb %3,%0\";
 779   return \"movw %3,%0\";
 780 }")
 781
 782 (define_insn ""
 783   [(set (match_operand:SI 0 "nonimmediate_operand" "=&g")
 784         (zero_extract:SI (match_operand:SI 1 "register_operand" "ro")
 785                          (match_operand:QI 2 "const_int_operand" "n")
 786                          (match_operand:SI 3 "const_int_operand" "n")))]
 787   "(INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
 788    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0
 789    && (GET_CODE (operands[1]) == REG
 790        || ! mode_dependent_address_p (XEXP (operands[1], 0)))"
 791   "*
 792 {
 793   if (REG_P (operands[1]))
 794     {
 795       if (INTVAL (operands[3]) != 0)
 796         return \"extzv %3,%2,%1,%0\";
 797     }
 798   else
 799     operands[1]
 800       = adjust_address (operands[1],
 801                         INTVAL (operands[2]) == 8 ? QImode : HImode,
 802                         INTVAL (operands[3]) / 8);
 803
 804   if (INTVAL (operands[2]) == 8)
 805     return \"movzbl %1,%0\";
 806   return \"movzwl %1,%0\";
 807 }")
 808
 809 (define_insn ""
 810   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 811         (sign_extract:SI (match_operand:SI 1 "register_operand" "ro")
 812                          (match_operand:QI 2 "const_int_operand" "n")
 813                          (match_operand:SI 3 "const_int_operand" "n")))]
 814   "(INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
 815    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0
 816    && (GET_CODE (operands[1]) == REG
 817        || ! mode_dependent_address_p (XEXP (operands[1], 0)))"
 818   "*
 819 {
 820   if (REG_P (operands[1]))
 821     {
 822       if (INTVAL (operands[3]) != 0)
 823         return \"extv %3,%2,%1,%0\";
 824     }
 825   else
 826     operands[1]
 827       = adjust_address (operands[1],
 828                         INTVAL (operands[2]) == 8 ? QImode : HImode,
 829                         INTVAL (operands[3]) / 8);
 830
 831   if (INTVAL (operands[2]) == 8)
 832     return \"cvtbl %1,%0\";
 833   return \"cvtwl %1,%0\";
 834 }")
 835 \f
 836 ;; Register-only SImode cases of bit-field insns.
 837
 838 (define_insn ""
 839   [(set (cc0)
 840         (compare
 841          (sign_extract:SI (match_operand:SI 0 "register_operand" "r")
 842                           (match_operand:QI 1 "general_operand" "g")
 843                           (match_operand:SI 2 "general_operand" "g"))
 844          (match_operand:SI 3 "general_operand" "g")))]
 845   ""
 846   "cmpv %2,%1,%0,%3")
 847
 848 (define_insn ""
 849   [(set (cc0)
 850         (compare
 851          (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
 852                           (match_operand:QI 1 "general_operand" "g")
 853                           (match_operand:SI 2 "general_operand" "g"))
 854          (match_operand:SI 3 "general_operand" "g")))]
 855   ""
 856   "cmpzv %2,%1,%0,%3")
 857
 858 ;; When the field position and size are constant and the destination
 859 ;; is a register, extv and extzv are much slower than a rotate followed
 860 ;; by a bicl or sign extension.  Because we might end up choosing ext[z]v
 861 ;; anyway, we can't allow immediate values for the primary source operand.
 862
 863 (define_insn ""
 864   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 865         (sign_extract:SI (match_operand:SI 1 "register_operand" "ro")
 866                          (match_operand:QI 2 "general_operand" "g")
 867                          (match_operand:SI 3 "general_operand" "g")))]
 868   ""
 869   "*
 870 {
 871   if (GET_CODE (operands[3]) != CONST_INT || GET_CODE (operands[2]) != CONST_INT
 872       || GET_CODE (operands[0]) != REG
 873       || (INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16))
 874     return \"extv %3,%2,%1,%0\";
 875   if (INTVAL (operands[2]) == 8)
 876     return \"rotl %R3,%1,%0\;cvtbl %0,%0\";
 877   return \"rotl %R3,%1,%0\;cvtwl %0,%0\";
 878 }")
 879
 880 (define_insn ""
 881   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 882         (zero_extract:SI (match_operand:SI 1 "register_operand" "ro")
 883                          (match_operand:QI 2 "general_operand" "g")
 884                          (match_operand:SI 3 "general_operand" "g")))]
 885   ""
 886   "*
 887 {
 888   if (GET_CODE (operands[3]) != CONST_INT || GET_CODE (operands[2]) != CONST_INT
 889       || GET_CODE (operands[0]) != REG)
 890     return \"extzv %3,%2,%1,%0\";
 891   if (INTVAL (operands[2]) == 8)
 892     return \"rotl %R3,%1,%0\;movzbl %0,%0\";
 893   if (INTVAL (operands[2]) == 16)
 894     return \"rotl %R3,%1,%0\;movzwl %0,%0\";
 895   if (INTVAL (operands[3]) & 31)
 896     return \"rotl %R3,%1,%0\;bicl2 %M2,%0\";
 897   if (rtx_equal_p (operands[0], operands[1]))
 898     return \"bicl2 %M2,%0\";
 899   return \"bicl3 %M2,%1,%0\";
 900 }")
 901
 902 ;; Non-register cases.
 903 ;; nonimmediate_operand is used to make sure that mode-ambiguous cases
 904 ;; don't match these (and therefore match the cases above instead).
 905
 906 (define_insn ""
 907   [(set (cc0)
 908         (compare
 909          (sign_extract:SI (match_operand:QI 0 "memory_operand" "m")
 910                           (match_operand:QI 1 "general_operand" "g")
 911                           (match_operand:SI 2 "general_operand" "g"))
 912          (match_operand:SI 3 "general_operand" "g")))]
 913   ""
 914   "cmpv %2,%1,%0,%3")
 915
 916 (define_insn ""
 917   [(set (cc0)
 918         (compare
 919          (zero_extract:SI (match_operand:QI 0 "nonimmediate_operand" "rm")
 920                           (match_operand:QI 1 "general_operand" "g")
 921                           (match_operand:SI 2 "general_operand" "g"))
 922          (match_operand:SI 3 "general_operand" "g")))]
 923   ""
 924   "cmpzv %2,%1,%0,%3")
 925
 926 (define_insn "extv"
 927   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 928         (sign_extract:SI (match_operand:QI 1 "memory_operand" "m")
 929                          (match_operand:QI 2 "general_operand" "g")
 930                          (match_operand:SI 3 "general_operand" "g")))]
 931   ""
 932   "*
 933 {
 934   if (GET_CODE (operands[0]) != REG || GET_CODE (operands[2]) != CONST_INT
 935       || GET_CODE (operands[3]) != CONST_INT
 936       || (INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16)
 937       || INTVAL (operands[2]) + INTVAL (operands[3]) > 32
 938       || side_effects_p (operands[1])
 939       || (GET_CODE (operands[1]) == MEM
 940           && mode_dependent_address_p (XEXP (operands[1], 0))))
 941     return \"extv %3,%2,%1,%0\";
 942   if (INTVAL (operands[2]) == 8)
 943     return \"rotl %R3,%1,%0\;cvtbl %0,%0\";
 944   return \"rotl %R3,%1,%0\;cvtwl %0,%0\";
 945 }")
 946
 947 (define_expand "extzv"
 948   [(set (match_operand:SI 0 "general_operand" "")
 949         (zero_extract:SI (match_operand:SI 1 "general_operand" "")
 950                          (match_operand:QI 2 "general_operand" "")
 951                          (match_operand:SI 3 "general_operand" "")))]
 952   ""
 953   "")
 954
 955 (define_insn ""
 956   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
 957         (zero_extract:SI (match_operand:QI 1 "memory_operand" "m")
 958                          (match_operand:QI 2 "general_operand" "g")
 959                          (match_operand:SI 3 "general_operand" "g")))]
 960   ""
 961   "*
 962 {
 963   if (GET_CODE (operands[0]) != REG || GET_CODE (operands[2]) != CONST_INT
 964       || GET_CODE (operands[3]) != CONST_INT
 965       || INTVAL (operands[2]) + INTVAL (operands[3]) > 32
 966       || side_effects_p (operands[1])
 967       || (GET_CODE (operands[1]) == MEM
 968           && mode_dependent_address_p (XEXP (operands[1], 0))))
 969     return \"extzv %3,%2,%1,%0\";
 970   if (INTVAL (operands[2]) == 8)
 971     return \"rotl %R3,%1,%0\;movzbl %0,%0\";
 972   if (INTVAL (operands[2]) == 16)
 973     return \"rotl %R3,%1,%0\;movzwl %0,%0\";
 974   return \"rotl %R3,%1,%0\;bicl2 %M2,%0\";
 975 }")
 976
 977 (define_expand "insv"
 978   [(set (zero_extract:SI (match_operand:SI 0 "general_operand" "")
 979                          (match_operand:QI 1 "general_operand" "")
 980                          (match_operand:SI 2 "general_operand" ""))
 981         (match_operand:SI 3 "general_operand" ""))]
 982   ""
 983   "")
 984
 985 (define_insn ""
 986   [(set (zero_extract:SI (match_operand:QI 0 "memory_operand" "+g")
 987                          (match_operand:QI 1 "general_operand" "g")
 988                          (match_operand:SI 2 "general_operand" "g"))
 989         (match_operand:SI 3 "general_operand" "g"))]
 990   ""
 991   "insv %3,%2,%1,%0")
 992
 993 (define_insn ""
 994   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
 995                          (match_operand:QI 1 "general_operand" "g")
 996                          (match_operand:SI 2 "general_operand" "g"))
 997         (match_operand:SI 3 "general_operand" "g"))]
 998   ""
 999   "insv %3,%2,%1,%0")
1000 \f
1001 ;; Unconditional jump
1002 (define_insn "jump"
1003   [(set (pc)
1004         (label_ref (match_operand 0 "" "")))]
1005   ""
1006   "jbr %l0")
1007
1008 ;; Conditional jumps
1009 (define_code_macro any_cond [eq ne gt lt gtu ltu ge le geu leu])
1010
1011 (define_insn "b<code>"
1012   [(set (pc)
1013         (if_then_else (any_cond (cc0)
1014                                 (const_int 0))
1015                       (label_ref (match_operand 0 "" ""))
1016                       (pc)))]
1017   ""
1018   "* return vax_output_conditional_branch (<CODE>);")
1019
1020 ;; Recognize reversed jumps.
1021 (define_insn ""
1022   [(set (pc)
1023         (if_then_else (match_operator 0 "comparison_operator"
1024                                       [(cc0)
1025                                        (const_int 0)])
1026                       (pc)
1027                       (label_ref (match_operand 1 "" ""))))]
1028   ""
1029   "j%C0 %l1") ; %C0 negates condition
1030 \f
1031 ;; Recognize jbs, jlbs, jbc and jlbc instructions.  Note that the operand
1032 ;; of jlbs and jlbc insns are SImode in the hardware.  However, if it is
1033 ;; memory, we use QImode in the insn.  So we can't use those instructions
1034 ;; for mode-dependent addresses.
1035
1036 (define_insn ""
1037   [(set (pc)
1038         (if_then_else
1039          (ne (zero_extract:SI (match_operand:QI 0 "memory_operand" "Q,g")
1040                               (const_int 1)
1041                               (match_operand:SI 1 "general_operand" "I,g"))
1042              (const_int 0))
1043          (label_ref (match_operand 2 "" ""))
1044          (pc)))]
1045   ""
1046   "@
1047    jlbs %0,%l2
1048    jbs %1,%0,%l2")
1049
1050 (define_insn ""
1051   [(set (pc)
1052         (if_then_else
1053          (eq (zero_extract:SI (match_operand:QI 0 "memory_operand" "Q,g")
1054                               (const_int 1)
1055                               (match_operand:SI 1 "general_operand" "I,g"))
1056              (const_int 0))
1057          (label_ref (match_operand 2 "" ""))
1058          (pc)))]
1059   ""
1060   "@
1061    jlbc %0,%l2
1062    jbc %1,%0,%l2")
1063
1064 (define_insn ""
1065   [(set (pc)
1066         (if_then_else
1067          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r,r")
1068                               (const_int 1)
1069                               (match_operand:SI 1 "general_operand" "I,g"))
1070              (const_int 0))
1071          (label_ref (match_operand 2 "" ""))
1072          (pc)))]
1073   ""
1074   "@
1075    jlbs %0,%l2
1076    jbs %1,%0,%l2")
1077
1078 (define_insn ""
1079   [(set (pc)
1080         (if_then_else
1081          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r,r")
1082                               (const_int 1)
1083                               (match_operand:SI 1 "general_operand" "I,g"))
1084              (const_int 0))
1085          (label_ref (match_operand 2 "" ""))
1086          (pc)))]
1087   ""
1088   "@
1089    jlbc %0,%l2
1090    jbc %1,%0,%l2")
1091 \f
1092 ;; Subtract-and-jump and Add-and-jump insns.
1093 ;; These are not used when output is for the Unix assembler
1094 ;; because it does not know how to modify them to reach far.
1095
1096 ;; Normal sob insns.
1097
1098 (define_insn ""
1099   [(set (pc)
1100         (if_then_else
1101          (gt (plus:SI (match_operand:SI 0 "nonimmediate_operand" "+g")
1102                       (const_int -1))
1103              (const_int 0))
1104          (label_ref (match_operand 1 "" ""))
1105          (pc)))
1106    (set (match_dup 0)
1107         (plus:SI (match_dup 0)
1108                  (const_int -1)))]
1109   "!TARGET_UNIX_ASM"
1110   "jsobgtr %0,%l1")
1111
1112 (define_insn ""
1113   [(set (pc)
1114         (if_then_else
1115          (ge (plus:SI (match_operand:SI 0 "nonimmediate_operand" "+g")
1116                       (const_int -1))
1117              (const_int 0))
1118          (label_ref (match_operand 1 "" ""))
1119          (pc)))
1120    (set (match_dup 0)
1121         (plus:SI (match_dup 0)
1122                  (const_int -1)))]
1123   "!TARGET_UNIX_ASM"
1124   "jsobgeq %0,%l1")
1125
1126 ;; Normal aob insns.  Define a version for when operands[1] is a constant.
1127 (define_insn ""
1128   [(set (pc)
1129         (if_then_else
1130          (lt (plus:SI (match_operand:SI 0 "nonimmediate_operand" "+g")
1131                       (const_int 1))
1132              (match_operand:SI 1 "general_operand" "g"))
1133          (label_ref (match_operand 2 "" ""))
1134          (pc)))
1135    (set (match_dup 0)
1136         (plus:SI (match_dup 0)
1137                  (const_int 1)))]
1138   "!TARGET_UNIX_ASM"
1139   "jaoblss %1,%0,%l2")
1140
1141 (define_insn ""
1142   [(set (pc)
1143         (if_then_else
1144          (lt (match_operand:SI 0 "nonimmediate_operand" "+g")
1145              (match_operand:SI 1 "general_operand" "g"))
1146          (label_ref (match_operand 2 "" ""))
1147          (pc)))
1148    (set (match_dup 0)
1149         (plus:SI (match_dup 0)
1150                  (const_int 1)))]
1151   "!TARGET_UNIX_ASM && GET_CODE (operands[1]) == CONST_INT"
1152   "jaoblss %P1,%0,%l2")
1153
1154 (define_insn ""
1155   [(set (pc)
1156         (if_then_else
1157          (le (plus:SI (match_operand:SI 0 "nonimmediate_operand" "+g")
1158                       (const_int 1))
1159              (match_operand:SI 1 "general_operand" "g"))
1160          (label_ref (match_operand 2 "" ""))
1161          (pc)))
1162    (set (match_dup 0)
1163         (plus:SI (match_dup 0)
1164                  (const_int 1)))]
1165   "!TARGET_UNIX_ASM"
1166   "jaobleq %1,%0,%l2")
1167
1168 (define_insn ""
1169   [(set (pc)
1170         (if_then_else
1171          (le (match_operand:SI 0 "nonimmediate_operand" "+g")
1172              (match_operand:SI 1 "general_operand" "g"))
1173          (label_ref (match_operand 2 "" ""))
1174          (pc)))
1175    (set (match_dup 0)
1176         (plus:SI (match_dup 0)
1177                  (const_int 1)))]
1178   "!TARGET_UNIX_ASM && GET_CODE (operands[1]) == CONST_INT"
1179   "jaobleq %P1,%0,%l2")
1180
1181 ;; Something like a sob insn, but compares against -1.
1182 ;; This finds `while (foo--)' which was changed to `while (--foo != -1)'.
1183
1184 (define_insn ""
1185   [(set (pc)
1186         (if_then_else
1187          (ne (match_operand:SI 0 "nonimmediate_operand" "+g")
1188              (const_int 0))
1189          (label_ref (match_operand 1 "" ""))
1190          (pc)))
1191    (set (match_dup 0)
1192         (plus:SI (match_dup 0)
1193                  (const_int -1)))]
1194   ""
1195   "decl %0\;jgequ %l1")
1196 \f
1197 (define_expand "call_pop"
1198   [(parallel [(call (match_operand:QI 0 "memory_operand" "")
1199                     (match_operand:SI 1 "const_int_operand" ""))
1200               (set (reg:SI 14)
1201                    (plus:SI (reg:SI 14)
1202                             (match_operand:SI 3 "immediate_operand" "")))])]
1203   ""
1204 {
1205   if (INTVAL (operands[3]) > 255 * 4 || INTVAL (operands[3]) % 4)
1206     abort ();
1207
1208   /* Operand 1 is the number of bytes to be popped by DW_CFA_GNU_args_size
1209      during EH unwinding.  We must include the argument count pushed by
1210      the calls instruction.  */
1211   operands[1] = GEN_INT (INTVAL (operands[3]) + 4);
1212 })
1213
1214 (define_insn "*call_pop"
1215   [(call (match_operand:QI 0 "memory_operand" "m")
1216          (match_operand:SI 1 "const_int_operand" "n"))
1217    (set (reg:SI 14) (plus:SI (reg:SI 14)
1218                              (match_operand:SI 2 "immediate_operand" "i")))]
1219   ""
1220 {
1221   operands[1] = GEN_INT ((INTVAL (operands[1]) - 4) / 4);
1222   return "calls %1,%0";
1223 })
1224
1225 (define_expand "call_value_pop"
1226   [(parallel [(set (match_operand 0 "" "")
1227                    (call (match_operand:QI 1 "memory_operand" "")
1228                          (match_operand:SI 2 "const_int_operand" "")))
1229               (set (reg:SI 14)
1230                    (plus:SI (reg:SI 14)
1231                             (match_operand:SI 4 "immediate_operand" "")))])]
1232   ""
1233 {
1234   if (INTVAL (operands[4]) > 255 * 4 || INTVAL (operands[4]) % 4)
1235     abort ();
1236
1237   /* Operand 2 is the number of bytes to be popped by DW_CFA_GNU_args_size
1238      during EH unwinding.  We must include the argument count pushed by
1239      the calls instruction.  */
1240   operands[2] = GEN_INT (INTVAL (operands[4]) + 4);
1241 })
1242
1243 (define_insn "*call_value_pop"
1244   [(set (match_operand 0 "" "")
1245         (call (match_operand:QI 1 "memory_operand" "m")
1246               (match_operand:SI 2 "const_int_operand" "n")))
1247    (set (reg:SI 14) (plus:SI (reg:SI 14)
1248                              (match_operand:SI 3 "immediate_operand" "i")))]
1249   ""
1250   "*
1251 {
1252   operands[2] = GEN_INT ((INTVAL (operands[2]) - 4) / 4);
1253   return \"calls %2,%1\";
1254 }")
1255
1256 (define_expand "call"
1257   [(call (match_operand:QI 0 "memory_operand" "")
1258       (match_operand:SI 1 "const_int_operand" ""))]
1259   ""
1260   "
1261 {
1262   /* Operand 1 is the number of bytes to be popped by DW_CFA_GNU_args_size
1263      during EH unwinding.  We must include the argument count pushed by
1264      the calls instruction.  */
1265   operands[1] = GEN_INT (INTVAL (operands[1]) + 4);
1266 }")
1267
1268 (define_insn "*call"
1269    [(call (match_operand:QI 0 "memory_operand" "m")
1270        (match_operand:SI 1 "const_int_operand" ""))]
1271   ""
1272   "calls $0,%0")
1273
1274 (define_expand "call_value"
1275   [(set (match_operand 0 "" "")
1276       (call (match_operand:QI 1 "memory_operand" "")
1277             (match_operand:SI 2 "const_int_operand" "")))]
1278   ""
1279   "
1280 {
1281   /* Operand 2 is the number of bytes to be popped by DW_CFA_GNU_args_size
1282      during EH unwinding.  We must include the argument count pushed by
1283      the calls instruction.  */
1284   operands[2] = GEN_INT (INTVAL (operands[2]) + 4);
1285 }")
1286
1287 (define_insn "*call_value"
1288   [(set (match_operand 0 "" "")
1289         (call (match_operand:QI 1 "memory_operand" "m")
1290               (match_operand:SI 2 "const_int_operand" "")))]
1291   ""
1292   "calls $0,%1")
1293
1294 ;; Call subroutine returning any type.
1295
1296 (define_expand "untyped_call"
1297   [(parallel [(call (match_operand 0 "" "")
1298                   (const_int 0))
1299             (match_operand 1 "" "")
1300             (match_operand 2 "" "")])]
1301   ""
1302   "
1303 {
1304   int i;
1305
1306   emit_call_insn (gen_call_pop (operands[0], const0_rtx, NULL, const0_rtx));
1307
1308   for (i = 0; i < XVECLEN (operands[2], 0); i++)
1309     {
1310       rtx set = XVECEXP (operands[2], 0, i);
1311       emit_move_insn (SET_DEST (set), SET_SRC (set));
1312     }
1313
1314   /* The optimizer does not know that the call sets the function value
1315      registers we stored in the result block.  We avoid problems by
1316      claiming that all hard registers are used and clobbered at this
1317      point.  */
1318   emit_insn (gen_blockage ());
1319
1320   DONE;
1321 }")
1322
1323 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
1324 ;; all of memory.  This blocks insns from being moved across this point.
1325
1326 (define_insn "blockage"
1327   [(unspec_volatile [(const_int 0)] VUNSPEC_BLOCKAGE)]
1328   ""
1329   "")
1330
1331 (define_insn "return"
1332   [(return)]
1333   ""
1334   "ret")
1335
1336 (define_expand "epilogue"
1337   [(return)]
1338   ""
1339   "
1340 {
1341   emit_jump_insn (gen_return ());
1342   DONE;
1343 }")
1344
1345 (define_insn "nop"
1346   [(const_int 0)]
1347   ""
1348   "nop")
1349
1350 ;; This had a wider constraint once, and it had trouble.
1351 ;; If you are tempted to try `g', please don't--it's not worth
1352 ;; the risk we will reopen the same bug.
1353 (define_insn "indirect_jump"
1354   [(set (pc) (match_operand:SI 0 "register_operand" "r"))]
1355   ""
1356   "jmp (%0)")
1357
1358 ;; This is here to accept 5 arguments (as passed by expand_end_case)
1359 ;; and pass the first 4 along to the casesi1 pattern that really does
1360 ;; the actual casesi work.  We emit a jump here to the default label
1361 ;; _before_ the casesi so that we can be sure that the casesi never
1362 ;; drops through.
1363 ;; This is suboptimal perhaps, but so is much of the rest of this
1364 ;; machine description.  For what it's worth, HPPA uses the same trick.
1365 ;;
1366 ;; operand 0 is index
1367 ;; operand 1 is the minimum bound (a const_int)
1368 ;; operand 2 is the maximum bound - minimum bound + 1 (also a const_int)
1369 ;; operand 3 is CODE_LABEL for the table;
1370 ;; operand 4 is the CODE_LABEL to go to if index out of range (ie. default).
1371 ;;
1372 ;; We emit:
1373 ;;      i = index - minimum_bound
1374 ;;      if (i > (maximum_bound - minimum_bound + 1) goto default;
1375 ;;      casesi (i, 0, table);
1376 ;;
1377 (define_expand "casesi"
1378   [(match_operand:SI 0 "general_operand" "")
1379    (match_operand:SI 1 "general_operand" "")
1380    (match_operand:SI 2 "general_operand" "")
1381    (match_operand 3 "" "")
1382    (match_operand 4 "" "")]
1383   ""
1384 {
1385   /* i = index - minimum_bound;
1386      But only if the lower bound is not already zero.  */
1387   if (operands[1] != const0_rtx)
1388     {
1389       rtx index = gen_reg_rtx (SImode);
1390       emit_insn (gen_addsi3 (index,
1391                              operands[0],
1392                              GEN_INT (-INTVAL (operands[1]))));
1393       operands[0] = index;
1394     }
1395
1396   /* if (i > (maximum_bound - minimum_bound + 1) goto default;  */
1397   emit_insn (gen_cmpsi (operands[0], operands[2]));
1398   emit_jump_insn (gen_bgtu (operands[4]));
1399
1400   /* casesi (i, 0, table);  */
1401   emit_jump_insn (gen_casesi1 (operands[0], operands[2], operands[3]));
1402   DONE;
1403 })
1404
1405 ;; This insn is a bit of a lier.  It actually falls through if no case
1406 ;; matches.  But, we prevent that from ever happening by emitting a jump
1407 ;; before this, see the define_expand above.
1408 (define_insn "casesi1"
1409   [(match_operand:SI 1 "const_int_operand" "n")
1410    (set (pc)
1411         (plus:SI (sign_extend:SI
1412                   (mem:HI (plus:SI (mult:SI (match_operand:SI 0 "general_operand" "g")
1413                                             (const_int 2))
1414                           (pc))))
1415                  (label_ref:SI (match_operand 2 "" ""))))]
1416   ""
1417   "casel %0,$0,%1")
1418 \f
1419 ;;- load or push effective address
1420 ;; These come after the move and add/sub patterns
1421 ;; because we don't want pushl $1 turned into pushad 1.
1422 ;; or addl3 r1,r2,r3 turned into movab 0(r1)[r2],r3.
1423
1424 ;; It does not work to use constraints to distinguish pushes from moves,
1425 ;; because < matches any autodecrement, not just a push.
1426
1427 (define_insn ""
1428   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1429         (match_operand:QI 1 "address_operand" "p"))]
1430   ""
1431   "*
1432 {
1433   if (push_operand (operands[0], SImode))
1434     return \"pushab %a1\";
1435   else
1436     return \"movab %a1,%0\";
1437 }")
1438
1439 (define_insn ""
1440   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1441         (match_operand:HI 1 "address_operand" "p"))]
1442   ""
1443   "*
1444 {
1445   if (push_operand (operands[0], SImode))
1446     return \"pushaw %a1\";
1447   else
1448     return \"movaw %a1,%0\";
1449 }")
1450
1451 (define_insn ""
1452   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1453         (match_operand:SI 1 "address_operand" "p"))]
1454   ""
1455   "*
1456 {
1457   if (push_operand (operands[0], SImode))
1458     return \"pushal %a1\";
1459   else
1460     return \"moval %a1,%0\";
1461 }")
1462
1463 (define_insn ""
1464   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1465         (match_operand:DI 1 "address_operand" "p"))]
1466   ""
1467   "*
1468 {
1469   if (push_operand (operands[0], SImode))
1470     return \"pushaq %a1\";
1471   else
1472     return \"movaq %a1,%0\";
1473 }")
1474
1475 (define_insn ""
1476   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1477         (match_operand:SF 1 "address_operand" "p"))]
1478   ""
1479   "*
1480 {
1481   if (push_operand (operands[0], SImode))
1482     return \"pushaf %a1\";
1483   else
1484     return \"movaf %a1,%0\";
1485 }")
1486
1487 (define_insn ""
1488   [(set (match_operand:SI 0 "nonimmediate_operand" "=g")
1489         (match_operand:DF 1 "address_operand" "p"))]
1490   ""
1491   "*
1492 {
1493   if (push_operand (operands[0], SImode))
1494     return \"pushad %a1\";
1495   else
1496     return \"movad %a1,%0\";
1497 }")
1498 \f
1499 ;; These used to be peepholes, but it is more straightforward to do them
1500 ;; as single insns.  However, we must force the output to be a register
1501 ;; if it is not an offsettable address so that we know that we can assign
1502 ;; to it twice.
1503
1504 ;; If we had a good way of evaluating the relative costs, these could be
1505 ;; machine-independent.
1506
1507 ;; Optimize   extzv ...,z;    andl2 ...,z
1508 ;; or         ashl ...,z;     andl2 ...,z
1509 ;; with other operands constant.  This is what the combiner converts the
1510 ;; above sequences to before attempting to recognize the new insn.
1511
1512 (define_insn ""
1513   [(set (match_operand:SI 0 "nonimmediate_operand" "=ro")
1514         (and:SI (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
1515                              (match_operand:QI 2 "const_int_operand" "n"))
1516                 (match_operand:SI 3 "const_int_operand" "n")))]
1517   "(INTVAL (operands[3]) & ~((1 << (32 - INTVAL (operands[2]))) - 1)) == 0"
1518   "*
1519 {
1520   unsigned long mask1 = INTVAL (operands[3]);
1521   unsigned long mask2 = (1 << (32 - INTVAL (operands[2]))) - 1;
1522
1523   if ((mask1 & mask2) != mask1)
1524     operands[3] = GEN_INT (mask1 & mask2);
1525
1526   return \"rotl %R2,%1,%0\;bicl2 %N3,%0\";
1527 }")
1528
1529 ;; left-shift and mask
1530 ;; The only case where `ashl' is better is if the mask only turns off
1531 ;; bits that the ashl would anyways, in which case it should have been
1532 ;; optimized away.
1533
1534 (define_insn ""
1535   [(set (match_operand:SI 0 "nonimmediate_operand" "=ro")
1536         (and:SI (ashift:SI (match_operand:SI 1 "general_operand" "g")
1537                            (match_operand:QI 2 "const_int_operand" "n"))
1538                 (match_operand:SI 3 "const_int_operand" "n")))]
1539   ""
1540   "*
1541 {
1542   operands[3]
1543     = GEN_INT (INTVAL (operands[3]) & ~((1 << INTVAL (operands[2])) - 1));
1544   return \"rotl %2,%1,%0\;bicl2 %N3,%0\";
1545 }")
1546
1547 ;; Instruction sequence to sync the VAX instruction stream.
1548 (define_insn "sync_istream"
1549   [(unspec_volatile [(const_int 0)] VUNSPEC_SYNC_ISTREAM)]
1550   ""
1551   "movpsl -(%|sp)\;pushal 1(%|pc)\;rei")