gcc/config/score/score.md

   1 ;;  Machine description for Sunplus S+CORE
   2 ;;  Copyright (C) 2005
   3 ;;  Free Software Foundation, Inc.
   4 ;;  Contributed by Sunnorth.
   5
   6 ;; This file is part of GCC.
   7
   8 ;; GCC is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation; either version 2, or (at your option)
  11 ;; any later version.
  12
  13 ;; GCC 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 GCC; see the file COPYING.  If not, write to
  20 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 ;; Boston, MA 02110-1301, USA.
  22
  23 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  24
  25 ; branch        conditional branch
  26 ; jump          unconditional jump
  27 ; call          unconditional call
  28 ; load          load instruction(s)
  29 ; store         store instruction(s)
  30 ; cmp           integer compare
  31 ; arith         integer arithmetic instruction
  32 ; move          data movement within same register set
  33 ; const         load constant
  34 ; nop           no operation
  35 ; mul           integer multiply
  36 ; div           integer divide
  37 ; cndmv         conditional moves
  38 ; fce           transfer from hi/lo registers
  39 ; tce           transfer to   hi/lo registers
  40 ; fsr           transfer from special registers
  41 ; tsr           transfer to   special registers
  42 ; pseudo        pseudo instruction
  43
  44 (define_constants
  45   [(CC_REGNUM       33)
  46    (T_REGNUM        34)
  47    (RA_REGNUM       3)
  48    (SP_REGNUM       0)
  49    (AT_REGNUM       1)
  50    (FP_REGNUM       2)
  51    (RT_REGNUM       4)
  52    (GP_REGNUM       28)
  53    (EH_REGNUM       29)
  54    (HI_REGNUM       48)
  55    (LO_REGNUM       49)
  56    (CN_REGNUM       50)
  57    (LC_REGNUM       51)
  58    (SC_REGNUM       52)])
  59
  60 (define_constants
  61    [(BITTST         0)
  62     (LOAD_ADD       1)
  63     (STORE_ADD      2)
  64
  65     (SCB            3)
  66     (SCW            4)
  67     (SCE            5)
  68     (SCLC           6)
  69
  70     (LCB            7)
  71     (LCW            8)
  72     (LCE            9)
  73
  74     (SFFS           10)])
  75
  76 (define_attr "type"
  77   "unknown,branch,jump,call,load,store,cmp,arith,move,const,nop,mul,div,cndmv,fce,tce,fsr,tsr,fcr,tcr,pseudo"
  78   (const_string "unknown"))
  79
  80 (define_attr "mode" "unknown,none,QI,HI,SI,DI"
  81   (const_string "unknown"))
  82
  83 (define_attr "up_c" "yes,no"
  84   (const_string "no"))
  85
  86 (include "score7.md")
  87 (include "predicates.md")
  88 (include "misc.md")
  89 (include "mac.md")
  90
  91 (define_insn "movqi"
  92   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,m,d,*x,d,*a")
  93         (match_operand:QI 1 "general_operand" "i,d,m,d,*x,d,*a,d"))]
  94   ""
  95 {
  96   switch (which_alternative)
  97     {
  98     case 0: return mdp_limm (operands);
  99     case 1: return mdp_move (operands);
 100     case 2: return mdp_linsn (operands, MDA_BYTE, false);
 101     case 3: return mdp_sinsn (operands, MDA_BYTE);
 102     case 4: return TARGET_MAC ? \"mf%1%S0 %0\" : \"mf%1    %0\";
 103     case 5: return TARGET_MAC ? \"mt%0%S1 %1\" : \"mt%0    %1\";
 104     case 6: return \"mfsr    %0, %1\";
 105     case 7: return \"mtsr    %1, %0\";
 106     default: gcc_unreachable ();
 107     }
 108 }
 109   [(set_attr "type" "arith,move,load,store,fce,tce,fsr,tsr")
 110    (set_attr "mode" "QI")])
 111
 112 (define_insn "movhi"
 113   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d,m,d,*x,d,*a")
 114         (match_operand:HI 1 "general_operand" "i,d,m,d,*x,d,*a,d"))]
 115   ""
 116 {
 117   switch (which_alternative)
 118     {
 119     case 0: return mdp_limm (operands);
 120     case 1: return mdp_move (operands);
 121     case 2: return mdp_linsn (operands, MDA_HWORD, false);
 122     case 3: return mdp_sinsn (operands, MDA_HWORD);
 123     case 4: return TARGET_MAC ? \"mf%1%S0 %0\" : \"mf%1    %0\";
 124     case 5: return TARGET_MAC ? \"mt%0%S1 %1\" : \"mt%0    %1\";
 125     case 6: return \"mfsr    %0, %1\";
 126     case 7: return \"mtsr    %1, %0\";
 127     default: gcc_unreachable ();
 128     }
 129 }
 130   [(set_attr "type" "arith,move,load,store,fce,tce,fsr,tsr")
 131    (set_attr "mode" "HI")])
 132
 133 (define_insn "movsi"
 134   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d,m,d,*x,d,*a,d,c")
 135         (match_operand:SI 1 "general_operand" "i,d,m,d,*x,d,*a,d,c,d"))]
 136   ""
 137 {
 138   switch (which_alternative)
 139     {
 140     case 0:
 141       if (GET_CODE (operands[1]) != CONST_INT)
 142         return \"la      %0, %1\";
 143       else
 144         return mdp_limm (operands);
 145     case 1: return mdp_move (operands);
 146     case 2: return mdp_linsn (operands, MDA_WORD, false);
 147     case 3: return mdp_sinsn (operands, MDA_WORD);
 148     case 4: return TARGET_MAC ? \"mf%1%S0 %0\" : \"mf%1    %0\";
 149     case 5: return TARGET_MAC ? \"mt%0%S1 %1\" : \"mt%0    %1\";
 150     case 6: return \"mfsr    %0, %1\";
 151     case 7: return \"mtsr    %1, %0\";
 152     case 8: return \"mfcr    %0, %1\";
 153     case 9: return \"mtcr    %1, %0\";
 154     default: gcc_unreachable ();
 155     }
 156 }
 157   [(set_attr "type" "arith,move,load,store,fce,tce,fsr,tsr,fcr,tcr")
 158    (set_attr "mode" "SI")])
 159
 160 (define_insn_and_split "movdi"
 161   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,m,d,*x")
 162         (match_operand:DI 1 "general_operand" "i,d,m,d,*x,d"))]
 163   ""
 164   "#"
 165   "reload_completed"
 166   [(const_int 0)]
 167 {
 168   mds_movdi (operands);
 169   DONE;
 170 })
 171
 172 (define_insn "addsi3"
 173   [(set (match_operand:SI 0 "register_operand" "=d,d,d")
 174         (plus:SI (match_operand:SI 1 "register_operand" "0,d,%d")
 175                  (match_operand:SI 2 "arith_operand" "L,N,d")))]
 176   ""
 177   "@
 178    addi    %0, %c2
 179    addri   %0, %1, %c2
 180    add     %0, %1, %2"
 181   [(set_attr "type" "arith")
 182    (set_attr "mode" "SI")])
 183
 184 (define_insn "*addsi3_cmp"
 185   [(set (reg:CC_NZ CC_REGNUM)
 186         (compare:CC_NZ (plus:SI (match_operand:SI 0 "register_operand" "d,d,d")
 187                                 (match_operand:SI 1 "arith_operand" "N,L,d"))
 188                        (const_int 0)))]
 189   ""
 190   "@
 191    %[       addri.c r1, %0, %c1       %]
 192    %[       m%V0    r1, %0\;addi.c  r1, %2        %]
 193    %[       add.c   r1, %0, %1        %]"
 194   [(set_attr "type" "arith")
 195    (set_attr "up_c" "yes")
 196    (set_attr "mode" "SI")])
 197
 198 (define_insn "addsi3_ucc"
 199   [(set (reg:CC_NZ CC_REGNUM)
 200         (compare:CC_NZ (plus:SI (match_operand:SI 1 "register_operand" "0,d,d")
 201                                 (match_operand:SI 2 "arith_operand" "L,N,d"))
 202                        (const_int 0)))
 203    (set (match_operand:SI 0 "register_operand" "=d,d,d")
 204         (plus:SI (match_dup 1) (match_dup 2)))]
 205   ""
 206 {
 207   switch (which_alternative)
 208     {
 209     case 0: return mdp_add_imm_ucc (operands);
 210     case 1: return \"addri.c %0, %1, %c2\";
 211     case 2: return mdp_select (operands, "add", true, "");
 212     default: gcc_unreachable ();
 213     }
 214 }
 215   [(set_attr "type" "arith")
 216    (set_attr "up_c" "yes")
 217    (set_attr "mode" "SI")])
 218
 219 (define_insn "adddi3"
 220   [(set (match_operand:DI 0 "register_operand" "=*e,d")
 221         (plus:DI (match_operand:DI 1 "register_operand" "*0,d")
 222                  (match_operand:DI 2 "register_operand" "*e,d")))
 223   (clobber (reg:CC CC_REGNUM))]
 224   ""
 225   "@
 226    add!    %L0, %L2\;addc!   %H0, %H2
 227    add.c   %L0, %L1, %L2\;addc    %H0, %H1, %H2"
 228   [(set_attr "type" "arith")
 229    (set_attr "mode" "DI")])
 230
 231 (define_insn "subsi3"
 232   [(set (match_operand:SI 0 "register_operand" "=d")
 233         (minus:SI (match_operand:SI 1 "register_operand" "d")
 234                   (match_operand:SI 2 "register_operand" "d")))]
 235   ""
 236   "sub     %0, %1, %2"
 237   [(set_attr "type" "arith")
 238    (set_attr "mode" "SI")])
 239
 240 (define_insn "*subsi3_cmp"
 241   [(set (reg:CC_NZ CC_REGNUM)
 242         (compare:CC_NZ (minus:SI (match_operand:SI 0 "register_operand" "d")
 243                                  (match_operand:SI 1 "register_operand" "d"))
 244                        (const_int 0)))]
 245   ""
 246   "%[        sub.c   r1, %0, %1        %]"
 247   [(set_attr "type" "arith")
 248    (set_attr "up_c" "yes")
 249    (set_attr "mode" "SI")])
 250
 251 (define_peephole2
 252   [(set (match_operand:SI 0 "g32reg_operand" "")
 253         (minus:SI (match_operand:SI 1 "g32reg_operand" "")
 254                   (match_operand:SI 2 "g32reg_operand" "")))
 255    (set (reg:CC CC_REGNUM)
 256         (compare:CC (match_dup 1) (match_dup 2)))]
 257   ""
 258   [(parallel
 259        [(set (reg:CC CC_REGNUM)
 260              (compare:CC (match_dup 1) (match_dup 2)))
 261         (set (match_dup 0)
 262              (minus:SI (match_dup 1) (match_dup 2)))])])
 263
 264 (define_insn "subsi3_ucc_pcmp"
 265   [(parallel
 266        [(set (reg:CC CC_REGNUM)
 267              (compare:CC (match_operand:SI 1 "register_operand" "d")
 268                          (match_operand:SI 2 "register_operand" "d")))
 269         (set (match_operand:SI 0 "register_operand" "=d")
 270              (minus:SI (match_dup 1) (match_dup 2)))])]
 271   ""
 272 {
 273   return mdp_select (operands, "sub", false, "");
 274 }
 275   [(set_attr "type" "arith")
 276    (set_attr "up_c" "yes")
 277    (set_attr "mode" "SI")])
 278
 279 (define_insn "subsi3_ucc"
 280   [(set (reg:CC_NZ CC_REGNUM)
 281         (compare:CC_NZ (minus:SI (match_operand:SI 1 "register_operand" "d")
 282                                  (match_operand:SI 2 "register_operand" "d"))
 283                        (const_int 0)))
 284    (set (match_operand:SI 0 "register_operand" "=d")
 285         (minus:SI (match_dup 1) (match_dup 2)))]
 286   ""
 287 {
 288   return mdp_select (operands, "sub", false, "");
 289 }
 290   [(set_attr "type" "arith")
 291    (set_attr "up_c" "yes")
 292    (set_attr "mode" "SI")])
 293
 294 (define_insn "subdi3"
 295   [(set (match_operand:DI 0 "register_operand" "=*e,d")
 296         (minus:DI (match_operand:DI 1 "register_operand" "*0,d")
 297                   (match_operand:DI 2 "register_operand" "*e,d")))
 298    (clobber (reg:CC CC_REGNUM))]
 299   ""
 300   "@
 301    sub!    %L0, %L2\;subc    %H0, %H1, %H2
 302    sub.c   %L0, %L1, %L2\;subc    %H0, %H1, %H2"
 303   [(set_attr "type" "arith")
 304    (set_attr "mode" "DI")])
 305
 306 (define_insn "andsi3"
 307   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
 308         (and:SI (match_operand:SI 1 "register_operand" "0,0,d,d")
 309                 (match_operand:SI 2 "arith_operand" "K,Q,M,d")))]
 310   ""
 311   "@
 312    andi    %0, %c2
 313    andis   %0, %U2
 314    andri   %0, %1, %c2
 315    and     %0, %1, %2"
 316   [(set_attr "type" "arith")
 317    (set_attr "mode" "SI")])
 318
 319 (define_insn "andsi3_cmp"
 320   [(set (reg:CC_NZ CC_REGNUM)
 321         (compare:CC_NZ (and:SI (match_operand:SI 0 "register_operand" "d,d,d,d")
 322                                (match_operand:SI 1 "arith_operand" "M,K,Q,d"))
 323                        (const_int 0)))]
 324   ""
 325   "@
 326    %[        andri.c r1, %0, %c1      %]
 327    %[        m%V0    r1, %0\;andi.c  r1, %c1        %]
 328    %[        m%V0    r1, %0\;andis.c r1, %U1        %]
 329    %[        and.c   r1, %0, %1       %]"
 330   [(set_attr "type" "arith")
 331    (set_attr "up_c" "yes")
 332    (set_attr "mode" "SI")])
 333
 334 (define_insn "andsi3_ucc"
 335   [(set (reg:CC_NZ CC_REGNUM)
 336         (compare:CC_NZ (and:SI
 337                         (match_operand:SI 1 "register_operand" "0,0,d,d")
 338                         (match_operand:SI 2 "arith_operand" "K,Q,M,d"))
 339                        (const_int 0)))
 340    (set (match_operand:SI 0 "register_operand" "=d,d,d,d")
 341         (and:SI (match_dup 1) (match_dup 2)))]
 342   ""
 343 {
 344   switch (which_alternative)
 345     {
 346     case 0:  return \"andi.c  %0, %c2\";
 347     case 1:  return \"andis.c %0, %U2\";
 348     case 2:  return \"andri.c %0, %1, %c2\";
 349     case 3:  return mdp_select (operands, "and", true, "");
 350     default: gcc_unreachable ();
 351     }
 352 }
 353   [(set_attr "type" "arith")
 354    (set_attr "up_c" "yes")
 355    (set_attr "mode" "SI")])
 356
 357 (define_insn_and_split "*zero_extract_andi"
 358   [(set (reg:CC_NZ CC_REGNUM)
 359         (compare:CC_NZ (zero_extract:SI
 360                         (match_operand:SI 0 "register_operand" "d")
 361                         (match_operand:SI 1 "const_bi_operand" "")
 362                         (match_operand:SI 2 "const_bi_operand" ""))
 363                        (const_int 0)))]
 364   ""
 365   "#"
 366   ""
 367   [(const_int 1)]
 368 {
 369   mds_zero_extract_andi (operands);
 370   DONE;
 371 })
 372
 373 (define_insn "iorsi3"
 374   [(set (match_operand:SI 0 "register_operand" "=d,d,d,d")
 375         (ior:SI (match_operand:SI 1 "register_operand" "0,0,d,d")
 376                 (match_operand:SI 2 "arith_operand" "K,Q,M,d")))]
 377   ""
 378   "@
 379    ori     %0, %c2
 380    oris    %0, %U2
 381    orri    %0, %1, %c2
 382    or      %0, %1, %2"
 383   [(set_attr "type" "arith")
 384    (set_attr "mode" "SI")])
 385
 386 (define_insn "iorsi3_ucc"
 387   [(set (reg:CC_NZ CC_REGNUM)
 388         (compare:CC_NZ (ior:SI (match_operand:SI 1 "register_operand" "d")
 389                                (match_operand:SI 2 "register_operand" "d"))
 390                        (const_int 0)))
 391    (set (match_operand:SI 0 "register_operand" "=d")
 392         (ior:SI (match_dup 1) (match_dup 2)))]
 393   ""
 394 {
 395   return mdp_select (operands, "or", true, "");
 396 }
 397   [(set_attr "type" "arith")
 398    (set_attr "up_c" "yes")
 399    (set_attr "mode" "SI")])
 400
 401 (define_insn "iorsi3_cmp"
 402   [(set (reg:CC_NZ CC_REGNUM)
 403         (compare:CC_NZ (ior:SI (match_operand:SI 0 "register_operand" "d")
 404                                (match_operand:SI 1 "register_operand" "d"))
 405                        (const_int 0)))]
 406   ""
 407   "%[        or.c    r1, %0, %1       %]"
 408   [(set_attr "type" "arith")
 409    (set_attr "up_c" "yes")
 410    (set_attr "mode" "SI")])
 411
 412 (define_insn "xorsi3"
 413   [(set (match_operand:SI 0 "register_operand" "=d")
 414         (xor:SI (match_operand:SI 1 "register_operand" "d")
 415                 (match_operand:SI 2 "register_operand" "d")))]
 416   ""
 417   "xor     %0, %1, %2"
 418   [(set_attr "type" "arith")
 419    (set_attr "mode" "SI")])
 420
 421 (define_insn "xorsi3_ucc"
 422   [(set (reg:CC_NZ CC_REGNUM)
 423         (compare:CC_NZ (xor:SI (match_operand:SI 1 "register_operand" "d")
 424                                (match_operand:SI 2 "register_operand" "d"))
 425                        (const_int 0)))
 426    (set (match_operand:SI 0 "register_operand" "=d")
 427         (xor:SI (match_dup 1) (match_dup 2)))]
 428   ""
 429 {
 430   return mdp_select (operands, "xor", true, "");
 431 }
 432   [(set_attr "type" "arith")
 433    (set_attr "up_c" "yes")
 434    (set_attr "mode" "SI")])
 435
 436 (define_insn "xorsi3_cmp"
 437   [(set (reg:CC_NZ CC_REGNUM)
 438         (compare:CC_NZ (xor:SI (match_operand:SI 0 "register_operand" "d")
 439                                (match_operand:SI 1 "register_operand" "d"))
 440                        (const_int 0)))]
 441   ""
 442   "%[        xor.c   r1, %0, %1       %]"
 443   [(set_attr "type" "arith")
 444    (set_attr "up_c" "yes")
 445    (set_attr "mode" "SI")])
 446
 447 (define_insn "extendqisi2"
 448   [(set (match_operand:SI 0 "register_operand" "=d,d")
 449         (sign_extend:SI (match_operand:QI 1 "nonimmediate_operand" "d,m")))]
 450   ""
 451 {
 452   switch (which_alternative)
 453     {
 454     case 0: return \"extsb   %0, %1\";
 455     case 1: return mdp_linsn (operands, MDA_BYTE, true);
 456     default: gcc_unreachable ();
 457     }
 458 }
 459   [(set_attr "type" "arith,load")
 460    (set_attr "mode" "SI")])
 461
 462 (define_insn "extendqisi2_cmp"
 463   [(set (reg:CC_N CC_REGNUM)
 464         (compare:CC_N (ashiftrt:SI
 465                        (ashift:SI (match_operand:SI 0 "register_operand" "d")
 466                                   (const_int 24))
 467                        (const_int 24))
 468                       (const_int 0)))]
 469   ""
 470   "%[        extsb.c r1, %0       %]"
 471   [(set_attr "type" "arith")
 472    (set_attr "up_c" "yes")
 473    (set_attr "mode" "SI")])
 474
 475 (define_insn "extendqisi2_ucc"
 476   [(set (reg:CC_N CC_REGNUM)
 477         (compare:CC_N (ashiftrt:SI
 478                        (ashift:SI (match_operand:SI 1 "register_operand" "d")
 479                                   (const_int 24))
 480                        (const_int 24))
 481                       (const_int 0)))
 482    (set (match_operand:SI 0 "register_operand" "=d")
 483         (sign_extend:SI (match_operand:QI 2 "register_operand" "0")))]
 484   ""
 485   "extsb.c %0, %1"
 486   [(set_attr "type" "arith")
 487    (set_attr "up_c" "yes")
 488    (set_attr "mode" "SI")])
 489
 490 (define_insn "zero_extendqisi2"
 491   [(set (match_operand:SI 0 "register_operand""=d,d")
 492         (zero_extend:SI (match_operand:QI 1 "register_operand" "d,m")))]
 493   ""
 494 {
 495   switch (which_alternative)
 496     {
 497     case 0: return \"extzb   %0, %1\";
 498     case 1: return mdp_linsn (operands, MDA_BYTE, false);
 499     default: gcc_unreachable ();
 500     }
 501 }
 502   [(set_attr "type" "arith, load")
 503    (set_attr "mode" "SI")])
 504
 505 (define_insn "extendhisi2"
 506   [(set (match_operand:SI 0 "register_operand" "=d,d")
 507         (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d,m")))]
 508   ""
 509 {
 510   switch (which_alternative)
 511     {
 512     case 0: return \"extsh   %0, %1\";
 513     case 1: return mdp_linsn (operands, MDA_HWORD, true);
 514     default: gcc_unreachable ();
 515     }
 516 }
 517   [(set_attr "type" "arith, load")
 518    (set_attr "mode" "SI")])
 519
 520 (define_insn "extendhisi2_cmp"
 521   [(set (reg:CC_N CC_REGNUM)
 522         (compare:CC_N (ashiftrt:SI
 523                        (ashift:SI (match_operand:SI 0 "register_operand" "d")
 524                                   (const_int 16))
 525                        (const_int 16))
 526                       (const_int 0)))]
 527   ""
 528   "%[        extsh.c r1, %0       %]"
 529   [(set_attr "type" "arith")
 530    (set_attr "up_c" "yes")
 531    (set_attr "mode" "SI")])
 532
 533 (define_insn "extendhisi2_ucc"
 534   [(set (reg:CC_N CC_REGNUM)
 535         (compare:CC_N (ashiftrt:SI
 536                        (ashift:SI (match_operand:SI 1 "register_operand" "d")
 537                                   (const_int 16))
 538                        (const_int 16))
 539                       (const_int 0)))
 540   (set (match_operand:SI 0 "register_operand" "=d")
 541        (sign_extend:SI (match_operand:HI 2 "register_operand" "0")))]
 542   ""
 543   "extsh.c %0, %1"
 544   [(set_attr "type" "arith")
 545    (set_attr "up_c" "yes")
 546    (set_attr "mode" "SI")])
 547
 548 (define_insn "zero_extendhisi2"
 549   [(set (match_operand:SI 0 "register_operand" "=d,d")
 550         (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "d,m")))]
 551   ""
 552 {
 553   switch (which_alternative)
 554     {
 555     case 0: return \"extzh   %0, %1\";
 556     case 1: return mdp_linsn (operands, MDA_HWORD, false);
 557     default: gcc_unreachable ();
 558     }
 559   }
 560   [(set_attr "type" "arith, load")
 561    (set_attr "mode" "SI")])
 562
 563 (define_insn "mulsi3"
 564   [(set (match_operand:SI 0 "register_operand" "=l")
 565         (mult:SI (match_operand:SI 1 "register_operand" "d")
 566                  (match_operand:SI 2 "register_operand" "d")))
 567   (clobber (reg:SI HI_REGNUM))]
 568   "!TARGET_SCORE5U"
 569   "mul     %1, %2"
 570   [(set_attr "type" "mul")
 571    (set_attr "mode" "SI")])
 572
 573 (define_insn "mulsidi3"
 574   [(set (match_operand:DI 0 "register_operand" "=x")
 575         (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "d"))
 576                  (sign_extend:DI
 577                   (match_operand:SI 2 "register_operand" "d"))))]
 578   "!TARGET_SCORE5U"
 579   "mul     %1, %2"
 580   [(set_attr "type" "mul")
 581    (set_attr "mode" "DI")])
 582
 583 (define_insn "umulsidi3"
 584   [(set (match_operand:DI 0 "register_operand" "=x")
 585         (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "d"))
 586                  (zero_extend:DI
 587                   (match_operand:SI 2 "register_operand" "d"))))]
 588   "!TARGET_SCORE5U"
 589   "mulu    %1, %2"
 590   [(set_attr "type" "mul")
 591    (set_attr "mode" "DI")])
 592
 593 (define_insn "divmodsi4"
 594   [(set (match_operand:SI 0 "register_operand" "=l")
 595         (div:SI (match_operand:SI 1 "register_operand" "d")
 596                 (match_operand:SI 2 "register_operand" "d")))
 597    (set (match_operand:SI 3 "register_operand" "=h")
 598         (mod:SI (match_dup 1) (match_dup 2)))]
 599   "!TARGET_SCORE5U"
 600   "div     %1, %2"
 601   [(set_attr "type" "div")
 602    (set_attr "mode" "SI")])
 603
 604 (define_insn "udivmodsi4"
 605   [(set (match_operand:SI 0 "register_operand" "=l")
 606         (udiv:SI (match_operand:SI 1 "register_operand" "d")
 607                  (match_operand:SI 2 "register_operand" "d")))
 608    (set (match_operand:SI 3 "register_operand" "=h")
 609         (umod:SI (match_dup 1) (match_dup 2)))]
 610   "!TARGET_SCORE5U"
 611   "divu    %1, %2"
 612   [(set_attr "type" "div")
 613    (set_attr "mode" "SI")])
 614
 615 (define_insn "ashlsi3"
 616   [(set (match_operand:SI 0 "register_operand" "=d,d")
 617         (ashift:SI (match_operand:SI 1 "register_operand" "d,d")
 618                    (match_operand:SI 2 "arith_operand" "J,d")))]
 619   ""
 620   "@
 621    slli    %0, %1, %c2
 622    sll     %0, %1, %2"
 623   [(set_attr "type" "arith")
 624    (set_attr "mode" "SI")])
 625
 626 (define_insn "ashlsi3_ucc"
 627   [(set (reg:CC_NZ CC_REGNUM)
 628         (compare:CC_NZ (ashift:SI
 629                         (match_operand:SI 1 "register_operand" "d,d")
 630                         (match_operand:SI 2 "arith_operand" "J,d"))
 631                        (const_int 0)))
 632    (set (match_operand:SI 0 "register_operand" "=d,d")
 633         (ashift:SI (match_dup 1) (match_dup 2)))]
 634   ""
 635 {
 636   switch (which_alternative)
 637     {
 638     case 0: return mdp_select (operands, "slli", false, "c");
 639     case 1: return mdp_select (operands, "sll", false, "");
 640     default: gcc_unreachable ();
 641     }
 642 }
 643   [(set_attr "type" "arith")
 644    (set_attr "up_c" "yes")
 645    (set_attr "mode" "SI")])
 646
 647 (define_insn "ashlsi3_cmp"
 648   [(set (reg:CC_NZ CC_REGNUM)
 649         (compare:CC_NZ (ashift:SI
 650                         (match_operand:SI 0 "register_operand" "d,d")
 651                         (match_operand:SI 1 "arith_operand" "J,d"))
 652                        (const_int 0)))]
 653   ""
 654   "@
 655    %[        slli.c  r1, %0, %c1      %]
 656    %[        sll.c   r1, %0, %1       %]"
 657   [(set_attr "type" "arith")
 658    (set_attr "up_c" "yes")
 659    (set_attr "mode" "SI")])
 660
 661 (define_insn "ashrsi3"
 662   [(set (match_operand:SI 0 "register_operand" "=d,d")
 663         (ashiftrt:SI (match_operand:SI 1 "register_operand" "d,d")
 664                      (match_operand:SI 2 "arith_operand" "J,d")))]
 665   ""
 666   "@
 667    srai    %0, %1, %c2
 668    sra     %0, %1, %2"
 669   [(set_attr "type" "arith")
 670    (set_attr "mode" "SI")])
 671
 672 (define_insn "ashrsi3_ucc"
 673   [(set (reg:CC_NZ CC_REGNUM)
 674         (compare:CC_NZ (ashiftrt:SI
 675                         (match_operand:SI 1 "register_operand" "d,d")
 676                         (match_operand:SI 2 "arith_operand" "J,d"))
 677                        (const_int 0)))
 678    (set (match_operand:SI 0 "register_operand" "=d,d")
 679         (ashiftrt:SI (match_dup 1) (match_dup 2)))]
 680   ""
 681 {
 682   switch (which_alternative)
 683     {
 684     case 0: return \"srai.c  %0, %1, %c2\";
 685     case 1: return mdp_select (operands, "sra", false, "");
 686     default: gcc_unreachable ();
 687     }
 688 }
 689   [(set_attr "type" "arith")
 690    (set_attr "up_c" "yes")
 691    (set_attr "mode" "SI")])
 692
 693 (define_insn "ashrsi3_cmp"
 694   [(set (reg:CC_NZ CC_REGNUM)
 695         (compare:CC_NZ (ashiftrt:SI
 696                         (match_operand:SI 0 "register_operand" "d,d")
 697                         (match_operand:SI 1 "arith_operand" "J,d"))
 698                        (const_int 0)))]
 699   ""
 700   "@
 701    %[        srai.c  r1, %0, %c1      %]
 702    %[        sra.c   r1, %0, %1       %]"
 703   [(set_attr "type" "arith")
 704    (set_attr "up_c" "yes")
 705    (set_attr "mode" "SI")])
 706
 707 (define_insn "ashrsi3_ucc_n"
 708   [(set (reg:CC_N CC_REGNUM)
 709         (compare:CC_N (ashiftrt:SI
 710                        (match_operand:SI 1 "register_operand" "d,d")
 711                        (match_operand:SI 2 "arith_operand" "J,d"))
 712                       (const_int 0)))
 713    (set (match_operand:SI 0 "register_operand" "=d,d")
 714         (ashiftrt:SI (match_dup 1) (match_dup 2)))]
 715   ""
 716 {
 717   switch (which_alternative)
 718     {
 719     case 0: return \"srai.c  %0, %1, %c2\";
 720     case 1: return mdp_select (operands, "sra", false, "");
 721     default: gcc_unreachable ();
 722     }
 723 }
 724   [(set_attr "type" "arith")
 725    (set_attr "up_c" "yes")
 726    (set_attr "mode" "SI")])
 727
 728 (define_insn "ashrsi3_cmp_n"
 729   [(set (reg:CC_N CC_REGNUM)
 730         (compare:CC_N (ashiftrt:SI
 731                        (match_operand:SI 0 "register_operand" "d,d")
 732                        (match_operand:SI 1 "arith_operand" "J,d"))
 733                       (const_int 0)))]
 734   ""
 735   "@
 736    %[        srai.c  r1, %0, %c1      %]
 737    %[        sra.c   r1, %0, %1       %]"
 738   [(set_attr "type" "arith")
 739    (set_attr "up_c" "yes")
 740    (set_attr "mode" "SI")])
 741
 742 (define_insn "lshrsi3"
 743   [(set (match_operand:SI 0 "register_operand" "=d,d")
 744         (lshiftrt:SI (match_operand:SI 1 "register_operand" "d,d")
 745                      (match_operand:SI 2 "arith_operand" "J,d")))]
 746   ""
 747   "@
 748    srli    %0, %1, %c2
 749    srl     %0, %1, %2"
 750   [(set_attr "type" "arith")
 751    (set_attr "mode" "SI")])
 752
 753 (define_insn "lshrsi3_ucc"
 754   [(set (reg:CC_NZ CC_REGNUM)
 755         (compare:CC_NZ (lshiftrt:SI
 756                         (match_operand:SI 1 "register_operand" "d,d")
 757                         (match_operand:SI 2 "arith_operand" "J,d"))
 758                        (const_int 0)))
 759    (set (match_operand:SI 0 "register_operand" "=d,d")
 760         (lshiftrt:SI (match_dup 1) (match_dup 2)))]
 761   ""
 762 {
 763   switch (which_alternative)
 764     {
 765     case 0: return mdp_select (operands, "srli", false, "c");
 766     case 1: return mdp_select (operands, "srl", false, "");
 767     default: gcc_unreachable ();
 768     }
 769 }
 770   [(set_attr "type" "arith")
 771    (set_attr "up_c" "yes")
 772    (set_attr "mode" "SI")])
 773
 774 (define_insn "lshrsi3_cmp"
 775   [(set (reg:CC_NZ CC_REGNUM)
 776         (compare:CC_NZ (lshiftrt:SI
 777                         (match_operand:SI 0 "register_operand" "d,d")
 778                         (match_operand:SI 1 "arith_operand" "J,d"))
 779                        (const_int 0)))]
 780   ""
 781   "@
 782    %[        srli.c  r1, %0, %c1      %]
 783    %[        srl.c   r1, %0, %1       %]"
 784   [(set_attr "type" "arith")
 785    (set_attr "up_c" "yes")
 786    (set_attr "mode" "SI")])
 787
 788 (define_insn "negsi2"
 789   [(set (match_operand:SI 0 "register_operand" "=d")
 790         (neg:SI (match_operand:SI 1 "register_operand" "d")))]
 791   ""
 792   "neg     %0, %1"
 793   [(set_attr "type" "arith")
 794    (set_attr "mode" "SI")])
 795
 796 (define_insn "negsi2_ucc"
 797   [(set (reg:CC CC_REGNUM)
 798         (compare:CC (neg:SI (match_operand:SI 1 "register_operand" "*e,d"))
 799                     (const_int 0)))
 800    (set (match_operand:SI 0 "register_operand" "=*e,d")
 801         (neg:SI (match_dup 1)))]
 802   ""
 803   "@
 804    neg!    %0, %1
 805    neg.c   %0, %1"
 806   [(set_attr "type" "arith")
 807    (set_attr "up_c" "yes")
 808    (set_attr "mode" "SI")])
 809
 810 (define_insn "one_cmplsi2"
 811   [(set (match_operand:SI 0 "register_operand" "=d")
 812         (not:SI (match_operand:SI 1 "register_operand" "d")))]
 813   ""
 814   "not     %0, %1"
 815   [(set_attr "type" "arith")
 816    (set_attr "mode" "SI")])
 817
 818 (define_insn "one_cmplsi2_ucc"
 819   [(set (reg:CC_NZ CC_REGNUM)
 820         (compare:CC_NZ (not:SI (match_operand:SI 1 "register_operand" "*e,d"))
 821                        (const_int 0)))
 822    (set (match_operand:SI 0 "register_operand" "=*e,d")
 823         (not:SI (match_dup 1)))]
 824   ""
 825   "@
 826    not!    %0, %1
 827    not.c   %0, %1"
 828   [(set_attr "type" "arith")
 829    (set_attr "up_c" "yes")
 830    (set_attr "mode" "SI")])
 831
 832 (define_insn "one_cmplsi2_cmp"
 833   [(set (reg:CC_NZ CC_REGNUM)
 834         (compare:CC_NZ (not:SI (match_operand:SI 0 "register_operand" "*e,d"))
 835                        (const_int 0)))]
 836   ""
 837   "@
 838    %[        not!    r1, %0       %]
 839    %[        not.c   r1, %0       %]"
 840   [(set_attr "type" "arith")
 841    (set_attr "up_c" "yes")
 842    (set_attr "mode" "SI")])
 843
 844 (define_insn "rotlsi3"
 845   [(set (match_operand:SI 0 "register_operand" "=d,d")
 846         (rotate:SI (match_operand:SI 1 "register_operand" "d,d")
 847                    (match_operand:SI 2 "arith_operand" "J,d")))
 848    (clobber (reg:CC CC_REGNUM))]
 849   ""
 850   "@
 851    roli.c  %0, %1, %c2
 852    rol.c   %0, %1, %2"
 853   [(set_attr "type" "arith")
 854    (set_attr "mode" "SI")])
 855
 856 (define_insn "rotrsi3"
 857   [(set (match_operand:SI 0 "register_operand" "=d,d")
 858         (rotatert:SI (match_operand:SI 1 "register_operand" "d,d")
 859                      (match_operand:SI 2 "arith_operand" "J,d")))
 860    (clobber (reg:CC CC_REGNUM))]
 861   ""
 862   "@
 863    rori.c  %0, %1, %c2
 864    ror.c   %0, %1, %2"
 865   [(set_attr "type" "arith")
 866    (set_attr "mode" "SI")])
 867
 868 (define_expand "cmpsi"
 869   [(match_operand:SI 0 "register_operand" "")
 870    (match_operand:SI 1 "arith_operand" "")]
 871   ""
 872 {
 873   cmp_op0 = operands[0];
 874   cmp_op1 = operands[1];
 875   DONE;
 876 })
 877
 878 (define_insn "cmpsi_nz"
 879   [(set (reg:CC_NZ CC_REGNUM)
 880         (compare:CC_NZ (match_operand:SI 0 "register_operand" "d,*e,d")
 881                        (match_operand:SI 1 "arith_operand" "L,*e,d")))]
 882   ""
 883   "@
 884    cmpi.c  %0, %c1
 885    cmp!    %0, %1
 886    cmp.c   %0, %1"
 887    [(set_attr "type" "cmp")
 888     (set_attr "up_c" "yes")
 889     (set_attr "mode" "SI")])
 890
 891 (define_insn "cmpsi_n"
 892   [(set (reg:CC_N CC_REGNUM)
 893         (compare:CC_N (match_operand:SI 0 "register_operand" "d,*e,d")
 894                       (match_operand:SI 1 "arith_operand" "L,*e,d")))]
 895   ""
 896   "@
 897    cmpi.c  %0, %c1
 898    cmp!    %0, %1
 899    cmp.c   %0, %1"
 900    [(set_attr "type" "cmp")
 901     (set_attr "up_c" "yes")
 902     (set_attr "mode" "SI")])
 903
 904 (define_insn "cmpsi_cc"
 905   [(set (reg:CC CC_REGNUM)
 906         (compare:CC (match_operand:SI 0 "register_operand" "d,*e,d")
 907                     (match_operand:SI 1 "arith_operand" "L,*e,d")))]
 908   ""
 909   "@
 910    cmpi.c  %0, %c1
 911    cmp!    %0, %1
 912    cmp.c   %0, %1"
 913   [(set_attr "type" "cmp")
 914    (set_attr "up_c" "yes")
 915    (set_attr "mode" "SI")])
 916
 917 (define_expand "beq"
 918   [(set (pc)
 919         (if_then_else (eq (reg:CC CC_REGNUM) (const_int 0))
 920                       (label_ref (match_operand 0 "" ""))
 921                       (pc)))]
 922   ""
 923 {
 924   mda_gen_cmp (CCmode);
 925 })
 926
 927 (define_expand "bne"
 928   [(set (pc)
 929         (if_then_else (ne (reg:CC CC_REGNUM) (const_int 0))
 930                       (label_ref (match_operand 0 "" ""))
 931                       (pc)))]
 932   ""
 933 {
 934   mda_gen_cmp (CCmode);
 935 })
 936
 937 (define_expand "bgt"
 938   [(set (pc)
 939         (if_then_else (gt (reg:CC CC_REGNUM) (const_int 0))
 940                       (label_ref (match_operand 0 "" ""))
 941                       (pc)))]
 942   ""
 943 {
 944   mda_gen_cmp (CCmode);
 945 })
 946
 947 (define_expand "ble"
 948   [(set (pc)
 949         (if_then_else (le (reg:CC CC_REGNUM) (const_int 0))
 950                       (label_ref (match_operand 0 "" ""))
 951                       (pc)))]
 952   ""
 953 {
 954   mda_gen_cmp (CCmode);
 955 })
 956
 957 (define_expand "bge"
 958   [(set (pc)
 959         (if_then_else (ge (reg:CC CC_REGNUM) (const_int 0))
 960                       (label_ref (match_operand 0 "" ""))
 961                       (pc)))]
 962   ""
 963 {
 964   mda_gen_cmp (CCmode);
 965 })
 966
 967 (define_expand "blt"
 968   [(set (pc)
 969         (if_then_else (lt (reg:CC CC_REGNUM) (const_int 0))
 970                       (label_ref (match_operand 0 "" ""))
 971                       (pc)))]
 972   ""
 973 {
 974   mda_gen_cmp (CCmode);
 975 })
 976
 977 (define_expand "bgtu"
 978   [(set (pc)
 979         (if_then_else (gtu (reg:CC CC_REGNUM) (const_int 0))
 980                       (label_ref (match_operand 0 "" ""))
 981                       (pc)))]
 982   ""
 983 {
 984   mda_gen_cmp (CCmode);
 985 })
 986
 987 (define_expand "bleu"
 988   [(set (pc)
 989         (if_then_else (leu (reg:CC CC_REGNUM) (const_int 0))
 990                       (label_ref (match_operand 0 "" ""))
 991                       (pc)))]
 992   ""
 993 {
 994   mda_gen_cmp (CCmode);
 995 })
 996
 997 (define_expand "bgeu"
 998   [(set (pc)
 999         (if_then_else (geu (reg:CC CC_REGNUM) (const_int 0))
1000                       (label_ref (match_operand 0 "" ""))
1001                       (pc)))]
1002   ""
1003 {
1004   mda_gen_cmp (CCmode);
1005 })
1006
1007 (define_expand "bltu"
1008   [(set (pc)
1009         (if_then_else (ltu (reg:CC CC_REGNUM) (const_int 0))
1010                       (label_ref (match_operand 0 "" ""))
1011                       (pc)))]
1012   ""
1013 {
1014   mda_gen_cmp (CCmode);
1015 })
1016
1017 (define_insn "branch_n"
1018   [(set (pc)
1019         (if_then_else
1020          (match_operator 0 "branch_n_operator"
1021                          [(reg:CC_N CC_REGNUM)
1022                           (const_int 0)])
1023          (label_ref (match_operand 1 "" ""))
1024          (pc)))]
1025   ""
1026   "b%C0    %1"
1027   [(set_attr "type" "branch")])
1028
1029 (define_insn "branch_nz"
1030   [(set (pc)
1031         (if_then_else
1032          (match_operator 0 "branch_nz_operator"
1033                          [(reg:CC_NZ CC_REGNUM)
1034                           (const_int 0)])
1035          (label_ref (match_operand 1 "" ""))
1036          (pc)))]
1037   ""
1038   "b%C0    %1"
1039   [(set_attr "type" "branch")])
1040
1041 (define_insn "branch_cc"
1042   [(set (pc)
1043         (if_then_else
1044          (match_operator 0 "comparison_operator"
1045                          [(reg:CC CC_REGNUM)
1046                           (const_int 0)])
1047          (label_ref (match_operand 1 "" ""))
1048          (pc)))]
1049   ""
1050   "b%C0    %1"
1051   [(set_attr "type" "branch")])
1052
1053 (define_insn "jump"
1054   [(set (pc)
1055         (label_ref (match_operand 0 "" "")))]
1056   ""
1057 {
1058   if (!flag_pic)
1059     return \"j      %0\";
1060   else
1061     return \"b      %0\";
1062 }
1063   [(set_attr "type" "jump")])
1064
1065 (define_expand "sibcall"
1066   [(parallel [(call (match_operand 0 "" "")
1067                     (match_operand 1 "" ""))
1068               (use (match_operand 2 "" ""))])]
1069   ""
1070 {
1071   mdx_call (operands, true);
1072   DONE;
1073 })
1074
1075 (define_insn "sibcall_internal"
1076   [(call (mem:SI (match_operand:SI 0 "call_insn_operand" "t,Z"))
1077          (match_operand 1 "" ""))
1078    (clobber (reg:SI RT_REGNUM))]
1079   "SIBLING_CALL_P (insn)"
1080 {
1081   if (!flag_pic)
1082     switch (which_alternative)
1083       {
1084       case 0: return \"br%S0   %0\";
1085       case 1: return \"j       %0\";
1086       default: gcc_unreachable ();
1087       }
1088   else
1089     switch (which_alternative)
1090       {
1091       case 0: return \"mv      r29, %0\;.cpadd  r29\;br      r29\";
1092       case 1: return \"la      r29, %0\;br      r29\";
1093       default: gcc_unreachable ();
1094       }
1095 }
1096   [(set_attr "type" "call")])
1097
1098 (define_expand "sibcall_value"
1099   [(parallel [(set (match_operand 0 "" "")
1100               (call (match_operand 1 "" "") (match_operand 2 "" "")))
1101               (use (match_operand 3 "" ""))])]
1102   ""
1103 {
1104   mdx_call_value (operands, true);
1105   DONE;
1106 })
1107
1108 (define_insn "sibcall_value_internal"
1109   [(set (match_operand 0 "register_operand" "=d,d")
1110         (call (mem:SI (match_operand:SI 1 "call_insn_operand" "t,Z"))
1111               (match_operand 2 "" "")))
1112    (clobber (reg:SI RT_REGNUM))]
1113   "SIBLING_CALL_P (insn)"
1114 {
1115   if (!flag_pic)
1116     switch (which_alternative)
1117       {
1118       case 0: return \"br%S1   %1\";
1119       case 1: return \"j       %1\";
1120       default: gcc_unreachable ();
1121       }
1122   else
1123     switch (which_alternative)
1124       {
1125       case 0: return \"mv      r29, %1\;.cpadd  r29\;br      r29\";
1126       case 1: return \"la      r29, %1\;br      r29\";
1127       default: gcc_unreachable ();
1128       }
1129 }
1130   [(set_attr "type" "call")])
1131
1132 (define_expand "call"
1133   [(parallel [(call (match_operand 0 "" "") (match_operand 1 "" ""))
1134               (use (match_operand 2 "" ""))])]
1135   ""
1136 {
1137   mdx_call (operands, false);
1138   DONE;
1139 })
1140
1141 (define_insn "call_internal"
1142   [(call (mem:SI (match_operand:SI 0 "call_insn_operand" "d,Z"))
1143          (match_operand 1 "" ""))
1144    (clobber (reg:SI RA_REGNUM))]
1145   ""
1146 {
1147   if (!flag_pic)
1148     switch (which_alternative)
1149       {
1150       case 0: return \"brl%S0  %0\";
1151       case 1: return \"jl      %0\";
1152       default: gcc_unreachable ();
1153       }
1154   else
1155      switch (which_alternative)
1156       {
1157       case 0: return \"mv      r29, %0\;.cpadd  r29\;brl     r29\";
1158       case 1: return \"la      r29, %0\;brl     r29\";
1159       default: gcc_unreachable ();
1160       }
1161 }
1162   [(set_attr "type" "call")])
1163
1164 (define_expand "call_value"
1165   [(parallel [(set (match_operand 0 "" "")
1166               (call (match_operand 1 "" "") (match_operand 2 "" "")))
1167               (use (match_operand 3 "" ""))])]
1168   ""
1169 {
1170   mdx_call_value (operands, false);
1171   DONE;
1172 })
1173
1174 (define_insn "call_value_internal"
1175   [(set (match_operand 0 "register_operand" "=d,d")
1176         (call (mem:SI (match_operand:SI 1 "call_insn_operand" "d,Z"))
1177               (match_operand 2 "" "")))
1178    (clobber (reg:SI RA_REGNUM))]
1179   ""
1180 {
1181   if (!flag_pic)
1182     switch (which_alternative)
1183       {
1184       case 0: return \"brl%S1  %1\";
1185       case 1: return \"jl      %1\";
1186       default: gcc_unreachable ();
1187       }
1188   else
1189     switch (which_alternative)
1190       {
1191       case 0: return \"mv      r29, %1\;.cpadd  r29\;brl     r29\";
1192       case 1: return \"la      r29, %1\;brl     r29\";
1193       default: gcc_unreachable ();
1194       }
1195 }
1196   [(set_attr "type" "call")])
1197
1198 (define_expand "indirect_jump"
1199   [(set (pc) (match_operand 0 "register_operand" "d"))]
1200   ""
1201 {
1202   rtx dest;
1203   dest = operands[0];
1204   if (GET_CODE (dest) != REG
1205       || GET_MODE (dest) != Pmode)
1206     operands[0] = copy_to_mode_reg (Pmode, dest);
1207
1208   emit_jump_insn (gen_indirect_jump_internal1 (operands[0]));
1209   DONE;
1210 })
1211
1212 (define_insn "indirect_jump_internal1"
1213   [(set (pc) (match_operand:SI 0 "register_operand" "d"))]
1214   ""
1215   "br%S0   %0"
1216   [(set_attr "type" "jump")])
1217
1218 (define_expand "tablejump"
1219   [(set (pc)
1220         (match_operand 0 "register_operand" "d"))
1221    (use (label_ref (match_operand 1 "" "")))]
1222   ""
1223 {
1224   if (GET_MODE (operands[0]) != ptr_mode)
1225     gcc_unreachable ();
1226   emit_jump_insn (gen_tablejump_internal1 (operands[0], operands[1]));
1227   DONE;
1228 })
1229
1230 (define_insn "tablejump_internal1"
1231   [(set (pc)
1232         (match_operand:SI 0 "register_operand" "d"))
1233    (use (label_ref (match_operand 1 "" "")))]
1234   ""
1235   "*
1236    if (flag_pic)
1237      return \"mv      r29, %0\;.cpadd  r29\;br      r29\";
1238    else
1239      return \"br%S0   %0\";
1240   "
1241   [(set_attr "type" "jump")])
1242
1243 (define_expand "prologue"
1244   [(const_int 1)]
1245   ""
1246 {
1247   mdx_prologue ();
1248   DONE;
1249 })
1250
1251 (define_expand "epilogue"
1252   [(const_int 2)]
1253   ""
1254 {
1255   mdx_epilogue (false);
1256   DONE;
1257 })
1258
1259 (define_expand "sibcall_epilogue"
1260   [(const_int 2)]
1261   ""
1262 {
1263   mdx_epilogue (true);
1264   DONE;
1265 })
1266
1267 (define_insn "return_internal"
1268   [(return)
1269    (use (match_operand 0 "pmode_register_operand" "d"))]
1270   ""
1271   "br%S0   %0")
1272
1273 (define_insn "nop"
1274   [(const_int 0)]
1275   ""
1276   "#nop!"
1277 )
1278
1279 (define_insn "cpload"
1280   [(unspec:SI [(const_int 1)] 1)]
1281   "flag_pic"
1282   ".cpload r29"
1283 )
1284
1285 (define_insn "cprestore"
1286   [(unspec:SI [(match_operand:SI 0 "" "")] 2)]
1287   "flag_pic"
1288   ".cprestore %0"
1289 )