gcc/config/1750a/1750a.md

   1 ;;- Machine description for GNU compiler
   2 ;;- MIL-STD-1750A version.
   3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   4 ;; Contributed by O.M.Kellogg, DASA (oliver.kellogg@space.otn.dasa.de).
   5
   6 ;; This file is part of GNU CC.
   7
   8 ;; GNU CC is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation; either version 1, or (at your option)
  11 ;; any later version.
  12
  13 ;; GNU CC is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with GNU CC; see the file COPYING.  If not, write to
  20 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
  21 ;; Boston, MA 02111-1307, USA.
  22
  23
  24 ;;- instruction definitions
  25
  26 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  27
  28 ;;- When naming insn's (operand 0 of define_insn) be careful about using
  29 ;;- names from other targets machine descriptions.
  30
  31 ;; MIL-STD-1750 specific remarks:
  32 ;;
  33 ;; 1) BITS_PER_UNIT = 16
  34 ;;
  35 ;; 2) GCC   to    MIL-STD-1750       data type mappings:
  36 ;;    QImode => single integer (16 bits or 1 reg).
  37 ;;    HImode => double integer (32 bits or 2 regs).
  38 ;;    HFmode => single precision float (32 bits or 2 regs).
  39 ;;    TQFmode => extended precision float (48 bits or 3 regs).
  40 ;;
  41 ;; 3) Immediate integer operands Constraints:
  42 ;;    'I'  1 .. 16
  43 ;;    'J' -1 ..-16
  44 ;;    'K'  0 .. 15
  45 ;;    'L'  0 .. 255
  46 ;;    'M' -32768 .. 32767
  47 ;;    'O' => 0  (for optimizations and GCC quirks)
  48 ;;
  49 ;; Further notes:
  50 ;;-  Assembly output ending in ".M" are macros in file M1750.INC
  51
  52
  53 ;; stackpush
  54 (define_insn ""
  55   [(set (match_operand:QI 0 "push_operand" "=<")
  56         (match_operand:QI 1 "general_operand" "r"))]
  57   ""
  58   "pshm r%1,r%1")
  59
  60 (define_insn ""
  61   [(set (match_operand:HI 0 "push_operand" "=<")
  62         (match_operand:HI 1 "general_operand" "r"))]
  63   ""
  64   "pshm r%1,r%d1")
  65
  66 (define_insn ""
  67   [(set (match_operand:HF 0 "push_operand" "=<")
  68         (match_operand:HF 1 "general_operand" "r"))]
  69   ""
  70   "pshm r%1,r%d1")
  71
  72 (define_insn ""
  73   [(set (match_operand:TQF 0 "push_operand" "=<")
  74         (match_operand:TQF 1 "general_operand" "r"))]
  75   ""
  76   "pshm r%1,r%t1")
  77
  78 ;; stackpop
  79 (define_insn ""
  80   [(set (match_operand:QI 0 "general_operand" "=r")
  81         (match_operand:QI 1 "push_operand" ">"))]
  82   ""
  83   "popm r%1,r%1")
  84
  85 (define_insn ""
  86   [(set (match_operand:HI 0 "general_operand" "=r")
  87         (match_operand:HI 1 "push_operand" ">"))]
  88   ""
  89   "popm r%1,r%d1")
  90
  91 (define_insn ""
  92   [(set (match_operand:HF 0 "general_operand" "=r")
  93         (match_operand:HF 1 "push_operand" ">"))]
  94   ""
  95   "popm r%1,r%d1")
  96
  97 (define_insn ""
  98   [(set (match_operand:TQF 0 "general_operand" "=r")
  99         (match_operand:TQF 1 "push_operand" ">"))]
 100   ""
 101   "popm r%1,r%t1")
 102
 103
 104 ;; Test operations.
 105
 106 (define_insn "tstqi"
 107   [(set (cc0)
 108         (match_operand:QI 0 "register_operand" "r"))]
 109   ""
 110   "lr r%0,r%0   ; from tstqi")
 111
 112 (define_insn "tsthi"
 113   [(set (cc0)
 114         (match_operand:HI 0 "register_operand" "r"))]
 115   ""
 116   "dlr r%0,r%0   ; from tsthi")
 117
 118 ; With 1750A floats, testing the most significant word suffices.
 119
 120 (define_insn "tsthf"
 121   [(set (cc0)
 122         (match_operand:HF 0 "register_operand" "r"))]
 123   ""
 124   "lr r%0,r%0   ; tsthf")
 125
 126 (define_insn "tsttqf"
 127   [(set (cc0)
 128         (match_operand:TQF 0 "register_operand" "r"))]
 129   ""
 130   "lr r%0,r%0   ; tsttqf")
 131
 132
 133 ;; block move.
 134
 135 (define_insn "movstrqi"
 136   [(set (match_operand:BLK 0 "mov_memory_operand" "m")
 137         (match_operand:BLK 1 "mov_memory_operand" "m"))
 138    (use (match_operand:QI 2 "general_operand" "r"))
 139    (match_operand 3 "" "")
 140    (clobber (match_dup 0))
 141    (clobber (match_dup 1))
 142    (clobber (match_dup 2))]
 143   ""
 144   "*
 145    {
 146      rtx regops[3];
 147
 148      regops[0] = XEXP (operands[0], 0);
 149      regops[1] = XEXP (operands[1], 0);
 150      regops[2] = operands[2];
 151
 152      return movcnt_regno_adjust (regops);
 153    } ")
 154
 155
 156 ;; compare instructions.
 157
 158 (define_insn "cmpqi"
 159   [(set (cc0)
 160         (compare (match_operand:QI 0 "register_operand" "r,r,r,r,r")
 161                  (match_operand:QI 1 "general_operand"  "I,J,i,r,m")))]
 162   ""
 163   "*
 164    {
 165      if (next_cc_user_is_unsigned (insn))
 166        switch (which_alternative)
 167          {
 168          case 0:
 169          case 1:
 170          case 2:
 171            return \"ucim.m %0,%1\";
 172          case 3:
 173            return \"ucr.m %0,%1\";
 174          case 4:
 175            return \"uc.m %0,%1\";
 176          }
 177      else
 178        switch (which_alternative)
 179          {
 180          case 0:
 181            return \"cisp r%0,%1\";
 182          case 1:
 183            return \"cisn r%0,%J1\";
 184          case 2:
 185            return \"cim  r%0,%1\";
 186          case 3:
 187            return \"cr   r%0,r%1\";
 188          case 4:
 189            return \"c    r%0,%1\";
 190          }
 191    } ")
 192
 193 (define_insn "cmphi"
 194   [(set (cc0)
 195         (compare (match_operand:HI 0 "general_operand" "r,r")
 196                  (match_operand:HI 1 "general_operand" "r,m")))]
 197   ""
 198   "*
 199    {
 200      if (next_cc_user_is_unsigned (insn))
 201        {
 202          if (which_alternative == 0)
 203            return \"ducr.m %0,%1\";
 204          return \"duc.m %0,%1\";
 205        }
 206      else
 207        {
 208          if (which_alternative == 0)
 209            return \"dcr r%0,r%1\";
 210          return \"dc  r%0,%1\";
 211        }
 212    } ")
 213
 214 (define_insn "cmphf"
 215  [(set (cc0)
 216        (compare (match_operand:HF 0 "general_operand" "r,r")
 217                 (match_operand:HF 1 "general_operand" "r,m")))]
 218  ""
 219  "@
 220    fcr r%0,r%1
 221    fc  r%0,%1 ")
 222
 223 (define_insn "cmptqf"
 224   [(set (cc0)
 225         (compare (match_operand:TQF 0 "general_operand" "r,r")
 226                  (match_operand:TQF 1 "general_operand" "r,m")))]
 227   ""
 228   "@
 229     efcr r%0,r%1
 230     efc  r%0,%1 ")
 231
 232
 233 ;; truncation instructions
 234 ;;- 1750: any needed?
 235
 236 (define_insn "trunchiqi2"
 237   [(set (match_operand:QI 0 "register_operand" "=r")
 238         (truncate:QI (match_operand:HI 1 "register_operand" "r")))]
 239   ""
 240   "lr  r%0,r%d1")
 241
 242
 243 ;; zero extension instructions: not defined, GCC can synthesize
 244
 245 ;; sign extension instructions
 246
 247 (define_insn "extendqihi2"
 248   [(set (match_operand:HI 0 "register_operand" "=r,r")
 249         (sign_extend:HI (match_operand:QI 1 "general_operand" "r,m")) )]
 250   ""
 251   "*
 252     if (which_alternative == 0)
 253       {
 254         if (REGNO (operands [0]) != REGNO (operands [1]))
 255           output_asm_insn (\"lr r%0,r%1\", operands);
 256       }
 257     else
 258       output_asm_insn (\"l  r%0,%1\", operands);
 259     return \"dsra r%0,16  ;extendqihi2\";
 260   ")
 261
 262
 263 ;; Conversions between float and double.
 264
 265 ; 1750 HF-to-TQF extend: just append 16 bits (least signif.) with all bits zero
 266 (define_insn "extendhftqf2"
 267   [(set (match_operand:TQF 0 "register_operand" "=r,r")
 268         (float_extend:TQF (match_operand:HF 1 "general_operand" "r,m")))]
 269   ""
 270   "*
 271     output_asm_insn(\"xorr r%t0,r%t0   ;extendhftqf2\", operands);
 272     if (which_alternative == 0)
 273       {
 274         if (REGNO (operands[1]) != REGNO (operands[0]))
 275           return \"dlr r%0,r%1\";
 276         else
 277           return \";\";
 278       }
 279     else
 280       return \"dl  r%0,%1\";
 281    ")
 282
 283 ; 1750 TQF-to-HF truncate is a no-op: just leave away the least signif. 16 bits
 284 (define_insn "trunctqfhf2"
 285   [(set (match_operand:HF 0 "register_operand" "=r,r")
 286         (float_truncate:HF
 287           (match_operand:TQF 1 "general_operand" "r,m")))]
 288   ""
 289   "@
 290      dlr r%0,r%1  ;trunctqfhf2
 291      dl  r%0,%1   ;trunctqfhf2 ")
 292
 293
 294 ;; Conversion between fixed point and floating point.
 295
 296 (define_insn "floatqihf2"
 297   [(set           (match_operand:HF 0 "register_operand" "=r")
 298         (float:HF (match_operand:QI 1 "register_operand" "r")))]
 299   ""
 300   "flt r%0,r%1")
 301
 302 (define_insn "floathitqf2"
 303   [(set           (match_operand:TQF 0 "register_operand" "=r")
 304         (float:TQF (match_operand:HI 1 "register_operand" "r")))]
 305   ""
 306   "eflt r%0,r%1")
 307
 308
 309 ;; Convert floats to ints
 310
 311 (define_insn "fix_trunchfqi2"
 312   [(set                 (match_operand:QI 0 "register_operand" "=r")
 313         (fix:QI (fix:HF (match_operand:HF 1 "register_operand" "r"))))]
 314   ""
 315   "fix r%0,r%1")
 316
 317 (define_insn "fix_trunctqfhi2"
 318   [(set                 (match_operand:HI 0 "register_operand" "=r")
 319         (fix:HI (fix:TQF (match_operand:TQF 1 "register_operand" "r"))))]
 320   ""
 321   "efix r%0,r%1")
 322
 323
 324 ;; Move instructions
 325
 326 ;; We can't deal with normal byte-size characters, only with WIDE characters!
 327 ;; This may appear as a serious restriction, but it also opens the doors
 328 ;; for ISO 10646  :-)
 329
 330 ;; 16-bit moves
 331
 332 ; memory indirect to reg
 333 (define_insn ""
 334   [(set (match_operand:QI 0 "register_operand" "=r")
 335         (mem:QI (match_operand 1 "memory_operand"  "m")))]
 336   ""
 337   "li   r%0,%1")
 338
 339 ; reg/const to memory indirect
 340 (define_insn ""
 341   [(set (mem:QI (match_operand 0 "memory_operand" "=m,m"))
 342         (match_operand:QI 1 "nonmemory_operand"  "r,K"))]
 343   ""
 344   "@
 345      sti  r%1,%0
 346      stci %1,%0")
 347
 348 ; general case
 349 (define_insn "movqi"
 350   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,r,m,m")
 351         (match_operand:QI 1 "general_operand"  "O,I,J,i,r,m,r,K"))]
 352   ""
 353   "@
 354      xorr r%0,r%0
 355      lisp r%0,%1
 356      lisn r%0,%J1
 357      lim  r%0,%1
 358      lr   r%0,r%1
 359      l    r%0,%1
 360      st   r%1,%0
 361      stc  %1,%0   ")
 362
 363 ;; 32-bit moves
 364
 365 ; memory indirect to reg
 366 (define_insn ""
 367   [(set (match_operand:HI 0 "register_operand" "=r")
 368         (mem:HI (match_operand 1 "memory_operand"  "m")))]
 369   ""
 370   "dli  r%0,%1")
 371
 372 ; reg to memory indirect
 373 (define_insn ""
 374   [(set (mem:HI (match_operand 0 "memory_operand" "=m"))
 375         (match_operand:HI 1 "register_operand"  "r"))]
 376   ""
 377   "dsti r%1,%0")
 378
 379 ; general case
 380 (define_insn ""
 381   [(set (match_operand:HI 0 "general_operand" "=r,r,r,r,r,m,m")
 382         (match_operand:HI 1 "general_operand"  "O,I,J,r,m,r,K"))]
 383   ""
 384   "@
 385     xorr r%0,r%0\;xorr r%d0,r%d0
 386     xorr r%0,r%0\;lisp r%d0,%1
 387     lisn r%0,1  \;lisn r%d0,%J1
 388     dlr  r%0,r%1
 389     dl   r%0,%1
 390     dst  r%1,%0
 391     stc  0,%0   \;stc  %1,%A0 ")
 392
 393 (define_expand "movhi"
 394   [(set (match_operand:HI 0 "general_operand" "=g")
 395         (match_operand:HI 1 "general_operand"  "g"))]
 396   ""
 397   "
 398    {
 399      rtx op1 = operands[1];
 400      if (GET_CODE (operands[0]) == MEM)
 401        {
 402          if (GET_CODE (op1) == MEM
 403              || (GET_CODE (op1) == CONST_INT
 404                  && (INTVAL (op1) < 0 || INTVAL (op1) > 15)))
 405            operands[1] = force_reg (HImode, operands[1]);
 406        }
 407      else if (GET_CODE (op1) == CONST_INT
 408               && (INTVAL (op1) < -16 || INTVAL (op1) > 16))
 409        operands[1] = force_const_mem (HImode, operands[1]);
 410    }")
 411
 412
 413 ;; Single-Float moves
 414
 415 (define_insn ""
 416   [(set (match_operand:HF 0 "general_operand" "=r,r,m,m")
 417         (match_operand:HF 1 "general_operand"  "r,m,r,G"))]
 418   ""
 419   "@
 420     dlr  r%0,r%1
 421     dl   r%0,%1
 422     dst  r%1,%0
 423     stc  0,%0   \;stc 0,%A0 ")
 424
 425 (define_expand "movhf"
 426   [(set (match_operand:HF 0 "general_operand" "")
 427         (match_operand:HF 1 "general_operand" ""))]
 428   ""
 429   "
 430    {
 431      enum rtx_code op1code = GET_CODE (operands[1]);
 432      if (GET_CODE (operands[0]) == MEM)
 433        {
 434          if (op1code == MEM || (op1code == CONST_DOUBLE
 435              && !rtx_equal_p (operands[1], CONST0_RTX (HFmode))))
 436            operands[1] = force_reg (HFmode, operands[1]);
 437        }
 438      else if (op1code == CONST_DOUBLE)
 439        operands[1] = force_const_mem (HFmode, operands[1]);
 440    }")
 441
 442
 443 ;; Longfloat moves
 444
 445 (define_insn ""
 446   [(set (match_operand:TQF 0 "general_operand" "=r,r,m")
 447         (match_operand:TQF 1 "general_operand"  "r,m,r"))]
 448   ""
 449   "@
 450     eflr.m %0,%1
 451     efl  r%0,%1
 452     efst r%1,%0 ")
 453
 454 (define_expand "movtqf"
 455   [(set (match_operand:TQF 0 "general_operand" "")
 456         (match_operand:TQF 1 "general_operand" ""))]
 457   ""
 458   "
 459    {
 460      enum rtx_code op1code = GET_CODE (operands[1]);
 461      if (GET_CODE (operands[0]) == MEM)
 462        {
 463          if (op1code == MEM || op1code == CONST_DOUBLE)
 464            operands[1] = force_reg (TQFmode, operands[1]);
 465        }
 466      else if (op1code == CONST_DOUBLE)
 467        operands[1] = force_const_mem (TQFmode, operands[1]);
 468    }")
 469
 470
 471 ;; add instructions
 472
 473 ;; single integer
 474
 475 (define_insn "addqi3"
 476   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,m,m")
 477         (plus:QI (match_operand:QI 1 "general_operand" "%0,0,0,0,0,0,0")
 478                  (match_operand:QI 2 "general_operand"  "I,J,i,r,m,I,J")))]
 479   ""
 480   "*
 481     switch (which_alternative)
 482       {
 483         case 0:
 484           return \"aisp r%0,%2\";
 485         case 1:
 486           return \"sisp r%0,%J2\";
 487         case 2:
 488           if (INTVAL(operands[2]) < 0)
 489             return \"sim r%0,%J2\";
 490           else
 491             return \"aim r%0,%2\";
 492         case 3:
 493           return \"ar r%0,r%2\";
 494         case 4:
 495           return \"a r%0,%2\";
 496         case 5:
 497           return \"incm %2,%0\";
 498         case 6:
 499           return \"decm %J2,%0\";
 500       } ")
 501
 502 ;; double integer
 503 (define_insn "addhi3"
 504   [(set (match_operand:HI 0 "register_operand" "=r,r")
 505         (plus:HI (match_operand:HI 1 "register_operand" "%0,0")
 506                  (match_operand:HI 2 "general_operand" "r,m")))]
 507   ""
 508   "@
 509     dar r%0,r%2
 510     da  r%0,%2 ")
 511
 512 (define_insn "addhf3"
 513   [(set (match_operand:HF 0 "register_operand" "=r,r")
 514         (plus:HF (match_operand:HF 1 "register_operand" "%0,0")
 515                  (match_operand:HF 2 "general_operand" "r,m")))]
 516   ""
 517   "@
 518     far r%0,r%2
 519     fa  r%0,%2 ")
 520
 521 (define_insn "addtqf3"
 522   [(set (match_operand:TQF 0 "register_operand" "=r,r")
 523         (plus:TQF (match_operand:TQF 1 "register_operand" "%0,0")
 524                  (match_operand:TQF 2 "general_operand" "r,m")))]
 525   ""
 526   "@
 527     efar r%0,r%2
 528     efa  r%0,%2 ")
 529
 530
 531 ;; subtract instructions
 532
 533 ;; single integer
 534 (define_insn "subqi3"
 535   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,m")
 536         (minus:QI (match_operand:QI 1 "general_operand" "0,0,0,0,0")
 537                   (match_operand:QI 2 "general_operand"  "I,i,r,m,I")))]
 538   ""
 539   "@
 540     sisp r%0,%2
 541     sim  r%0,%2
 542     sr   r%0,r%2
 543     s    r%0,%2
 544     decm %2,%0 ")
 545
 546 ;; double integer
 547 (define_insn "subhi3"
 548   [(set (match_operand:HI 0 "register_operand" "=r,r")
 549         (minus:HI (match_operand:HI 1 "register_operand" "0,0")
 550                   (match_operand:HI 2 "general_operand" "r,m")))]
 551   ""
 552   "@
 553     dsr r%0,r%2
 554     ds  r%0,%2 ")
 555
 556 (define_insn "subhf3"
 557   [(set (match_operand:HF 0 "register_operand" "=r,r")
 558         (minus:HF (match_operand:HF 1 "register_operand" "0,0")
 559                   (match_operand:HF 2 "general_operand" "r,m")))]
 560   ""
 561   "@
 562     fsr r%0,r%2
 563     fs  r%0,%2 ")
 564
 565 (define_insn "subtqf3"
 566   [(set (match_operand:TQF 0 "register_operand" "=r,r")
 567         (minus:TQF (match_operand:TQF 1 "register_operand" "0,0")
 568                   (match_operand:TQF 2 "general_operand" "r,m")))]
 569   ""
 570   "@
 571     efsr r%0,r%2
 572     efs  r%0,%2 ")
 573
 574
 575 ;; multiply instructions
 576
 577 (define_insn "mulqi3"
 578   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
 579         (mult:QI (match_operand:QI 1 "register_operand" "%0,0,0,0,0")
 580                  (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))]
 581   ""
 582   "@
 583      misp r%0,%2
 584      misn r%0,%J2
 585      msim r%0,%2
 586      msr  r%0,r%2
 587      ms   r%0,%2  ")
 588
 589
 590 ; 32-bit product
 591 (define_insn "mulqihi3"
 592   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
 593     (mult:HI (sign_extend:HI (match_operand:QI 1 "register_operand" "%r,r,r"))
 594              (sign_extend:HI (match_operand:QI 2 "general_operand" "r,m,i"))))]
 595   ""
 596   "*
 597     if (REGNO (operands[1]) != REGNO (operands[0]))
 598       output_asm_insn (\"lr r%0,r%1\", operands);
 599
 600     switch (which_alternative)
 601       {
 602       case 0:
 603         return \"mr  r%0,r%2\";
 604       case 1:
 605         return \"m   r%0,%2\";
 606       case 2:
 607         return \"mim r%0,%2\";
 608       }
 609   ")
 610
 611
 612 (define_insn "mulhi3"
 613   [(set (match_operand:HI 0 "register_operand" "=r,r")
 614         (mult:HI (match_operand:HI 1 "register_operand" "%0,0")
 615                  (match_operand:HI 2 "general_operand" "r,m")))]
 616   ""
 617   "@
 618     dmr r%0,r%2
 619     dm  r%0,%2 ")
 620
 621 ; not available on 1750: "umulhi3","umulhisi3","umulsi3" (unsigned multiply's)
 622
 623 (define_insn "mulhf3"
 624   [(set (match_operand:HF 0 "register_operand" "=r,r")
 625         (mult:HF (match_operand:HF 1 "register_operand" "%0,0")
 626                  (match_operand:HF 2 "general_operand" "r,m")))]
 627   ""
 628   "@
 629     fmr r%0,r%2
 630     fm  r%0,%2 ")
 631
 632 (define_insn "multqf3"
 633   [(set (match_operand:TQF 0 "register_operand" "=r,r")
 634         (mult:TQF (match_operand:TQF 1 "register_operand" "%0,0")
 635                  (match_operand:TQF 2 "general_operand" "r,m")))]
 636   ""
 637   "@
 638     efmr r%0,r%2
 639     efm  r%0,%2 ")
 640
 641
 642 ;; divide instructions
 643 ;; The 1750 16bit integer division instructions deliver a 16-bit
 644 ;; quotient and a 16-bit remainder, where the remainder is in the next higher
 645 ;; register number above the quotient. For now, we haven't found a way
 646 ;; to give the reload pass knowledge of this property. So we make do with
 647 ;; whatever registers the allocator wants, and willy-nilly output a pair of
 648 ;; register-copy ops when needed. (See mod_regno_adjust() in file aux-output.c)
 649 ;; A comment in the description of `divmodM4' suggests that one leave the divM3
 650 ;; undefined when there is a divmodM4 available.
 651
 652 (define_insn "divmodqi4"
 653   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
 654         (div:QI (match_operand:QI 1 "register_operand" "0,0,0,0,0")
 655                 (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))
 656    (set (match_operand:QI 3 "register_operand" "=r,r,r,r,r")
 657         (mod:QI (match_dup 1) (match_dup 2)))]
 658   ""
 659   "*
 660    {
 661      char *istr;
 662      switch(which_alternative)
 663        {
 664        case 0:
 665          istr = \"disp\";
 666          break;
 667        case 1:
 668          {
 669            rtx new_opnds[4];
 670            new_opnds[0] = operands[0];
 671            new_opnds[1] = operands[1];
 672            new_opnds[2] = gen_rtx (CONST_INT, VOIDmode, -INTVAL(operands[2]));
 673            new_opnds[3] = operands[3];
 674            istr = \"disn\";
 675            return mod_regno_adjust (istr, new_opnds);
 676          }
 677          break;
 678        case 2:
 679          istr = \"dvim\";
 680          break;
 681        case 3:
 682          istr = \"dvr \";
 683          break;
 684        case 4:
 685          istr = \"dv  \";
 686          break;
 687       }
 688       return mod_regno_adjust (istr, operands);
 689      }")
 690
 691 ;; Division for other types is straightforward.
 692
 693 (define_insn "divhi3"
 694   [(set (match_operand:HI 0 "register_operand" "=r,r")
 695         (div:HI (match_operand:HI 1 "register_operand" "0,0")
 696                 (match_operand:HI 2 "general_operand" "r,m")))]
 697   ""
 698   "@
 699     ddr r%0,r%2
 700     dd  r%0,%2 ")
 701
 702 (define_insn "divhf3"
 703   [(set (match_operand:HF 0 "register_operand" "=r,r")
 704         (div:HF (match_operand:HF 1 "register_operand" "0,0")
 705                 (match_operand:HF 2 "general_operand" "r,m")))]
 706   ""
 707   "@
 708     fdr r%0,r%2
 709     fd  r%0,%2 ")
 710
 711 (define_insn "divtqf3"
 712   [(set (match_operand:TQF 0 "register_operand" "=r,r")
 713         (div:TQF (match_operand:TQF 1 "register_operand" "0,0")
 714                 (match_operand:TQF 2 "general_operand" "r,m")))]
 715   ""
 716   "@
 717     efdr r%0,r%2
 718     efd  r%0,%2 ")
 719
 720
 721 ;; Other arithmetic instructions:
 722
 723 ;; Absolute value
 724
 725 (define_insn "absqi2"
 726   [(set (match_operand:QI 0 "register_operand" "=r")
 727         (abs:QI (match_operand:QI 1 "register_operand" "r")))]
 728   ""
 729   "abs r%0,r%1")
 730
 731 (define_insn "abshi2"
 732   [(set (match_operand:HI 0 "register_operand" "=r")
 733         (abs:HI (match_operand:HI 1 "register_operand" "r")))]
 734   ""
 735   "dabs r%0,r%1")
 736
 737 (define_insn "abshf2"
 738   [(set (match_operand:HF 0 "register_operand" "=r")
 739         (abs:HF (match_operand:HF 1 "register_operand" "r")))]
 740   ""
 741   "fabs r%0,r%1")
 742
 743
 744 ;; Negation
 745
 746 (define_insn "negqi2"
 747   [(set (match_operand:QI 0 "register_operand" "=r")
 748         (neg:QI (match_operand:QI 1 "register_operand" "r")))]
 749   ""
 750   "neg r%0,r%1")
 751
 752 (define_insn "neghi2"
 753   [(set (match_operand:HI 0 "register_operand" "=r")
 754         (neg:HI (match_operand:HI 1 "register_operand" "r")))]
 755   ""
 756   "dneg r%0,r%1")
 757
 758 (define_insn "neghf2"
 759   [(set (match_operand:HF 0 "register_operand" "=r")
 760         (neg:HF (match_operand:HF 1 "register_operand" "r")))]
 761   ""
 762   "fneg r%0,r%1")
 763
 764 ; The 1750A does not have an extended float negate instruction, so simulate.
 765 (define_expand "negtqf2"
 766   [(set (match_operand:TQF 0 "register_operand" "=&r")
 767         (neg:TQF (match_operand:TQF 1 "register_operand" "r")))]
 768   ""
 769   "
 770    emit_insn(gen_rtx(SET,VOIDmode,operands[0],CONST0_RTX(TQFmode)));
 771    emit_insn(gen_rtx(SET,VOIDmode,operands[0],
 772              gen_rtx(MINUS,TQFmode,operands[0],operands[1])));
 773    DONE;
 774   ")
 775
 776
 777 ;; bit-logical instructions
 778
 779 ;; Set Bit
 780 (define_insn ""
 781   [(set (match_operand:QI 0 "general_operand" "=r,m")
 782         (ior:QI  (match_operand:QI 1 "general_operand" "0,0")
 783                  (match_operand:QI 2 "const_int_operand" "i,i")))]
 784   "one_bit_set_p (INTVAL (operands [2]))"
 785   "@
 786     sbr    %b2,r%0
 787     sb     %b2,%0")
 788
 789 ;; Reset Bit
 790 (define_insn ""
 791   [(set (match_operand:QI 0 "general_operand" "=r,m")
 792         (and:QI  (match_operand:QI 1 "general_operand" "0,0")
 793                  (match_operand:QI 2 "const_int_operand" "i,i")))]
 794   "one_bit_set_p ((~INTVAL (operands [2])) & 0xffff)"
 795   "@
 796     rbr    %B2,r%0
 797     rb     %B2,%0")
 798
 799 ;; Set Variable Bit
 800 (define_insn ""
 801   [(set (match_operand:QI 0 "register_operand" "=r")
 802         (ior:QI  (match_operand:QI 1 "register_operand" "0")
 803                  (lshiftrt:QI (const_int 0x8000)
 804                       (match_operand:QI 2 "register_operand" "r"))))]
 805   ""
 806   "svbr   r%2,%r0")
 807
 808 ;; Reset Variable Bit
 809 (define_insn ""
 810   [(set (match_operand:QI 0 "general_operand" "=r")
 811         (and:QI  (match_operand:QI 1 "general_operand" "0")
 812             (not:QI (lshiftrt:QI (const_int 0x8000)
 813                         (match_operand:QI 2 "register_operand" "r")))))]
 814   ""
 815   "rvbr   r%2,%r0")
 816
 817
 818 ;; AND
 819
 820 (define_insn "andqi3"
 821   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
 822         (and:QI (match_operand:QI 1 "general_operand" "%0,0,0")
 823                 (match_operand:QI 2 "general_operand" "M,r,m")))]
 824   ""
 825   "@
 826     andm r%0,%2
 827     andr r%0,r%2
 828     and  r%0,%2 ")
 829
 830 ; This sets incorrect condition codes. See notice_update_cc()
 831 (define_insn "andhi3"
 832   [(set (match_operand:HI 0 "register_operand" "=r")
 833         (and:HI (match_operand:HI 1 "register_operand" "%0")
 834                 (match_operand:HI 2 "register_operand" "r")))]
 835   ""
 836   "danr.m %0,%2")
 837
 838 ;; OR
 839
 840 (define_insn "iorqi3"
 841   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
 842         (ior:QI  (match_operand:QI 1 "general_operand" "%0,0,0")
 843                  (match_operand:QI 2 "general_operand" "M,r,m")))]
 844   ""
 845   "@
 846     orim r%0,%2
 847     orr  r%0,r%2
 848     or   r%0,%2 ")
 849
 850 ; This sets incorrect condition codes. See notice_update_cc()
 851 (define_insn "iorhi3"
 852   [(set (match_operand:HI 0 "register_operand" "=r")
 853         (ior:HI (match_operand:HI 1 "register_operand" "%0")
 854                 (match_operand:HI 2 "register_operand" "r")))]
 855   ""
 856   "dorr.m %0,%2")
 857
 858 ;; XOR
 859
 860 (define_insn "xorqi3"
 861   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
 862         (xor:QI (match_operand:QI 1 "register_operand" "%0,0,0")
 863                 (match_operand:QI 2 "general_operand"  "M,r,m")))]
 864   ""
 865   "@
 866     xorm r%0,%2
 867     xorr r%0,r%2
 868     xor  r%0,%2 ")
 869
 870 ; This sets incorrect condition codes. See notice_update_cc()
 871 (define_insn "xorhi3"
 872   [(set (match_operand:HI 0 "register_operand" "=r")
 873         (xor:HI (match_operand:HI 1 "register_operand" "%0")
 874                 (match_operand:HI 2 "register_operand" "r")))]
 875   ""
 876   "dxrr.m %0,%2")
 877
 878 ;; NAND
 879
 880 (define_insn ""
 881   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
 882         (ior:QI (not:QI (match_operand:QI 1 "register_operand" "%0,0,0"))
 883                 (not:QI (match_operand:QI 2 "general_operand" "M,r,m"))))]
 884   ""
 885   "@
 886     nim r%0,%2
 887     nr  r%0,r%2
 888     n   r%0,%2 ")
 889
 890 ; This sets incorrect condition codes. See notice_update_cc()
 891 (define_insn ""
 892   [(set (match_operand:HI 0 "register_operand" "=r")
 893         (ior:HI (not:HI (match_operand:HI 1 "register_operand" "%0"))
 894                 (not:HI (match_operand:HI 2 "register_operand" "r"))))]
 895   ""
 896   "dnr.m %0,%2")
 897
 898 ;; NOT
 899
 900 (define_insn "one_cmplqi2"
 901   [(set (match_operand:QI 0 "register_operand" "=r")
 902         (not:QI (match_operand:QI 1 "register_operand" "0")))]
 903   ""
 904   "nr r%0,r%0")
 905
 906 ; This sets incorrect condition codes. See notice_update_cc()
 907 (define_insn "one_cmplhi2"
 908   [(set (match_operand:HI 0 "register_operand" "=r")
 909         (not:HI (match_operand:HI 1 "register_operand" "0")))]
 910   ""
 911   "dnr.m %0,%0")
 912
 913
 914 ;; Shift instructions
 915
 916 ; (What to the 1750 is logical-shift-left, GCC likes to call "arithmetic")
 917 (define_insn "ashlqi3"
 918   [(set (match_operand:QI 0 "register_operand" "=r,r")
 919         (ashift:QI (match_operand:QI 1 "register_operand" "0,0")
 920                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
 921   ""
 922   "@
 923     sll r%0,%2
 924     slr r%0,r%2 ")
 925
 926 (define_insn "ashlhi3"
 927   [(set (match_operand:HI 0 "register_operand" "=r,r")
 928         (ashift:HI (match_operand:HI 1 "register_operand" "0,0")
 929                    (match_operand:QI 2 "nonmemory_operand" "L,r")))]
 930   ""                        ; the 'L' constraint is a slight imprecise...
 931   "*
 932     if (which_alternative == 1)
 933       return \"dslr r%0,r%2\";
 934     else if (INTVAL(operands[2]) <= 16)
 935       return \"dsll r%0,%2\";
 936     else
 937       {
 938         output_asm_insn (\"dsll r%0,16  ; ashlhi3 shiftcnt > 16\", operands);
 939         return \"sll r%0,%w2\";
 940       }
 941   ")
 942
 943
 944 ;; Right shift by a variable shiftcount works by negating the shift count,
 945 ;; then emitting a right shift with the shift count negated.  This means
 946 ;; that all actual shift counts in the RTL will be positive.  This
 947 ;; prevents converting shifts to ZERO_EXTRACTs with negative positions,
 948 ;; which isn't valid.
 949 (define_expand "lshrqi3"
 950   [(set (match_operand:QI 0 "register_operand" "=r")
 951         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
 952                      (match_operand:QI 2 "nonmemory_operand" "g")))]
 953   ""
 954   "
 955 {
 956   if (GET_CODE (operands[2]) != CONST_INT)
 957     operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
 958 }")
 959
 960 (define_insn ""
 961   [(set (match_operand:QI 0 "register_operand" "=r")
 962         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
 963                      (match_operand:QI 2 "immediate_operand" "I")))]
 964   ""
 965   "srl r%0,%2")
 966
 967 (define_insn ""
 968   [(set (match_operand:QI 0 "register_operand" "=r")
 969         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
 970                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
 971   ""
 972   "slr r%0,r%2 ")
 973
 974 ;; Same thing for HImode.
 975
 976 (define_expand "lshrhi3"
 977   [(set (match_operand:HI 0 "register_operand" "=r")
 978         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
 979                      (match_operand:QI 2 "nonmemory_operand" "g")))]
 980   ""
 981   "
 982   {
 983     if (GET_CODE (operands[2]) != CONST_INT)
 984       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
 985   }")
 986
 987 (define_insn ""
 988   [(set (match_operand:HI 0 "register_operand" "=r")
 989         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
 990                      (match_operand:QI 2 "immediate_operand" "L")))]
 991   ""
 992   "*
 993     if (INTVAL (operands[2]) <= 16)
 994       return \"dsrl r%0,%2\";
 995     output_asm_insn (\"dsrl r%0,16  ; lshrhi3 shiftcount > 16\", operands);
 996     return \"srl  r%d0,%w2\";
 997   ")
 998
 999 (define_insn ""
1000   [(set (match_operand:HI 0 "register_operand" "=r")
1001         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
1002                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
1003   ""
1004   "dslr r%0,r%2 ")
1005
1006 ;; Same applies for arithmetic shift right.
1007 (define_expand "ashrqi3"
1008   [(set (match_operand:QI 0 "register_operand" "=r")
1009         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
1010                      (match_operand:QI 2 "nonmemory_operand" "g")))]
1011   ""
1012   "
1013   {
1014     if (GET_CODE (operands[2]) != CONST_INT)
1015       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
1016   }")
1017
1018 (define_insn ""
1019   [(set (match_operand:QI 0 "register_operand" "=r")
1020         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
1021                      (match_operand:QI 2 "immediate_operand" "I")))]
1022   ""
1023   "sra r%0,%2")
1024
1025 (define_insn ""
1026   [(set (match_operand:QI 0 "register_operand" "=r")
1027         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
1028                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
1029   ""
1030   "sar r%0,r%2 ")
1031
1032 ;; HImode arithmetic shift right.
1033 (define_expand "ashrhi3"
1034   [(set (match_operand:HI 0 "register_operand" "=r")
1035         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
1036                      (match_operand:QI 2 "nonmemory_operand" "g")))]
1037   ""
1038   "
1039   {
1040     if (GET_CODE (operands[2]) != CONST_INT)
1041       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
1042   }")
1043
1044 (define_insn ""
1045   [(set (match_operand:HI 0 "register_operand" "=r")
1046         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
1047                      (match_operand:QI 2 "immediate_operand" "L")))]
1048   ""
1049   "*
1050     if (INTVAL (operands[2]) <= 16)
1051       return \"dsra r%0,%2\";
1052     output_asm_insn (\"dsra r%0,16  ; ashrhi3 shiftcount > 16\", operands);
1053     return \"sra  r%d0,%w2\";
1054   ")
1055
1056 (define_insn ""
1057   [(set (match_operand:HI 0 "register_operand" "=r")
1058         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
1059                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
1060   ""
1061   "dsar r%0,r%2 ")
1062
1063
1064 ;; rotate instructions
1065
1066 (define_insn "rotlqi3"
1067   [(set (match_operand:QI 0 "register_operand" "=r,r")
1068         (rotate:QI (match_operand:QI 1 "register_operand" "0,0")
1069                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
1070   ""
1071   "@
1072     slc r%0,%2
1073     scr r%0,r%2 ")
1074
1075 (define_insn "rotlhi3"
1076   [(set (match_operand:HI 0 "register_operand" "=r,r")
1077         (rotate:HI (match_operand:HI 1 "register_operand" "0,0")
1078                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
1079   ""
1080   "@
1081     dslc r%0,%2
1082     dscr r%0,r%2 ")
1083
1084 (define_insn "rotrqi3"
1085   [(set (match_operand:QI 0 "register_operand" "=r")
1086         (rotatert:QI (match_operand:QI 1 "register_operand" "0")
1087                      (match_operand:QI 2 "register_operand" "r")))]
1088   ""
1089   "neg r%2,r%2\;scr r%0,r%2 ")
1090
1091 (define_insn "rotrhi3"
1092   [(set (match_operand:HI 0 "register_operand" "=r")
1093         (rotatert:HI (match_operand:HI 1 "register_operand" "0")
1094                      (match_operand:QI 2 "nonmemory_operand" "r")))]
1095   ""
1096   "neg  r%2,r%2\;dscr r%0,r%2 ")
1097
1098
1099
1100 ;; Special cases of bit-field insns which we should
1101 ;; recognize in preference to the general case.
1102 ;; These handle aligned 8-bit and 16-bit fields,
1103 ;; which can usually be done with move instructions.
1104 ;    1750: t.b.d.
1105 ;********************
1106
1107 ;; Bit field instructions, general cases.
1108 ;; "o,d" constraint causes a nonoffsetable memref to match the "o"
1109 ;; so that its address is reloaded.
1110
1111 ;; (define_insn "extv" ...
1112
1113 ;; (define_insn "extzv" ...
1114
1115 ;; (define_insn "insv" ...
1116
1117 ;; Now recognize bit field insns that operate on registers
1118 ;; (or at least were intended to do so).
1119 ;[unnamed only]
1120
1121 ;; Special patterns for optimizing bit-field instructions.
1122 ;**************************************
1123
1124 ; cc status test ops n.a. on 1750 ......... e.g. "sleu" on 68k:
1125 ;  [(set (match_operand:QI 0 "general_operand" "=d")
1126 ;        (leu (cc0) (const_int 0)))]
1127 ;  ""
1128 ;  "* cc_status = cc_prev_status;
1129 ;     return \"sls %0\"; ")
1130
1131
1132 ;; Basic conditional jump instructions.
1133
1134 (define_insn "beq"
1135   [(set (pc)
1136         (if_then_else (eq (cc0)
1137                           (const_int 0))
1138                       (label_ref (match_operand 0 "" ""))
1139                       (pc)))]
1140   ""
1141   "* return branch_or_jump (\"ez\", CODE_LABEL_NUMBER (operands[0]));
1142   ")
1143
1144 (define_insn "bne"
1145   [(set (pc)
1146         (if_then_else (ne (cc0)
1147                           (const_int 0))
1148                       (label_ref (match_operand 0 "" ""))
1149                       (pc)))]
1150   ""
1151   "* return branch_or_jump (\"nz\", CODE_LABEL_NUMBER (operands[0]));
1152   ")
1153
1154 (define_insn "bgt"
1155   [(set (pc)
1156         (if_then_else (gt (cc0)
1157                           (const_int 0))
1158                       (label_ref (match_operand 0 "" ""))
1159                       (pc)))]
1160   ""
1161   "* return branch_or_jump (\"gt\", CODE_LABEL_NUMBER (operands[0]));
1162   ")
1163
1164 (define_insn "blt"
1165   [(set (pc)
1166         (if_then_else (lt (cc0)
1167                           (const_int 0))
1168                       (label_ref (match_operand 0 "" ""))
1169                       (pc)))]
1170   ""
1171   "* return branch_or_jump (\"lt\", CODE_LABEL_NUMBER (operands[0]));
1172   ")
1173
1174 (define_insn "bge"
1175   [(set (pc)
1176         (if_then_else (ge (cc0)
1177                           (const_int 0))
1178                       (label_ref (match_operand 0 "" ""))
1179                       (pc)))]
1180   ""
1181   "* return branch_or_jump (\"ge\", CODE_LABEL_NUMBER (operands[0]));
1182   ")
1183
1184 (define_insn "ble"
1185   [(set (pc)
1186         (if_then_else (le (cc0)
1187                           (const_int 0))
1188                       (label_ref (match_operand 0 "" ""))
1189                       (pc)))]
1190   ""
1191   "* return branch_or_jump (\"le\", CODE_LABEL_NUMBER (operands[0]));
1192   ")
1193
1194
1195 ; no unsigned branches available on 1750. But GCC still needs them, so faking:
1196
1197 (define_insn "bgtu"
1198   [(set (pc)
1199         (if_then_else (gtu (cc0)
1200                           (const_int 0))
1201                       (label_ref (match_operand 0 "" ""))
1202                       (pc)))]
1203   ""
1204   "jc gt,%l0 ; Warning: this should be an *unsigned* test!")
1205
1206 (define_insn "bltu"
1207   [(set (pc)
1208         (if_then_else (ltu (cc0)
1209                           (const_int 0))
1210                       (label_ref (match_operand 0 "" ""))
1211                       (pc)))]
1212   ""
1213   "jc lt,%l0 ; Warning: this should be an *unsigned* test!")
1214
1215 (define_insn "bgeu"
1216   [(set (pc)
1217         (if_then_else (geu (cc0)
1218                           (const_int 0))
1219                       (label_ref (match_operand 0 "" ""))
1220                       (pc)))]
1221   ""
1222   "jc ge,%l0 ; Warning: this should be an *unsigned* test!")
1223
1224 (define_insn "bleu"
1225   [(set (pc)
1226         (if_then_else (leu (cc0)
1227                           (const_int 0))
1228                       (label_ref (match_operand 0 "" ""))
1229                       (pc)))]
1230   ""
1231   "jc le,%l0 ; Warning: this should be an *unsigned* test!")
1232
1233
1234 ;; Negated conditional jump instructions.
1235
1236 (define_insn ""
1237   [(set (pc)
1238         (if_then_else (eq (cc0)
1239                           (const_int 0))
1240                       (pc)
1241                       (label_ref (match_operand 0 "" ""))))]
1242   ""
1243   "* return branch_or_jump (\"nz\", CODE_LABEL_NUMBER (operands[0]));
1244   ")
1245
1246 (define_insn ""
1247   [(set (pc)
1248         (if_then_else (ne (cc0)
1249                           (const_int 0))
1250                       (pc)
1251                       (label_ref (match_operand 0 "" ""))))]
1252   ""
1253   "* return branch_or_jump (\"ez\", CODE_LABEL_NUMBER (operands[0]));
1254   ")
1255
1256 (define_insn ""
1257   [(set (pc)
1258         (if_then_else (gt (cc0)
1259                           (const_int 0))
1260                       (pc)
1261                       (label_ref (match_operand 0 "" ""))))]
1262   ""
1263   "* return branch_or_jump (\"le\", CODE_LABEL_NUMBER (operands[0]));
1264   ")
1265
1266 (define_insn ""
1267   [(set (pc)
1268         (if_then_else (lt (cc0)
1269                           (const_int 0))
1270                       (pc)
1271                       (label_ref (match_operand 0 "" ""))))]
1272   ""
1273   "* return branch_or_jump (\"ge\", CODE_LABEL_NUMBER (operands[0]));
1274   ")
1275
1276 (define_insn ""
1277   [(set (pc)
1278         (if_then_else (ge (cc0)
1279                           (const_int 0))
1280                       (pc)
1281                       (label_ref (match_operand 0 "" ""))))]
1282   ""
1283   "* return branch_or_jump (\"lt\", CODE_LABEL_NUMBER (operands[0]));
1284   ")
1285
1286 (define_insn ""
1287   [(set (pc)
1288         (if_then_else (le (cc0)
1289                           (const_int 0))
1290                       (pc)
1291                       (label_ref (match_operand 0 "" ""))))]
1292   ""
1293   "* return branch_or_jump (\"gt\", CODE_LABEL_NUMBER (operands[0]));
1294   ")
1295
1296
1297 ;; Negated unsigned conditional jump instructions (faked for 1750).
1298
1299 (define_insn ""
1300   [(set (pc)
1301         (if_then_else (gtu (cc0)
1302                           (const_int 0))
1303                       (pc)
1304                       (label_ref (match_operand 0 "" ""))))]
1305   ""
1306   "jc le,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1307
1308 (define_insn ""
1309   [(set (pc)
1310         (if_then_else (ltu (cc0)
1311                           (const_int 0))
1312                       (pc)
1313                       (label_ref (match_operand 0 "" ""))))]
1314   ""
1315   "jc ge,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1316
1317 (define_insn ""
1318   [(set (pc)
1319         (if_then_else (geu (cc0)
1320                           (const_int 0))
1321                       (pc)
1322                       (label_ref (match_operand 0 "" ""))))]
1323   ""
1324   "jc lt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1325
1326 (define_insn ""
1327   [(set (pc)
1328         (if_then_else (leu (cc0)
1329                           (const_int 0))
1330                       (pc)
1331                       (label_ref (match_operand 0 "" ""))))]
1332   ""
1333   "jc gt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1334
1335 ;; Tablejump
1336 ;; 1750 note: CASE_VECTOR_PC_RELATIVE is not defined
1337 (define_insn "tablejump"
1338   [(set (pc)
1339         (match_operand:QI 0 "register_operand" "b"))
1340    (use (label_ref (match_operand 1 "" "")))]
1341   ""
1342   "jc 15,0,r%0   ; tablejump label_ref=%1")
1343
1344
1345 ;; Unconditional jump
1346 (define_insn "jump"
1347   [(set (pc)
1348         (label_ref (match_operand 0 "" "")))]
1349   ""
1350   "jc 15,%0")
1351
1352 ;; Call subroutine, returning value in operand 0
1353 ;; (which must be a hard register).
1354 (define_insn "call_value"
1355   [(set (match_operand 0 "register_operand" "r")
1356         (call (match_operand:QI 1 "memory_operand" "m")
1357               (match_operand:QI 2 "general_operand" "g")))]
1358   ;; Operand 2 not really used for 1750.
1359   ""
1360   "sjs r15,%1   ; return value in R0")
1361
1362 ;; Call subroutine with no return value.
1363
1364 ;;  Operand 1 not really used in MIL-STD-1750.
1365 (define_insn ""
1366   [(call (match_operand:QI 0 "memory_operand" "mp")
1367          (match_operand:QI 1 "general_operand" ""))]
1368   ""
1369   "sjs r15,%0   ; no return value")
1370
1371 ;;;;;;;;;;;; 1750: NOT READY YET.
1372 (define_insn "call"
1373   [(call (match_operand:QI 0 "" "")
1374          (match_operand:QI 1 "" ""))]
1375   ""
1376   "ANYCALL %0")
1377
1378
1379 ; (define_insn "return"
1380 ;   [(return)]
1381 ;   ""
1382 ;   "*
1383 ;    {
1384 ;         rtx oprnd = gen_rtx(CONST_INT,VOIDmode,get_frame_size());
1385 ;         output_asm_insn(\"ret.m  %0\",&oprnd);
1386 ;         return \"\;\";
1387 ;    } ")
1388
1389 (define_insn "indirect_jump"
1390   [(set (pc) (match_operand:QI 0 "address_operand" "p"))]
1391   ""
1392   "jci 15,%0")
1393
1394 (define_insn "nop"
1395   [(const_int 0)]
1396   ""
1397   "nop")
1398
1399
1400 ;; Subtract One and Jump (if non-zero)
1401 (define_peephole
1402   [(set (match_operand:QI 0 "register_operand" "=r")
1403         (plus:QI (match_operand:QI 1 "register_operand" "%0")
1404                  (match_operand:QI 2 "immediate_operand" "J")))
1405    (set (cc0) (match_dup 0))
1406    (set (pc)
1407         (if_then_else (ne (cc0) (const_int 0))
1408          (label_ref (match_operand 3 "" ""))
1409          (pc)))
1410    ]
1411   "INTVAL(operands[2]) == -1"
1412   "soj r%0,%3")
1413
1414 ;; Combine a Load Register with subsequent increment/decrement into a LIM
1415 (define_peephole
1416   [(set (match_operand:QI 0 "register_operand" "=r")
1417         (match_operand:QI 1 "register_operand" "b"))
1418    (set (match_dup 0)
1419         (plus:QI (match_dup 0)
1420                  (match_operand:QI 2 "immediate_operand" "i")))]
1421   "REGNO(operands[1]) > 0"
1422   "lim r%0,%2,r%1  ; LR,inc/dec peephole")
1423
1424 ;; Eliminate the redundant load in a store/load sequence
1425 (define_peephole
1426   [(set (mem:QI (plus:QI (match_operand:QI 0 "register_operand" "r")
1427                           (match_operand:QI 1 "immediate_operand" "i")))
1428         (match_operand:QI 2 "register_operand" "r"))
1429    (set (match_operand:QI 3 "register_operand" "=r")
1430         (mem:QI (plus:QI (match_dup 0)
1431                          (match_dup 1))))
1432    ]
1433   "REGNO(operands[2]) == REGNO(operands[3])"
1434   "st r%2,%1,r%0  ; eliminated previous redundant load")
1435
1436 ;;;End.