gcc/config/pdp11/pdp11.md

   1 ;;- Machine description for the pdp11 for GNU C compiler
   2 ;; Copyright (C) 1994, 1995 Free Software Foundation, Inc.
   3 ;; Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at).
   4
   5 ;; This file is part of GNU CC.
   6
   7 ;; GNU CC is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 1, or (at your option)
  10 ;; any later version.
  11
  12 ;; GNU CC is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GNU CC; see the file COPYING.  If not, write to
  19 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21
  22 ;; HI is 16 bit
  23 ;; QI is 8 bit
  24
  25 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  26
  27 ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  28 ;;- updates for most instructions.
  29
  30 ;;- Operand classes for the register allocator:
  31 \f
  32 ;; Compare instructions.
  33
  34 ;; currently we only support df floats, which saves us quite some
  35 ;; hassle switching the FP mode!
  36 ;; we assume that CPU is always in long float mode, and
  37 ;; 16 bit integer mode - currently, the prologue for main does this,
  38 ;; but maybe we should just set up a NEW crt0 properly,
  39 ;; -- and what about signal handling code?
  40 ;; (we don't even let sf floats in the register file, so
  41 ;; we only should have to worry about truncating and widening
  42 ;; when going to memory)
  43
  44 ;; abort() call by g++ - must define libfunc for cmp_optab
  45 ;; and ucmp_optab for mode SImode, because we don't have that!!!
  46 ;; - yet since no libfunc is there, we abort ()
  47
  48 ;; The only thing that remains to be done then is output
  49 ;; the floats in a way the assembler can handle it (and
  50 ;; if you're really into it, use a PDP11 float emulation
  51 ;; libary to do floating point constant folding - but
  52 ;; I guess you'll get reasonable results even when not
  53 ;; doing this)
  54 ;; the last thing to do is fix the UPDATE_CC macro to check
  55 ;; for floating point condition codes, and set cc_status
  56 ;; properly, also setting the CC_IN_FCCR flag.
  57
  58 ;; define attributes
  59 ;; currently type is only fpu or arith or unknown, maybe branch later ?
  60 ;; default is arith
  61 (define_attr "type" "unknown,arith,fp" (const_string "arith"))
  62
  63 ;; length default is 1 word each
  64 (define_attr "length" "" (const_int 1))
  65
  66 ;; a user's asm statement
  67 (define_asm_attributes
  68   [(set_attr "type" "unknown")
  69 ; all bets are off how long it is - make it 256, forces long jumps
  70 ; whenever jumping around it !!!
  71    (set_attr "length" "256")])
  72
  73 ;; define function units
  74
  75 ;; arithmetic - values here immediately when next insn issued
  76 ;; or does it mean the number of cycles after this insn was issued?
  77 ;; how do I say that fpu insns use cpu also? (pre-interaction phase)
  78
  79 ;(define_function_unit "cpu" 1 1 (eq_attr "type" "arith") 0 0)
  80 ;(define_function_unit "fpu" 1 1 (eq_attr "type" "fp") 0 0)
  81
  82 ;; compare
  83 (define_insn "cmpdf"
  84   [(set (cc0)
  85         (compare (match_operand:DF 0 "general_operand" "fR,Q,F")
  86                  (match_operand:DF 1 "register_operand" "a,a,a")))]
  87   "TARGET_FPU"
  88   "*
  89 {
  90   cc_status.flags = CC_IN_FPU;
  91   return \"cmpd %0, %1\;cfcc\";
  92 }"
  93   [(set_attr "length" "2,3,6")])
  94
  95 ;; a bit of brain damage, maybe inline later -
  96 ;; problem is - gcc seems to NEED SImode because
  97 ;; of the cmp weirdness - maybe change gcc to handle this?
  98
  99 (define_expand "cmpsi"
 100   [(set (reg:SI 0)
 101         (match_operand:SI 0 "general_operand" "g"))
 102    (set (reg:SI 2)
 103         (match_operand:SI 1 "general_operand" "g"))
 104    (parallel [(set (cc0)
 105                    (compare (reg:SI 0)
 106                             (reg:SI 2)))
 107               (clobber (reg:SI 0))])]
 108   "0" ;; disable for test
 109   "")
 110
 111 ;; check for next insn for branch code - does this still
 112 ;; work in gcc 2.* ?
 113
 114 (define_insn ""
 115   [(set (cc0)
 116         (compare (reg:SI 0)
 117                  (reg:SI 2)))
 118    (clobber (reg:SI 0))]
 119   ""
 120   "*
 121 {
 122   rtx br_insn = NEXT_INSN (insn);
 123   RTX_CODE br_code;
 124
 125   if (GET_CODE (br_insn) != JUMP_INSN)
 126     abort();
 127   br_code =  GET_CODE (XEXP (XEXP (PATTERN (br_insn), 1), 0));
 128
 129   switch(br_code)
 130   {
 131     case GEU:
 132     case LTU:
 133     case GTU:
 134     case LEU:
 135
 136       return \"jsr pc, ___ucmpsi\;cmp $1,r0\";
 137
 138     case GE:
 139     case LT:
 140     case GT:
 141     case LE:
 142     case EQ:
 143     case NE:
 144
 145       return \"jsr pc, ___cmpsi\;tst r0\";
 146
 147     default:
 148
 149       abort();
 150   }
 151 }"
 152   [(set_attr "length" "4")])
 153
 154
 155 (define_insn "cmphi"
 156   [(set (cc0)
 157         (compare (match_operand:HI 0 "general_operand" "rR,rR,Qi,Qi")
 158                  (match_operand:HI 1 "general_operand" "rR,Qi,rR,Qi")))]
 159   ""
 160   "cmp %0,%1"
 161   [(set_attr "length" "1,2,2,3")])
 162
 163 (define_insn "cmpqi"
 164   [(set (cc0)
 165         (compare (match_operand:QI 0 "general_operand" "rR,rR,Qi,Qi")
 166                  (match_operand:QI 1 "general_operand" "rR,Qi,rR,Qi")))]
 167   ""
 168   "cmpb %0,%1"
 169   [(set_attr "length" "1,2,2,3")])
 170
 171
 172 ;; We have to have this because cse can optimize the previous pattern
 173 ;; into this one.
 174
 175 (define_insn "tstdf"
 176   [(set (cc0)
 177         (match_operand:DF 0 "general_operand" "fR,Q"))]
 178   "TARGET_FPU"
 179   "*
 180 {
 181   cc_status.flags = CC_IN_FPU;
 182   return \"tstd %0\;cfcc\";
 183 }"
 184   [(set_attr "length" "2,3")])
 185
 186
 187 (define_expand "tstsi"
 188   [(set (reg:SI 0)
 189         (match_operand:SI 0 "general_operand" "g"))
 190    (parallel [(set (cc0)
 191                    (reg:SI 0))
 192               (clobber (reg:SI 0))])]
 193   "0" ;; disable for test
 194   "")
 195
 196 (define_insn ""
 197   [(set (cc0)
 198         (reg:SI 0))
 199    (clobber (reg:SI 0))]
 200   ""
 201   "jsr pc, ___tstsi\;tst r0"
 202   [(set_attr "length" "3")])
 203
 204
 205 (define_insn "tsthi"
 206   [(set (cc0)
 207         (match_operand:HI 0 "general_operand" "rR,Q"))]
 208   ""
 209   "tst %0"
 210   [(set_attr "length" "1,2")])
 211
 212 (define_insn "tstqi"
 213   [(set (cc0)
 214         (match_operand:QI 0 "general_operand" "rR,Q"))]
 215   ""
 216   "tstb %0"
 217   [(set_attr "length" "1,2")])
 218
 219 ;; sob instruction - we need an assembler which can make this instruction
 220 ;; valid under _all_ circumstances!
 221
 222 (define_insn ""
 223   [(set (pc)
 224         (if_then_else
 225          (ne (plus:HI (match_operand:HI 0 "register_operand" "r")
 226                       (const_int -1))
 227              (const_int 0))
 228          (label_ref (match_operand 1 "" ""))
 229          (pc)))
 230    (set (match_dup 0)
 231         (plus:HI (match_dup 0)
 232                  (const_int -1)))]
 233   "TARGET_40_PLUS"
 234   "*
 235 {
 236  static int labelcount = 0;
 237  static char buf[1000];
 238
 239  if (get_attr_length (insn) == 1)
 240     return \"sob %0, %l1\";
 241
 242  /* emulate sob */
 243  output_asm_insn (\"dec %0\", operands);
 244
 245  sprintf (buf, \"bge LONG_SOB%d\", labelcount);
 246  output_asm_insn (buf, NULL);
 247
 248  output_asm_insn (\"jmp %l1\", operands);
 249
 250  sprintf (buf, \"LONG_SOB%d:\", labelcount++);
 251  output_asm_insn (buf, NULL);
 252
 253  return \"\";
 254 }"
 255   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 256                                                        (pc))
 257                                                 (const_int -256))
 258                                            (ge (minus (match_dup 0)
 259                                                        (pc))
 260                                                 (const_int 0)))
 261                                       (const_int 4)
 262                                       (const_int 1)))])
 263
 264 ;; These control RTL generation for conditional jump insns
 265 ;; and match them for register allocation.
 266
 267 ;; problem with too short jump distance! we need an assembler which can
 268 ;; make this valid for all jump distances!
 269 ;; e.g. gas!
 270
 271 ;; these must be changed to check for CC_IN_FCCR if float is to be
 272 ;; enabled
 273
 274 (define_insn "beq"
 275   [(set (pc)
 276         (if_then_else (eq (cc0)
 277                           (const_int 0))
 278                       (label_ref (match_operand 0 "" ""))
 279                       (pc)))]
 280   ""
 281   "* return output_jump(\"beq\", \"bne\", get_attr_length(insn));"
 282   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 283                                                       (pc))
 284                                                (const_int -128))
 285                                            (ge (minus (match_dup 0)
 286                                                       (pc))
 287                                                (const_int 128)))
 288                                       (const_int 3)
 289                                       (const_int 1)))])
 290
 291
 292 (define_insn "bne"
 293   [(set (pc)
 294         (if_then_else (ne (cc0)
 295                           (const_int 0))
 296                       (label_ref (match_operand 0 "" ""))
 297                       (pc)))]
 298   ""
 299   "* return output_jump(\"bne\", \"beq\", get_attr_length(insn));"
 300   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 301                                                       (pc))
 302                                                (const_int -128))
 303                                            (ge (minus (match_dup 0)
 304                                                       (pc))
 305                                                (const_int 128)))
 306                                       (const_int 3)
 307                                       (const_int 1)))])
 308
 309 (define_insn "bgt"
 310   [(set (pc)
 311         (if_then_else (gt (cc0)
 312                           (const_int 0))
 313                       (label_ref (match_operand 0 "" ""))
 314                       (pc)))]
 315   ""
 316   "* return output_jump(\"bgt\", \"ble\", get_attr_length(insn));"
 317   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 318                                                       (pc))
 319                                                (const_int -128))
 320                                            (ge (minus (match_dup 0)
 321                                                       (pc))
 322                                                (const_int 128)))
 323                                       (const_int 3)
 324                                       (const_int 1)))])
 325
 326 (define_insn "bgtu"
 327   [(set (pc)
 328         (if_then_else (gtu (cc0)
 329                            (const_int 0))
 330                       (label_ref (match_operand 0 "" ""))
 331                       (pc)))]
 332   ""
 333   "* return output_jump(\"bhi\", \"blos\", get_attr_length(insn));"
 334   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 335                                                       (pc))
 336                                                (const_int -128))
 337                                            (ge (minus (match_dup 0)
 338                                                       (pc))
 339                                                (const_int 128)))
 340                                       (const_int 3)
 341                                       (const_int 1)))])
 342
 343 (define_insn "blt"
 344   [(set (pc)
 345         (if_then_else (lt (cc0)
 346                           (const_int 0))
 347                       (label_ref (match_operand 0 "" ""))
 348                       (pc)))]
 349   ""
 350   "* return output_jump(\"blt\", \"bge\", get_attr_length(insn));"
 351   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 352                                                       (pc))
 353                                                (const_int -128))
 354                                            (ge (minus (match_dup 0)
 355                                                       (pc))
 356                                                (const_int 128)))
 357                                       (const_int 3)
 358                                       (const_int 1)))])
 359
 360
 361 (define_insn "bltu"
 362   [(set (pc)
 363         (if_then_else (ltu (cc0)
 364                            (const_int 0))
 365                       (label_ref (match_operand 0 "" ""))
 366                       (pc)))]
 367   ""
 368   "* return output_jump(\"blo\", \"bhis\", get_attr_length(insn));"
 369   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 370                                                       (pc))
 371                                                (const_int -128))
 372                                            (ge (minus (match_dup 0)
 373                                                       (pc))
 374                                                (const_int 128)))
 375                                       (const_int 3)
 376                                       (const_int 1)))])
 377
 378 (define_insn "bge"
 379   [(set (pc)
 380         (if_then_else (ge (cc0)
 381                           (const_int 0))
 382                       (label_ref (match_operand 0 "" ""))
 383                       (pc)))]
 384   ""
 385   "* return output_jump(\"bge\", \"blt\", get_attr_length(insn));"
 386   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 387                                                       (pc))
 388                                                (const_int -128))
 389                                            (ge (minus (match_dup 0)
 390                                                       (pc))
 391                                                (const_int 128)))
 392                                       (const_int 3)
 393                                       (const_int 1)))])
 394
 395 (define_insn "bgeu"
 396   [(set (pc)
 397         (if_then_else (geu (cc0)
 398                            (const_int 0))
 399                       (label_ref (match_operand 0 "" ""))
 400                       (pc)))]
 401   ""
 402   "* return output_jump(\"bhis\", \"blo\", get_attr_length(insn));"
 403   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 404                                                       (pc))
 405                                                (const_int -128))
 406                                            (ge (minus (match_dup 0)
 407                                                       (pc))
 408                                                (const_int 128)))
 409                                       (const_int 3)
 410                                       (const_int 1)))])
 411
 412 (define_insn "ble"
 413   [(set (pc)
 414         (if_then_else (le (cc0)
 415                           (const_int 0))
 416                       (label_ref (match_operand 0 "" ""))
 417                       (pc)))]
 418   ""
 419   "* return output_jump(\"ble\", \"bgt\", get_attr_length(insn));"
 420   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 421                                                       (pc))
 422                                                (const_int -128))
 423                                            (ge (minus (match_dup 0)
 424                                                       (pc))
 425                                                (const_int 128)))
 426                                       (const_int 3)
 427                                       (const_int 1)))])
 428
 429 (define_insn "bleu"
 430   [(set (pc)
 431         (if_then_else (leu (cc0)
 432                            (const_int 0))
 433                       (label_ref (match_operand 0 "" ""))
 434                       (pc)))]
 435   ""
 436   "* return output_jump(\"blos\", \"bhi\", get_attr_length(insn));"
 437   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 438                                                       (pc))
 439                                                (const_int -128))
 440                                            (ge (minus (match_dup 0)
 441                                                       (pc))
 442                                                (const_int 128)))
 443                                       (const_int 3)
 444                                       (const_int 1)))])
 445
 446 \f
 447 ;; These match inverted jump insns for register allocation.
 448
 449 (define_insn ""
 450   [(set (pc)
 451         (if_then_else (eq (cc0)
 452                           (const_int 0))
 453                       (pc)
 454                       (label_ref (match_operand 0 "" ""))))]
 455   ""
 456   "* return output_jump(\"bne\", \"beq\", get_attr_length(insn));"
 457   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 458                                                       (pc))
 459                                                (const_int -128))
 460                                            (ge (minus (match_dup 0)
 461                                                       (pc))
 462                                                (const_int 128)))
 463                                       (const_int 3)
 464                                       (const_int 1)))])
 465
 466 (define_insn ""
 467   [(set (pc)
 468         (if_then_else (ne (cc0)
 469                           (const_int 0))
 470                       (pc)
 471                       (label_ref (match_operand 0 "" ""))))]
 472   ""
 473   "* return output_jump(\"beq\", \"bne\", get_attr_length(insn));"
 474   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 475                                                       (pc))
 476                                                (const_int -128))
 477                                            (ge (minus (match_dup 0)
 478                                                       (pc))
 479                                                (const_int 128)))
 480                                       (const_int 3)
 481                                       (const_int 1)))])
 482
 483 (define_insn ""
 484   [(set (pc)
 485         (if_then_else (gt (cc0)
 486                           (const_int 0))
 487                       (pc)
 488                       (label_ref (match_operand 0 "" ""))))]
 489   ""
 490   "* return output_jump(\"ble\", \"bgt\", get_attr_length(insn));"
 491   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 492                                                       (pc))
 493                                                (const_int -128))
 494                                            (ge (minus (match_dup 0)
 495                                                       (pc))
 496                                                (const_int 128)))
 497                                       (const_int 3)
 498                                       (const_int 1)))])
 499
 500 (define_insn ""
 501   [(set (pc)
 502         (if_then_else (gtu (cc0)
 503                            (const_int 0))
 504                       (pc)
 505                       (label_ref (match_operand 0 "" ""))))]
 506   ""
 507   "* return output_jump(\"blos\", \"bhi\", get_attr_length(insn));"
 508   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 509                                                       (pc))
 510                                                (const_int -128))
 511                                            (ge (minus (match_dup 0)
 512                                                       (pc))
 513                                                (const_int 128)))
 514                                       (const_int 3)
 515                                       (const_int 1)))])
 516
 517 (define_insn ""
 518   [(set (pc)
 519         (if_then_else (lt (cc0)
 520                           (const_int 0))
 521                       (pc)
 522                       (label_ref (match_operand 0 "" ""))))]
 523   ""
 524   "* return output_jump(\"bge\", \"blt\", get_attr_length(insn));"
 525   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 526                                                       (pc))
 527                                                (const_int -128))
 528                                            (ge (minus (match_dup 0)
 529                                                       (pc))
 530                                                (const_int 128)))
 531                                       (const_int 3)
 532                                       (const_int 1)))])
 533
 534 (define_insn ""
 535   [(set (pc)
 536         (if_then_else (ltu (cc0)
 537                            (const_int 0))
 538                       (pc)
 539                       (label_ref (match_operand 0 "" ""))))]
 540   ""
 541   "* return output_jump(\"bhis\", \"blo\", get_attr_length(insn));"
 542   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 543                                                       (pc))
 544                                                (const_int -128))
 545                                            (ge (minus (match_dup 0)
 546                                                       (pc))
 547                                                (const_int 128)))
 548                                       (const_int 3)
 549                                       (const_int 1)))])
 550
 551 (define_insn ""
 552   [(set (pc)
 553         (if_then_else (ge (cc0)
 554                           (const_int 0))
 555                       (pc)
 556                       (label_ref (match_operand 0 "" ""))))]
 557   ""
 558   "* return output_jump(\"blt\", \"bge\", get_attr_length(insn));"
 559   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 560                                                       (pc))
 561                                                (const_int -128))
 562                                            (ge (minus (match_dup 0)
 563                                                       (pc))
 564                                                (const_int 128)))
 565                                       (const_int 3)
 566                                       (const_int 1)))])
 567
 568 (define_insn ""
 569   [(set (pc)
 570         (if_then_else (geu (cc0)
 571                            (const_int 0))
 572                       (pc)
 573                       (label_ref (match_operand 0 "" ""))))]
 574   ""
 575   "* return output_jump(\"blo\", \"bhis\", get_attr_length(insn));"
 576   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 577                                                       (pc))
 578                                                (const_int -128))
 579                                            (ge (minus (match_dup 0)
 580                                                       (pc))
 581                                                (const_int 128)))
 582                                       (const_int 3)
 583                                       (const_int 1)))])
 584
 585 (define_insn ""
 586   [(set (pc)
 587         (if_then_else (le (cc0)
 588                           (const_int 0))
 589                       (pc)
 590                       (label_ref (match_operand 0 "" ""))))]
 591   ""
 592   "* return output_jump(\"bgt\", \"ble\", get_attr_length(insn));"
 593   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 594                                                       (pc))
 595                                                (const_int -128))
 596                                            (ge (minus (match_dup 0)
 597                                                       (pc))
 598                                                (const_int 128)))
 599                                       (const_int 3)
 600                                       (const_int 1)))])
 601
 602 (define_insn ""
 603   [(set (pc)
 604         (if_then_else (leu (cc0)
 605                            (const_int 0))
 606                       (pc)
 607                       (label_ref (match_operand 0 "" ""))))]
 608   ""
 609   "* return output_jump(\"bhi\", \"blos\", get_attr_length(insn));"
 610   [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0)
 611                                                       (pc))
 612                                                (const_int -128))
 613                                            (ge (minus (match_dup 0)
 614                                                       (pc))
 615                                                (const_int 128)))
 616                                       (const_int 3)
 617                                       (const_int 1)))])
 618 \f
 619 ;; Move instructions
 620
 621 (define_insn "movdi"
 622   [(set (match_operand:DI 0 "general_operand" "=g")
 623         (match_operand:DI 1 "general_operand" "g"))]
 624   ""
 625   "* return output_move_quad (operands);"
 626 ;; what's the mose expensive code - say twice movsi = 16
 627   [(set_attr "length" "16")])
 628
 629 (define_insn "movsi"
 630   [(set (match_operand:SI 0 "general_operand" "=r,r,r,rm,m")
 631         (match_operand:SI 1 "general_operand" "rN,IJ,K,m,r"))]
 632   ""
 633   "* return output_move_double (operands);"
 634 ;; what's the most expensive code ? - I think 8!
 635 ;; we could split it up and make several sub-cases...
 636   [(set_attr "length" "2,3,4,8,8")])
 637
 638 (define_insn "movhi"
 639   [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q")
 640         (match_operand:HI 1 "general_operand" "rRN,Qi,rRN,Qi"))]
 641   ""
 642   "*
 643 {
 644   if (operands[1] == const0_rtx)
 645     return \"clr %0\";
 646
 647   return \"mov %1, %0\";
 648 }"
 649   [(set_attr "length" "1,2,2,3")])
 650
 651 (define_insn "movqi"
 652   [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q")
 653         (match_operand:QI 1 "general_operand" "rRN,Qi,rRN,Qi"))]
 654   ""
 655   "*
 656 {
 657   if (operands[1] == const0_rtx)
 658     return \"clrb %0\";
 659
 660   return \"movb %1, %0\";
 661 }"
 662   [(set_attr "length" "1,2,2,3")])
 663
 664 ;; do we have to supply all these moves? e.g. to
 665 ;; NO_LOAD_FPU_REGs ?
 666 (define_insn "movdf"
 667   [(set (match_operand:DF 0 "general_operand" "=f,R,f,Q,f,m")
 668         (match_operand:DF 1 "general_operand" "fR,f,Q,f,F,m"))]
 669   ""
 670   "* return output_move_quad (operands);"
 671 ;; just a guess..
 672   [(set_attr "length" "1,1,2,2,5,16")])
 673
 674 (define_insn "movsf"
 675   [(set (match_operand:SF 0 "general_operand" "=g,r,g")
 676         (match_operand:SF 1 "general_operand" "r,rmF,g"))]
 677   "TARGET_FPU"
 678   "* return output_move_double (operands);"
 679   [(set_attr "length" "8,8,8")])
 680
 681 ;; maybe fiddle a bit with move_ratio, then
 682 ;; let constraints only accept a register ...
 683
 684 (define_expand "movstrhi"
 685   [(parallel [(set (mem:BLK (match_operand:BLK 0 "general_operand" "=g,g"))
 686                    (mem:BLK (match_operand:BLK 1 "general_operand" "g,g")))
 687               (use (match_operand:HI 2 "arith_operand" "n,&mr"))
 688               (use (match_operand:HI 3 "immediate_operand" "i,i"))
 689               (clobber (match_scratch:HI 4 "=&r,X"))
 690               (clobber (match_dup 0))
 691               (clobber (match_dup 1))
 692               (clobber (match_dup 2))])]
 693   "(TARGET_BCOPY_BUILTIN)"
 694   "
 695 {
 696   operands[0] = copy_to_mode_reg (Pmode, XEXP (operands[0], 0));
 697   operands[1] = copy_to_mode_reg (Pmode, XEXP (operands[1], 0));
 698   operands[2] = force_not_mem (operands[2]);
 699 }")
 700
 701
 702 (define_insn "" ; "movstrhi"
 703   [(set (mem:BLK (match_operand:HI 0 "general_operand" "=r,r"))
 704         (mem:BLK (match_operand:HI 1 "general_operand" "r,r")))
 705    (use (match_operand:HI 2 "arith_operand" "n,&r"))
 706    (use (match_operand:HI 3 "immediate_operand" "i,i"))
 707    (clobber (match_scratch:HI 4 "=&r,X"))
 708    (clobber (match_dup 0))
 709    (clobber (match_dup 1))
 710    (clobber (match_dup 2))]
 711   "(TARGET_BCOPY_BUILTIN)"
 712   "* return output_block_move (operands);"
 713 ;;; just a guess
 714   [(set_attr "length" "40")])
 715
 716
 717 \f
 718 ;;- truncation instructions
 719
 720 (define_insn  "truncdfsf2"
 721   [(set (match_operand:SF 0 "general_operand" "=r,R,Q")
 722         (float_truncate:SF (match_operand:DF 1 "register_operand" "a,a,a")))]
 723   "TARGET_FPU"
 724   "* if (which_alternative ==0)
 725      {
 726        output_asm_insn(\"stcdf %1, -(sp)\", operands);
 727        output_asm_insn(\"mov (sp)+, %0\", operands);
 728        operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 729        output_asm_insn(\"mov (sp)+, %0\", operands);
 730        return \"\";
 731      }
 732      else if (which_alternative == 1)
 733        return \"stcdf %1, %0\";
 734      else
 735        return \"stcdf %1, %0\";
 736   "
 737   [(set_attr "length" "3,1,2")])
 738
 739
 740 (define_expand "truncsihi2"
 741   [(set (match_operand:HI 0 "general_operand" "=g")
 742         (subreg:HI
 743           (match_operand:SI 1 "general_operand" "or")
 744           0))]
 745   ""
 746   "")
 747
 748 \f
 749 ;;- zero extension instructions
 750
 751 (define_insn "zero_extendqihi2"
 752   [(set (match_operand:HI 0 "general_operand" "=r")
 753         (zero_extend:HI (match_operand:QI 1 "general_operand" "0")))]
 754   ""
 755   "bic $(256*255), %0"
 756   [(set_attr "length" "2")])
 757
 758 (define_expand "zero_extendhisi2"
 759   [(set (subreg:HI
 760           (match_dup 0)
 761           1)
 762         (match_operand:HI 1 "register_operand" "r"))
 763    (set (subreg:HI
 764           (match_operand:SI 0 "register_operand" "=r")
 765           0)
 766         (const_int 0))]
 767   ""
 768   "/* operands[1] = make_safe_from (operands[1], operands[0]); */")
 769
 770 \f
 771 ;;- sign extension instructions
 772
 773 (define_insn "extendsfdf2"
 774   [(set (match_operand:DF 0 "register_operand" "=a,a,a")
 775         (float_extend:SF (match_operand:SF 1 "general_operand" "r,R,Q")))]
 776   "TARGET_FPU"
 777   "@
 778    mov %1, -(sp)\;ldcfd (sp)+,%0
 779    ldcfd %1, %0
 780    ldcfd %1, %0"
 781   [(set_attr "length" "2,1,2")])
 782
 783 ;; does movb sign extend in register-to-register move?
 784 (define_insn "extendqihi2"
 785   [(set (match_operand:HI 0 "register_operand" "=r,r")
 786         (sign_extend:HI (match_operand:QI 1 "general_operand" "rR,Q")))]
 787   ""
 788   "movb %1, %0"
 789   [(set_attr "length" "1,2")])
 790
 791 (define_insn "extendqisi2"
 792   [(set (match_operand:SI 0 "register_operand" "=r,r")
 793         (sign_extend:SI (match_operand:QI 1 "general_operand" "rR,Q")))]
 794   "TARGET_40_PLUS"
 795   "*
 796 {
 797   rtx latehalf[2];
 798
 799   /* make register pair available */
 800   latehalf[0] = operands[0];
 801   operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 802
 803   output_asm_insn(\"movb %1, %0\", operands);
 804   output_asm_insn(\"sxt %0\", latehalf);
 805
 806   return \"\";
 807 }"
 808   [(set_attr "length" "2,3")])
 809
 810 ;; maybe we have to use define_expand to say that we have the instruction,
 811 ;; unconditionally, and then match dependent on CPU type:
 812
 813 (define_expand "extendhisi2"
 814   [(set (match_operand:SI 0 "general_operand" "=g")
 815         (sign_extend:SI (match_operand:HI 1 "general_operand" "g")))]
 816   ""
 817   "")
 818
 819 (define_insn "" ; "extendhisi2"
 820   [(set (match_operand:SI 0 "general_operand" "=o,<,r")
 821         (sign_extend:SI (match_operand:HI 1 "general_operand" "g,g,g")))]
 822   "TARGET_40_PLUS"
 823   "*
 824 {
 825   rtx latehalf[2];
 826
 827   /* we don't want to mess with auto increment */
 828
 829   switch(which_alternative)
 830   {
 831     case 0:
 832
 833       latehalf[0] = operands[0];
 834       operands[0] = adj_offsettable_operand(operands[0], 2);
 835
 836       output_asm_insn(\"mov %1, %0\", operands);
 837       output_asm_insn(\"sxt %0\", latehalf);
 838
 839       return \"\";
 840
 841     case 1:
 842
 843       /* - auto-decrement - right direction ;-) */
 844       output_asm_insn(\"mov %1, %0\", operands);
 845       output_asm_insn(\"sxt %0\", operands);
 846
 847       return \"\";
 848
 849     case 2:
 850
 851       /* make register pair available */
 852       latehalf[0] = operands[0];
 853       operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 854
 855       output_asm_insn(\"mov %1, %0\", operands);
 856       output_asm_insn(\"sxt %0\", latehalf);
 857
 858       return \"\";
 859
 860     default:
 861
 862       abort();
 863   }
 864 }"
 865   [(set_attr "length" "5,3,3")])
 866
 867
 868 (define_insn ""
 869   [(set (match_operand:SI 0 "register_operand" "=r")
 870         (sign_extend:SI (match_operand:HI 1 "general_operand" "0")))]
 871   "(! TARGET_40_PLUS)"
 872   "*
 873 {
 874   static count = 0;
 875   char buf[100];
 876   rtx lateoperands[2];
 877
 878   lateoperands[0] = operands[0];
 879   operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 880
 881   output_asm_insn(\"tst %0\", operands);
 882   sprintf(buf, \"bge extendhisi%d\", count);
 883   output_asm_insn(buf, NULL);
 884   output_asm_insn(\"mov -1, %0\", lateoperands);
 885   sprintf(buf, \"bne extendhisi%d\", count+1);
 886   output_asm_insn(buf, NULL);
 887   sprintf(buf, \"\\nextendhisi%d:\", count);
 888   output_asm_insn(buf, NULL);
 889   output_asm_insn(\"clr %0\", lateoperands);
 890   sprintf(buf, \"\\nextendhisi%d:\", count+1);
 891   output_asm_insn(buf, NULL);
 892
 893   count += 2;
 894
 895   return \"\";
 896 }"
 897   [(set_attr "length" "6")])
 898
 899 ;; make float to int and vice versa
 900 ;; using the cc_status.flag field we could probably cut down
 901 ;; on seti and setl
 902 ;; assume that we are normally in double and integer mode -
 903 ;; what do pdp library routines do to fpu mode ?
 904
 905 (define_insn "floatsidf2"
 906   [(set (match_operand:DF 0 "register_operand" "=a,a,a")
 907         (float:DF (match_operand:SI 1 "general_operand" "r,R,Q")))]
 908   "TARGET_FPU"
 909   "* if (which_alternative ==0)
 910      {
 911        rtx latehalf[2];
 912
 913        latehalf[0] = NULL;
 914        latehalf[1] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 915        output_asm_insn(\"mov %1, -(sp)\", latehalf);
 916        output_asm_insn(\"mov %1, -(sp)\", operands);
 917
 918        output_asm_insn(\"setl\", operands);
 919        output_asm_insn(\"ldcld (sp)+, %0\", operands);
 920        output_asm_insn(\"seti\", operands);
 921        return \"\";
 922      }
 923      else if (which_alternative == 1)
 924        return \"setl\;ldcld %1, %0\;seti\";
 925      else
 926        return \"setl\;ldcld %1, %0\;seti\";
 927   "
 928   [(set_attr "length" "5,3,4")])
 929
 930 (define_insn "floathidf2"
 931   [(set (match_operand:DF 0 "register_operand" "=a,a")
 932         (float:DF (match_operand:HI 1 "general_operand" "rR,Qi")))]
 933   "TARGET_FPU"
 934   "ldcid %1, %0"
 935   [(set_attr "length" "1,2")])
 936
 937 ;; cut float to int
 938 (define_insn "fix_truncdfsi2"
 939   [(set (match_operand:SI 0 "general_operand" "=r,R,Q")
 940         (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "a,a,a"))))]
 941   "TARGET_FPU"
 942   "* if (which_alternative ==0)
 943      {
 944        output_asm_insn(\"setl\", operands);
 945        output_asm_insn(\"stcdl %1, -(sp)\", operands);
 946        output_asm_insn(\"seti\", operands);
 947        output_asm_insn(\"mov (sp)+, %0\", operands);
 948        operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
 949        output_asm_insn(\"mov (sp)+, %0\", operands);
 950        return \"\";
 951      }
 952      else if (which_alternative == 1)
 953        return \"setl\;stcdl %1, %0\;seti\";
 954      else
 955        return \"setl\;stcdl %1, %0\;seti\";
 956   "
 957   [(set_attr "length" "5,3,4")])
 958
 959 (define_insn "fix_truncdfhi2"
 960   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
 961         (fix:HI (fix:DF (match_operand:DF 1 "register_operand" "a,a"))))]
 962   "TARGET_FPU"
 963   "stcdi %1, %0"
 964   [(set_attr "length" "1,2")])
 965
 966 \f
 967 ;;- arithmetic instructions
 968 ;;- add instructions
 969
 970 (define_insn "adddf3"
 971   [(set (match_operand:DF 0 "register_operand" "=a,a,a")
 972         (plus:DF (match_operand:DF 1 "register_operand" "%0,0,0")
 973                  (match_operand:DF 2 "general_operand" "fR,Q,F")))]
 974   "TARGET_FPU"
 975   "addd %2, %0"
 976   [(set_attr "length" "1,2,5")])
 977
 978 (define_insn "addsi3"
 979   [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o")
 980         (plus:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0")
 981                  (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K")))]
 982   ""
 983   "*
 984 { /* Here we trust that operands don't overlap
 985
 986      or is lateoperands the low word?? - looks like it! */
 987
 988   unsigned int i;
 989   rtx lateoperands[3];
 990
 991   lateoperands[0] = operands[0];
 992
 993   if (REG_P (operands[0]))
 994     operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
 995   else
 996     operands[0] = adj_offsettable_operand (operands[0], 2);
 997
 998   if (! CONSTANT_P(operands[2]))
 999   {
1000     lateoperands[2] = operands[2];
1001
1002     if (REG_P (operands[2]))
1003       operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1);
1004     else
1005       operands[2] = adj_offsettable_operand(operands[2], 2);
1006
1007     output_asm_insn (\"add %2, %0\", operands);
1008     output_asm_insn (\"adc %0\", lateoperands);
1009     output_asm_insn (\"add %2, %0\", lateoperands);
1010     return \"\";
1011   }
1012
1013   lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff);
1014   operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff);
1015
1016   if (INTVAL(operands[2]))
1017   {
1018     output_asm_insn (\"add %2, %0\", operands);
1019     output_asm_insn (\"adc %0\", lateoperands);
1020   }
1021
1022   if (INTVAL(lateoperands[2]))
1023     output_asm_insn (\"add %2, %0\", lateoperands);
1024
1025   return \"\";
1026 }"
1027   [(set_attr "length" "3,5,6,8,3,1,5,5,3,8")])
1028
1029 (define_insn "addhi3"
1030   [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q")
1031         (plus:HI (match_operand:HI 1 "general_operand" "%0,0,0,0")
1032                  (match_operand:HI 2 "general_operand" "rRLM,Qi,rRLM,Qi")))]
1033   ""
1034   "*
1035 {
1036   if (GET_CODE (operands[2]) == CONST_INT)
1037     if (INTVAL(operands[2]) == 1)
1038       return \"inc %0\";
1039     else if (INTVAL(operands[2]) == -1)
1040       return \"dec %0\";
1041
1042   return \"add %2, %0\";
1043 }"
1044   [(set_attr "length" "1,2,2,3")])
1045
1046 (define_insn "addqi3"
1047   [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q")
1048         (plus:QI (match_operand:QI 1 "general_operand" "%0,0,0,0")
1049                  (match_operand:QI 2 "general_operand" "rRLM,Qi,rRLM,Qi")))]
1050   ""
1051   "*
1052 {
1053   if (GET_CODE (operands[2]) == CONST_INT)
1054     if (INTVAL(operands[2]) == 1)
1055       return \"incb %0\";
1056     else if (INTVAL(operands[2]) == -1)
1057       return \"decb %0\";
1058
1059   return \"addb %2, %0\";
1060 }"
1061   [(set_attr "length" "1,2,2,3")])
1062
1063 \f
1064 ;;- subtract instructions
1065 ;; we don't have to care for constant second
1066 ;; args, since they are canonical plus:xx now!
1067 ;; also for minus:DF ??
1068
1069 (define_insn "subdf3"
1070   [(set (match_operand:DF 0 "register_operand" "=a,a")
1071         (minus:DF (match_operand:DF 1 "register_operand" "0,0")
1072                   (match_operand:DF 2 "general_operand" "fR,Q")))]
1073   "TARGET_FPU"
1074   "subd %2, %0"
1075   [(set_attr "length" "1,2")])
1076
1077 (define_insn "subsi3"
1078   [(set (match_operand:SI 0 "general_operand" "=r,r,o,o")
1079         (minus:SI (match_operand:SI 1 "general_operand" "0,0,0,0")
1080                   (match_operand:SI 2 "general_operand" "r,o,r,o")))]
1081   ""
1082   "*
1083 { /* Here we trust that operands don't overlap
1084
1085      or is lateoperands the low word?? - looks like it! */
1086
1087   unsigned int i;
1088   rtx lateoperands[3];
1089
1090   lateoperands[0] = operands[0];
1091
1092   if (REG_P (operands[0]))
1093     operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
1094   else
1095     operands[0] = adj_offsettable_operand (operands[0], 2);
1096
1097   lateoperands[2] = operands[2];
1098
1099   if (REG_P (operands[2]))
1100     operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1);
1101   else
1102     operands[2] = adj_offsettable_operand(operands[2], 2);
1103
1104   output_asm_insn (\"sub %2, %0\", operands);
1105   output_asm_insn (\"sbc %0\", lateoperands);
1106   output_asm_insn (\"sub %2, %0\", lateoperands);
1107   return \"\";
1108 }"
1109 ;; offsettable memory addresses always are expensive!!!
1110   [(set_attr "length" "3,5,6,8")])
1111
1112 (define_insn "subhi3"
1113   [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q")
1114         (minus:HI (match_operand:HI 1 "general_operand" "0,0,0,0")
1115                   (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi")))]
1116   ""
1117   "*
1118 {
1119   if (GET_CODE (operands[2]) == CONST_INT)
1120     abort();
1121
1122   return \"sub %2, %0\";
1123 }"
1124   [(set_attr "length" "1,2,2,3")])
1125
1126 (define_insn "subqi3"
1127   [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q")
1128         (minus:QI (match_operand:QI 1 "general_operand" "0,0,0,0")
1129                   (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi")))]
1130   ""
1131   "*
1132 {
1133   if (GET_CODE (operands[2]) == CONST_INT)
1134     abort();
1135
1136   return \"subb %2, %0\";
1137 }"
1138   [(set_attr "length" "1,2,2,3")])
1139
1140 ;;;;- and instructions
1141 ;; Bit-and on the pdp (like on the vax) is done with a clear-bits insn.
1142 (define_expand "andsi3"
1143   [(set (match_operand:SI 0 "general_operand" "=g")
1144         (and:SI (match_operand:SI 1 "general_operand" "0")
1145                 (not:SI (match_operand:SI 2 "general_operand" "g"))))]
1146   ""
1147   "
1148 {
1149   extern rtx expand_unop ();
1150   if (GET_CODE (operands[2]) == CONST_INT)
1151     operands[2] = gen_rtx (CONST_INT, VOIDmode, ~INTVAL (operands[2]));
1152   else
1153     operands[2] = expand_unop (SImode, one_cmpl_optab, operands[2], 0, 1);
1154 }")
1155
1156 (define_expand "andhi3"
1157   [(set (match_operand:HI 0 "general_operand" "=g")
1158         (and:HI (match_operand:HI 1 "general_operand" "0")
1159                 (not:HI (match_operand:HI 2 "general_operand" "g"))))]
1160   ""
1161   "
1162 {
1163   extern rtx expand_unop ();
1164   if (GET_CODE (operands[2]) == CONST_INT)
1165     operands[2] = gen_rtx (CONST_INT, VOIDmode, ~INTVAL (operands[2]));
1166   else
1167     operands[2] = expand_unop (HImode, one_cmpl_optab, operands[2], 0, 1);
1168 }")
1169
1170 (define_expand "andqi3"
1171   [(set (match_operand:QI 0 "general_operand" "=g")
1172         (and:QI (match_operand:QI 1 "general_operand" "0")
1173                 (not:QI (match_operand:QI 2 "general_operand" "g"))))]
1174   ""
1175   "
1176 {
1177   extern rtx expand_unop ();
1178   rtx op = operands[2];
1179   if (GET_CODE (op) == CONST_INT)
1180     operands[2] = gen_rtx (CONST_INT, VOIDmode,
1181                            ((1 << 8) - 1) & ~INTVAL (op));
1182   else
1183     operands[2] = expand_unop (QImode, one_cmpl_optab, op, 0, 1);
1184 }")
1185
1186 (define_insn "andcbsi3"
1187   [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o")
1188         (and:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0")
1189                 (not:SI (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K"))))]
1190   ""
1191   "*
1192 { /* Here we trust that operands don't overlap
1193
1194      or is lateoperands the low word?? - looks like it! */
1195
1196   unsigned int i;
1197   rtx lateoperands[3];
1198
1199   lateoperands[0] = operands[0];
1200
1201   if (REG_P (operands[0]))
1202     operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
1203   else
1204     operands[0] = adj_offsettable_operand (operands[0], 2);
1205
1206   if (! CONSTANT_P(operands[2]))
1207   {
1208     lateoperands[2] = operands[2];
1209
1210     if (REG_P (operands[2]))
1211       operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1);
1212     else
1213       operands[2] = adj_offsettable_operand(operands[2], 2);
1214
1215     output_asm_insn (\"bic %2, %0\", operands);
1216     output_asm_insn (\"bic %2, %0\", lateoperands);
1217     return \"\";
1218   }
1219
1220   lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff);
1221   operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff);
1222
1223   /* these have different lengths, so we should have
1224      different constraints! */
1225   if (INTVAL(operands[2]))
1226     output_asm_insn (\"bic %2, %0\", operands);
1227
1228   if (INTVAL(lateoperands[2]))
1229     output_asm_insn (\"bic %2, %0\", lateoperands);
1230
1231   return \"\";
1232 }"
1233   [(set_attr "length" "2,4,4,6,2,2,4,3,3,6")])
1234
1235 (define_insn "andcbhi3"
1236   [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q")
1237         (and:HI (match_operand:HI 1 "general_operand" "0,0,0,0")
1238                 (not:HI (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi"))))]
1239   ""
1240   "bic %2, %0"
1241   [(set_attr "length" "1,2,2,3")])
1242
1243 (define_insn "andcbqi3"
1244   [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q")
1245         (and:QI (match_operand:QI 1 "general_operand" "0,0,0,0")
1246                 (not:QI (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi"))))]
1247   ""
1248   "bicb %2, %0"
1249   [(set_attr "length" "1,2,2,3")])
1250
1251 ;;- Bit set (inclusive or) instructions
1252 (define_insn "iorsi3"
1253   [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o")
1254         (ior:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0")
1255                   (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K")))]
1256   ""
1257   "*
1258 { /* Here we trust that operands don't overlap
1259
1260      or is lateoperands the low word?? - looks like it! */
1261
1262   unsigned int i;
1263   rtx lateoperands[3];
1264
1265   lateoperands[0] = operands[0];
1266
1267   if (REG_P (operands[0]))
1268     operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
1269   else
1270     operands[0] = adj_offsettable_operand (operands[0], 2);
1271
1272   if (! CONSTANT_P(operands[2]))
1273   {
1274     lateoperands[2] = operands[2];
1275
1276     if (REG_P (operands[2]))
1277       operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1);
1278     else
1279       operands[2] = adj_offsettable_operand(operands[2], 2);
1280
1281     output_asm_insn (\"bis %2, %0\", operands);
1282     output_asm_insn (\"bis %2, %0\", lateoperands);
1283     return \"\";
1284   }
1285
1286   lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff);
1287   operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff);
1288
1289   /* these have different lengths, so we should have
1290      different constraints! */
1291   if (INTVAL(operands[2]))
1292     output_asm_insn (\"bis %2, %0\", operands);
1293
1294   if (INTVAL(lateoperands[2]))
1295     output_asm_insn (\"bis %2, %0\", lateoperands);
1296
1297   return \"\";
1298 }"
1299   [(set_attr "length" "2,4,4,6,2,2,4,3,3,6")])
1300
1301 (define_insn "iorhi3"
1302   [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q")
1303         (ior:HI (match_operand:HI 1 "general_operand" "%0,0,0,0")
1304                 (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi")))]
1305   ""
1306   "bis %2, %0"
1307   [(set_attr "length" "1,2,2,3")])
1308
1309 (define_insn "iorqi3"
1310   [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q")
1311         (ior:QI (match_operand:QI 1 "general_operand" "%0,0,0,0")
1312                 (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi")))]
1313   ""
1314   "bisb %2, %0")
1315
1316 ;;- xor instructions
1317 (define_insn "xorsi3"
1318   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
1319         (xor:SI (match_operand:SI 1 "register_operand" "%0,0,0,0")
1320                   (match_operand:SI 2 "arith_operand" "r,I,J,K")))]
1321   "TARGET_40_PLUS"
1322   "*
1323 { /* Here we trust that operands don't overlap */
1324
1325   unsigned int i;
1326   rtx lateoperands[3];
1327
1328   lateoperands[0] = operands[0];
1329   operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
1330
1331   if (REG_P(operands[2]))
1332   {
1333     lateoperands[2] = operands[2];
1334     operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1);
1335
1336     output_asm_insn (\"xor %2, %0\", operands);
1337     output_asm_insn (\"xor %2, %0\", lateoperands);
1338
1339     return \"\";
1340   }
1341
1342   lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff);
1343   operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff);
1344
1345   if (INTVAL(operands[2]))
1346     output_asm_insn (\"xor %2, %0\", operands);
1347
1348   if (INTVAL(lateoperands[2]))
1349     output_asm_insn (\"xor %2, %0\", lateoperands);
1350
1351   return \"\";
1352 }"
1353   [(set_attr "length" "2,1,1,2")])
1354
1355 (define_insn "xorhi3"
1356   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1357         (xor:HI (match_operand:HI 1 "general_operand" "%0,0")
1358                 (match_operand:HI 2 "register_operand" "r,r")))]
1359   "TARGET_40_PLUS"
1360   "xor %2, %0"
1361   [(set_attr "length" "1,2")])
1362
1363 ;;- one complement instructions
1364
1365 (define_insn "one_cmplhi2"
1366   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1367         (not:HI (match_operand:HI 1 "general_operand" "0,0")))]
1368   ""
1369   "com %0"
1370   [(set_attr "length" "1,2")])
1371
1372 (define_insn "one_cmplqi2"
1373   [(set (match_operand:QI 0 "general_operand" "=rR,Q")
1374         (not:QI (match_operand:QI 1 "general_operand" "0,0")))]
1375   ""
1376   "comb %0"
1377   [(set_attr "length" "1,2")])
1378
1379 ;;- arithmetic shift instructions
1380 (define_insn "ashlsi3"
1381   [(set (match_operand:SI 0 "register_operand" "=r,r")
1382         (ashift:SI (match_operand:SI 1 "register_operand" "0,0")
1383                    (match_operand:HI 2 "general_operand" "rR,Qi")))]
1384   "TARGET_45"
1385   "ashc %2,%0"
1386   [(set_attr "length" "1,2")])
1387
1388 ;; Arithmetic right shift on the pdp works by negating the shift count.
1389 (define_expand "ashrsi3"
1390   [(set (match_operand:SI 0 "register_operand" "=r")
1391         (ashift:SI (match_operand:SI 1 "register_operand" "0")
1392                    (match_operand:HI 2 "general_operand" "g")))]
1393   ""
1394   "
1395 {
1396   operands[2] = negate_rtx (HImode, operands[2]);
1397 }")
1398
1399 ;; define asl aslb asr asrb - ashc missing!
1400
1401 ;; asl
1402 (define_insn ""
1403   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1404         (ashift:HI (match_operand:HI 1 "general_operand" "0,0")
1405                    (const_int 1)))]
1406   ""
1407   "asl %0"
1408   [(set_attr "length" "1,2")])
1409
1410 ;; and another possibility for asr is << -1
1411 ;; might cause problems since -1 can also be encoded as 65535!
1412 ;; not in gcc2 ???
1413
1414 ;; asr
1415 (define_insn ""
1416   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1417         (ashift:HI (match_operand:HI 1 "general_operand" "0,0")
1418                    (const_int -1)))]
1419   ""
1420   "asr %0"
1421   [(set_attr "length" "1,2")])
1422
1423 ;; shift is by arbitrary count is expensive,
1424 ;; shift by one cheap - so let's do that, if
1425 ;; space doesn't matter
1426 (define_insn ""
1427   [(set (match_operand:HI 0 "general_operand" "=r")
1428         (ashift:HI (match_operand:HI 1 "general_operand" "0")
1429                    (match_operand:HI 2 "expand_shift_operand" "O")))]
1430   "TARGET_TIME"
1431   "*
1432 {
1433   register int i;
1434
1435   for (i = 1; i <= abs(INTVAL(operands[2])); i++)
1436     if (INTVAL(operands[2]) < 0)
1437       output_asm_insn(\"asr %0\", operands);
1438     else
1439       output_asm_insn(\"asl %0\", operands);
1440
1441   return \"\";
1442 }"
1443 ;; longest is 4
1444   [(set (attr "length") (const_int 4))])
1445
1446 ;; aslb
1447 (define_insn ""
1448   [(set (match_operand:QI 0 "general_operand" "=r,o")
1449         (ashift:QI (match_operand:QI 1 "general_operand" "0,0")
1450                    (match_operand:HI 2 "const_immediate_operand" "n,n")))]
1451   ""
1452   "*
1453 { /* allowing predec or post_inc is possible, but hairy! */
1454   int i, cnt;
1455
1456   cnt = INTVAL(operands[2]) & 0x0007;
1457
1458   for (i=0 ; i < cnt ; i++)
1459        output_asm_insn(\"aslb %0\", operands);
1460
1461   return \"\";
1462 }"
1463 ;; set attribute length ( match_dup 2 & 7 ) *(1 or 2) !!!
1464   [(set_attr_alternative "length"
1465                          [(const_int 7)
1466                           (const_int 14)])])
1467
1468 ;;; asr
1469 ;(define_insn ""
1470 ;  [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1471 ;       (ashiftrt:HI (match_operand:HI 1 "general_operand" "0,0")
1472 ;                    (const_int 1)))]
1473 ;  ""
1474 ;  "asr %0"
1475 ;  [(set_attr "length" "1,2")])
1476
1477 ;; asrb
1478 (define_insn ""
1479   [(set (match_operand:QI 0 "general_operand" "=r,o")
1480         (ashiftrt:QI (match_operand:QI 1 "general_operand" "0,0")
1481                      (match_operand:HI 2 "const_immediate_operand" "n,n")))]
1482   ""
1483   "*
1484 { /* allowing predec or post_inc is possible, but hairy! */
1485   int i, cnt;
1486
1487   cnt = INTVAL(operands[2]) & 0x0007;
1488
1489   for (i=0 ; i < cnt ; i++)
1490        output_asm_insn(\"asrb %0\", operands);
1491
1492   return \"\";
1493 }"
1494   [(set_attr_alternative "length"
1495                          [(const_int 7)
1496                           (const_int 14)])])
1497
1498 ;; the following is invalid - too complex!!! - just say 14 !!!
1499 ;  [(set (attr "length") (plus (and (match_dup 2)
1500 ;                                   (const_int 7))
1501 ;                              (and (match_dup 2)
1502 ;                                   (const_int 7))))])
1503
1504
1505
1506 ;; can we get +-1 in the next pattern? should
1507 ;; have been caught by previous patterns!
1508
1509 (define_insn "ashlhi3"
1510   [(set (match_operand:HI 0 "register_operand" "=r,r")
1511         (ashift:HI (match_operand:HI 1 "register_operand" "0,0")
1512                    (match_operand:HI 2 "general_operand" "rR,Qi")))]
1513   ""
1514   "*
1515 {
1516   if (GET_CODE(operands[2]) == CONST_INT)
1517     if (INTVAL(operands[2]) == 1)
1518       return \"asl %0\";
1519     else if (INTVAL(operands[2]) == -1)
1520       return \"asr %0\";
1521
1522   return \"ash %2,%0\";
1523 }"
1524   [(set_attr "length" "1,2")])
1525
1526 ;; Arithmetic right shift on the pdp works by negating the shift count.
1527 (define_expand "ashrhi3"
1528   [(set (match_operand:HI 0 "register_operand" "=r")
1529         (ashift:HI (match_operand:HI 1 "register_operand" "0")
1530                    (match_operand:HI 2 "general_operand" "g")))]
1531   ""
1532   "
1533 {
1534   operands[2] = negate_rtx (HImode, operands[2]);
1535 }")
1536
1537 ;;;;- logical shift instructions
1538 ;;(define_insn "lshrsi3"
1539 ;;  [(set (match_operand:HI 0 "register_operand" "=r")
1540 ;;      (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
1541 ;;                   (match_operand:HI 2 "arith_operand" "rI")))]
1542 ;;  ""
1543 ;;  "srl %0,%2")
1544
1545 ;; absolute
1546
1547 (define_insn "absdf2"
1548   [(set (match_operand:DF 0 "general_operand" "=fR,Q")
1549         (abs:DF (match_operand:DF 1 "general_operand" "0,0")))]
1550   "TARGET_FPU"
1551   "absd %0"
1552   [(set_attr "length" "1,2")])
1553
1554 (define_insn "abshi2"
1555   [(set (match_operand:HI 0 "general_operand" "=r,o")
1556         (abs:HI (match_operand:HI 1 "general_operand" "0,0")))]
1557   "TARGET_ABSHI_BUILTIN"
1558   "*
1559 {
1560   static count = 0;
1561   char buf[200];
1562
1563   output_asm_insn(\"tst %0\", operands);
1564   sprintf(buf, \"bge abshi%d\", count);
1565   output_asm_insn(buf, NULL);
1566   output_asm_insn(\"neg %0\", operands);
1567   sprintf(buf, \"\\nabshi%d:\", count++);
1568   output_asm_insn(buf, NULL);
1569
1570   return \"\";
1571 }"
1572   [(set_attr "length" "3,5")])
1573
1574
1575 ;; define expand abshi - is much better !!! - but
1576 ;; will it be optimized into an abshi2 ?
1577 ;; it will leave better code, because the tsthi might be
1578 ;; optimized away!!
1579 ; -- just a thought - don't have time to check
1580 ;
1581 ;(define_expand "abshi2"
1582 ;  [(match_operand:HI 0 "general_operand" "")
1583 ;   (match_operand:HI 1 "general_operand" "")]
1584 ;  ""
1585 ;  "
1586 ;{
1587 ;  rtx label = gen_label_rtx ();
1588 ;
1589 ;  /* do I need this? */
1590 ;  do_pending_stack_adjust ();
1591 ;
1592 ;  emit_move_insn (operands[0], operands[1]);
1593 ;
1594 ;  emit_insn (gen_tsthi (operands[0]));
1595 ;  emit_insn (gen_bge (label1));
1596 ;
1597 ;  emit_insn (gen_neghi(operands[0], operands[0])
1598 ;
1599 ;  emit_barrier ();
1600 ;
1601 ;  emit_label (label);
1602 ;
1603 ;  /* allow REG_NOTES to be set on last insn (labels don't have enough
1604 ;     fields, and can't be used for REG_NOTES anyway).  */
1605 ;  emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
1606 ;  DONE;
1607 ;}")
1608
1609 ;; negate insns
1610
1611 (define_insn "negdf2"
1612   [(set (match_operand:DF 0 "general_operand" "=fR,Q")
1613         (neg:DF (match_operand:DF 1 "register_operand" "0,0")))]
1614   "TARGET_FPU"
1615   "negd %0"
1616   [(set_attr "length" "1,2")])
1617
1618 (define_insn "neghi2"
1619   [(set (match_operand:HI 0 "general_operand" "=rR,Q")
1620         (neg:HI (match_operand:HI 1 "general_operand" "0,0")))]
1621   ""
1622   "neg %0"
1623   [(set_attr "length" "1,2")])
1624
1625 (define_insn "negqi2"
1626   [(set (match_operand:QI 0 "general_operand" "=rR,Q")
1627         (neg:QI (match_operand:QI 1 "general_operand" "0,0")))]
1628   ""
1629   "negb %0"
1630   [(set_attr "length" "1,2")])
1631
1632
1633 ;; Unconditional and other jump instructions
1634 (define_insn "jump"
1635   [(set (pc)
1636         (label_ref (match_operand 0 "" "")))]
1637   ""
1638   "jmp %l0"
1639   [(set_attr "length" "2")])
1640
1641 (define_insn ""
1642   [(set (pc)
1643     (label_ref (match_operand 0 "" "")))
1644    (clobber (const_int 1))]
1645   ""
1646   "jmp %l0"
1647   [(set_attr "length" "2")])
1648
1649 (define_insn "tablejump"
1650   [(set (pc) (match_operand:HI 0 "general_operand" "rR,Q"))
1651    (use (label_ref (match_operand 1 "" "")))]
1652   ""
1653   "jmp %0"
1654   [(set_attr "length" "1,2")])
1655
1656 ;; indirect jump - let's be conservative!
1657 ;; allow only register_operand, even though we could also
1658 ;; allow labels etc.
1659
1660 (define_insn "indirect_jump"
1661   [(set (pc) (match_operand:HI 0 "register_operand" "r"))]
1662   ""
1663   "jmp (%0)")
1664
1665 ;;- jump to subroutine
1666
1667 (define_insn "call"
1668   [(call (match_operand:HI 0 "general_operand" "R,Q")
1669          (match_operand:HI 1 "general_operand" "g,g"))
1670 ;;   (use (reg:HI 0)) what was that ???
1671   ]
1672   ;;- Don't use operand 1 for most machines.
1673   ""
1674   "jsr pc, %0"
1675   [(set_attr "length" "1,2")])
1676
1677 ;;- jump to subroutine
1678 (define_insn "call_value"
1679   [(set (match_operand 0 "" "")
1680         (call (match_operand:HI 1 "general_operand" "R,Q")
1681               (match_operand:HI 2 "general_operand" "g,g")))
1682 ;;   (use (reg:HI 0)) - what was that ????
1683   ]
1684   ;;- Don't use operand 2 for most machines.
1685   ""
1686   "jsr pc, %1"
1687   [(set_attr "length" "1,2")])
1688
1689 ;;- nop instruction
1690 (define_insn "nop"
1691   [(const_int 0)]
1692   ""
1693   "nop")
1694 \f
1695
1696 ;;- multiply
1697
1698 (define_insn "muldf3"
1699   [(set (match_operand:DF 0 "register_operand" "=a,a,a")
1700         (mult:DF (match_operand:DF 1 "register_operand" "%0,0,0")
1701                  (match_operand:DF 2 "general_operand" "fR,Q,F")))]
1702   "TARGET_FPU"
1703   "muld %2, %0"
1704   [(set_attr "length" "1,2,5")])
1705
1706 ;; 16 bit result multiply:
1707 ;; currently we multiply only into odd registers, so we don't use two
1708 ;; registers - but this is a bit inefficient at times. If we define
1709 ;; a register class for each register, then we can specify properly
1710 ;; which register need which scratch register ....
1711
1712 (define_insn "mulhi3"
1713   [(set (match_operand:HI 0 "register_operand" "=d,d") ; multiply regs
1714         (mult:HI (match_operand:HI 1 "register_operand" "%0,0")
1715                  (match_operand:HI 2 "general_operand" "rR,Qi")))]
1716   "TARGET_45"
1717   "mul %2, %0"
1718   [(set_attr "length" "1,2")])
1719
1720 ;; 32 bit result
1721 (define_expand "mulhisi3"
1722   [(set (match_dup 3)
1723         (match_operand:HI 1 "general_operand" "g,g"))
1724    (set (match_operand:SI 0 "register_operand" "=r,r") ; even numbered!
1725         (mult:SI (truncate:HI
1726                   (match_dup 0))
1727                  (match_operand:HI 2 "general_operand" "rR,Qi")))]
1728   "TARGET_45"
1729   "operands[3] = gen_lowpart(HImode, operands[1]);")
1730
1731 (define_insn ""
1732   [(set (match_operand:SI 0 "register_operand" "=r,r") ; even numbered!
1733         (mult:SI (truncate:HI
1734                   (match_operand:SI 1 "register_operand" "%0,0"))
1735                  (match_operand:HI 2 "general_operand" "rR,Qi")))]
1736   "TARGET_45"
1737   "mul %2, %0"
1738   [(set_attr "length" "1,2")])
1739
1740 ;(define_insn "mulhisi3"
1741 ;  [(set (match_operand:SI 0 "register_operand" "=r,r") ; even numbered!
1742 ;       (mult:SI (truncate:HI
1743 ;                  (match_operand:SI 1 "register_operand" "%0,0"))
1744 ;                (match_operand:HI 2 "general_operand" "rR,Qi")))]
1745 ;  "TARGET_45"
1746 ;  "mul %2, %0"
1747 ;  [(set_attr "length" "1,2")])
1748
1749 ;;- divide
1750 (define_insn "divdf3"
1751   [(set (match_operand:DF 0 "register_operand" "=a,a,a")
1752         (div:DF (match_operand:DF 1 "register_operand" "0,0,0")
1753                 (match_operand:DF 2 "general_operand" "fR,Q,F")))]
1754   "TARGET_FPU"
1755   "divd %2, %0"
1756   [(set_attr "length" "1,2,5")])
1757
1758
1759 (define_expand "divhi3"
1760   [(set (subreg:HI (match_dup 1) 0)
1761         (div:HI (match_operand:SI 1 "general_operand" "0")
1762                 (match_operand:HI 2 "general_operand" "g")))
1763    (set (match_operand:HI 0 "general_operand" "=r")
1764         (subreg:HI (match_dup 1) 0))]
1765   "TARGET_45"
1766   "")
1767
1768 (define_insn ""
1769   [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 0)
1770         (div:HI (match_operand:SI 1 "general_operand" "0")
1771                 (match_operand:HI 2 "general_operand" "g")))]
1772   "TARGET_45"
1773   "div %2,%0"
1774   [(set_attr "length" "2")])
1775
1776 (define_expand "modhi3"
1777   [(set (subreg:HI (match_dup 1) 1)
1778         (mod:HI (match_operand:SI 1 "general_operand" "0")
1779                 (match_operand:HI 2 "general_operand" "g")))
1780    (set (match_operand:HI 0 "general_operand" "=r")
1781         (subreg:HI (match_dup 1) 1))]
1782   "TARGET_45"
1783   "")
1784
1785 (define_insn ""
1786   [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 1)
1787         (mod:HI (match_operand:SI 1 "general_operand" "0")
1788                 (match_operand:HI 2 "general_operand" "g")))]
1789   "TARGET_45"
1790   "div %2,%0"
1791   [(set_attr "length" "2")])
1792
1793 ;(define_expand "divmodhi4"
1794 ;  [(parallel [(set (subreg:HI (match_dup 1) 0)
1795 ;                  (div:HI (match_operand:SI 1 "general_operand" "0")
1796 ;                          (match_operand:HI 2 "general_operand" "g")))
1797 ;              (set (subreg:HI (match_dup 1) 1)
1798 ;                  (mod:HI (match_dup 1)
1799 ;                          (match_dup 2)))])
1800 ;   (set (match_operand:HI 3 "general_operand" "=r")
1801 ;        (subreg:HI (match_dup 1) 1))
1802 ;   (set (match_operand:HI 0 "general_operand" "=r")
1803 ;        (subreg:HI (match_dup 1) 0))]
1804 ;  "TARGET_45"
1805 ;  "")
1806 ;
1807 ;(define_insn ""
1808 ;  [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 0)
1809 ;                  (div:HI (match_operand:SI 1 "general_operand" "0")
1810 ;                          (match_operand:HI 2 "general_operand" "g")))
1811 ;   (set (subreg:HI (match_dup 0) 1)
1812 ;                  (mod:HI (match_dup 1)
1813 ;                          (match_dup 2)))]
1814 ;  "TARGET_45"
1815 ;  "div %2, %0")
1816 ;
1817
1818 ;; is rotate doing the right thing to be included here ????