gcc/config/m32r/m32r.md

   1 ;; Machine description of the Renesas M32R cpu for GNU C compiler
   2 ;; Copyright (C) 1996, 1997, 1998, 1999, 2001, 2003, 2004, 2005,
   3 ;  2007, 2008 Free Software Foundation, Inc.
   4
   5 ;; This file is part of GCC.
   6
   7 ;; GCC is free software; you can redistribute it and/or modify it
   8 ;; under the terms of the GNU General Public License as published
   9 ;; by the Free Software Foundation; either version 3, or (at your
  10 ;; option) any later version.
  11
  12 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
  13 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15 ;; License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GCC; see the file COPYING3.  If not see
  19 ;; <http://www.gnu.org/licenses/>.
  20
  21 ;; See file "rtl.def" for documentation on define_insn, match_*, et. al.
  22 \f
  23 ;; UNSPEC_VOLATILE usage
  24 (define_constants
  25   [(UNSPECV_BLOCKAGE            0)
  26    (UNSPECV_FLUSH_ICACHE        1)])
  27
  28 ;; UNSPEC usage
  29 (define_constants
  30   [(UNSPEC_LOAD_SDA_BASE        2)
  31    (UNSPEC_SET_CBIT             3)
  32    (UNSPEC_PIC_LOAD_ADDR        4)
  33    (UNSPEC_GET_PC               5)
  34    (UNSPEC_GOTOFF               6)
  35    ])
  36
  37 ;; Insn type.  Used to default other attribute values.
  38 (define_attr "type"
  39   "int2,int4,load2,load4,load8,store2,store4,store8,shift2,shift4,mul2,div4,uncond_branch,branch,call,multi,misc"
  40   (const_string "misc"))
  41
  42 ;; Length in bytes.
  43 (define_attr "length" ""
  44   (cond [(eq_attr "type" "int2,load2,store2,shift2,mul2")
  45          (const_int 2)
  46
  47          (eq_attr "type" "int4,load4,store4,shift4,div4")
  48          (const_int 4)
  49
  50          (eq_attr "type" "multi")
  51          (const_int 8)
  52
  53          (eq_attr "type" "uncond_branch,branch,call")
  54          (const_int 4)]
  55
  56          (const_int 4)))
  57
  58 ;; The length here is the length of a single asm.  Unfortunately it might be
  59 ;; 2 or 4 so we must allow for 4.  That's ok though.
  60 (define_asm_attributes
  61   [(set_attr "length" "4")
  62    (set_attr "type" "multi")])
  63
  64 ;; Whether an instruction is short (16-bit) or long (32-bit).
  65 (define_attr "insn_size" "short,long"
  66   (if_then_else (eq_attr "type" "int2,load2,store2,shift2,mul2")
  67                 (const_string "short")
  68                 (const_string "long")))
  69
  70 ;; The target CPU we're compiling for.
  71 (define_attr "cpu" "m32r,m32r2,m32rx"
  72   (cond [(ne (symbol_ref "TARGET_M32RX") (const_int 0))
  73              (const_string "m32rx")
  74          (ne (symbol_ref "TARGET_M32R2") (const_int 0))
  75              (const_string "m32r2")]
  76     (const_string "m32r")))
  77
  78 ;; Defines the pipeline where an instruction can be executed on.
  79 ;; For the M32R, a short instruction can execute one of the two pipes.
  80 ;; For the M32Rx, the restrictions are modelled in the second
  81 ;;  condition of this attribute definition.
  82 (define_attr "m32r_pipeline" "either,s,o,long"
  83   (cond [(and (eq_attr "cpu" "m32r")
  84               (eq_attr "insn_size" "short"))
  85              (const_string "either")
  86          (eq_attr "insn_size" "!short")
  87              (const_string "long")]
  88          (cond [(eq_attr "type" "int2")
  89                    (const_string "either")
  90                 (eq_attr "type" "load2,store2,shift2,uncond_branch,branch,call")
  91                    (const_string "o")
  92                 (eq_attr "type" "mul2")
  93                    (const_string "s")]
  94          (const_string "long"))))
  95 \f
  96 ;; ::::::::::::::::::::
  97 ;; ::
  98 ;; :: Pipeline description
  99 ;; ::
 100 ;; ::::::::::::::::::::
 101
 102 ;; This model is based on Chapter 2, Appendix 3 and Appendix 4 of the
 103 ;; "M32R-FPU Software Manual", Revision 1.01, plus additional information
 104 ;; obtained by our best friend and mine, Google.
 105 ;;
 106 ;; The pipeline is modelled as a fetch unit, and a core with a memory unit,
 107 ;; two execution units, where "fetch" models IF and D, "memory" for MEM1
 108 ;; and MEM2, and "EXEC" for E, E1, E2, EM, and EA.  Writeback and
 109 ;; bypasses are not modelled.
 110 (define_automaton "m32r")
 111
 112 ;; We pretend there are two short (16 bits) instruction fetchers.  The
 113 ;; "s" short fetcher cannot be reserved until the "o" short fetcher is
 114 ;; reserved.  Some instructions reserve both the left and right fetchers.
 115 ;; These fetch units are a hack to get GCC to better pack the instructions
 116 ;; for the M32Rx processor, which has two execution pipes.
 117 ;;
 118 ;; In reality there is only one decoder, which can decode either two 16-bit
 119 ;; instructions, or a single 32-bit instruction.
 120 ;;
 121 ;; Note, "fetch" models both the IF and the D pipeline stages.
 122 ;;
 123 ;; The m32rx core has two execution pipes.  We name them o_E and s_E.
 124 ;; In addition, there's a memory unit.
 125
 126 (define_cpu_unit "o_IF,s_IF,o_E,s_E,memory" "m32r")
 127
 128 ;; Prevent the s pipe from being reserved before the o pipe.
 129 (absence_set "s_IF" "o_IF")
 130 (absence_set "s_E"  "o_E")
 131
 132 ;; On the M32Rx, long instructions execute on both pipes, so reserve
 133 ;; both fetch slots and both pipes.
 134 (define_reservation "long_IF" "o_IF+s_IF")
 135 (define_reservation "long_E" "o_E+s_E")
 136
 137 ;; ::::::::::::::::::::
 138
 139 ;; Simple instructions do 4 stages: IF D E WB.  WB is not modelled.
 140 ;; Hence, ready latency is 1.
 141 (define_insn_reservation "short_left" 1
 142   (and (eq_attr "m32r_pipeline" "o")
 143        (and (eq_attr "insn_size" "short")
 144             (eq_attr "type" "!load2")))
 145   "o_IF,o_E")
 146
 147 (define_insn_reservation "short_right" 1
 148   (and (eq_attr "m32r_pipeline" "s")
 149        (and (eq_attr "insn_size" "short")
 150             (eq_attr "type" "!load2")))
 151   "s_IF,s_E")
 152
 153 (define_insn_reservation "short_either" 1
 154   (and (eq_attr "m32r_pipeline" "either")
 155        (and (eq_attr "insn_size" "short")
 156             (eq_attr "type" "!load2")))
 157   "o_IF|s_IF,o_E|s_E")
 158
 159 (define_insn_reservation "long_m32r" 1
 160   (and (eq_attr "cpu" "m32r")
 161        (and (eq_attr "insn_size" "long")
 162             (eq_attr "type" "!load4,load8")))
 163   "long_IF,long_E")
 164
 165 (define_insn_reservation "long_m32rx" 2
 166   (and (eq_attr "m32r_pipeline" "long")
 167        (and (eq_attr "insn_size" "long")
 168             (eq_attr "type" "!load4,load8")))
 169   "long_IF,long_E")
 170
 171 ;; Load/store instructions do 6 stages: IF D E MEM1 MEM2 WB.
 172 ;; MEM1 may require more than one cycle depending on locality.  We
 173 ;; optimistically assume all memory is nearby, i.e. MEM1 takes only
 174 ;; one cycle.  Hence, ready latency is 3.
 175
 176 ;; The M32Rx can do short load/store only on the left pipe.
 177 (define_insn_reservation "short_load_left" 3
 178   (and (eq_attr "m32r_pipeline" "o")
 179        (and (eq_attr "insn_size" "short")
 180             (eq_attr "type" "load2")))
 181   "o_IF,o_E,memory*2")
 182
 183 (define_insn_reservation "short_load" 3
 184   (and (eq_attr "m32r_pipeline" "either")
 185        (and (eq_attr "insn_size" "short")
 186             (eq_attr "type" "load2")))
 187   "s_IF|o_IF,s_E|o_E,memory*2")
 188
 189 (define_insn_reservation "long_load" 3
 190   (and (eq_attr "cpu" "m32r")
 191        (and (eq_attr "insn_size" "long")
 192             (eq_attr "type" "load4,load8")))
 193   "long_IF,long_E,memory*2")
 194
 195 (define_insn_reservation "long_load_m32rx" 3
 196   (and (eq_attr "m32r_pipeline" "long")
 197        (eq_attr "type" "load4,load8"))
 198   "long_IF,long_E,memory*2")
 199
 200 \f
 201 (include "predicates.md")
 202 (include "constraints.md")
 203
 204 ;; Expand prologue as RTL
 205 (define_expand "prologue"
 206   [(const_int 1)]
 207   ""
 208   "
 209 {
 210   m32r_expand_prologue ();
 211   DONE;
 212 }")
 213
 214 ;; Expand epilogue as RTL
 215 (define_expand "epilogue"
 216   [(return)]
 217   ""
 218   "
 219 {
 220   m32r_expand_epilogue ();
 221   emit_jump_insn (gen_return_normal ());
 222   DONE;
 223 }")
 224 \f
 225 ;; Move instructions.
 226 ;;
 227 ;; For QI and HI moves, the register must contain the full properly
 228 ;; sign-extended value.  nonzero_bits assumes this [otherwise
 229 ;; SHORT_IMMEDIATES_SIGN_EXTEND must be used, but the comment for it
 230 ;; says it's a kludge and the .md files should be fixed instead].
 231
 232 (define_expand "movqi"
 233   [(set (match_operand:QI 0 "general_operand" "")
 234         (match_operand:QI 1 "general_operand" ""))]
 235   ""
 236   "
 237 {
 238   /* Fixup PIC cases.  */
 239   if (flag_pic)
 240     {
 241       if (symbolic_operand (operands[1], QImode))
 242         {
 243           if (reload_in_progress || reload_completed)
 244             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 245           else
 246             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 247         }
 248     }
 249
 250   /* Everything except mem = const or mem = mem can be done easily.
 251      Objects in the small data area are handled too.  */
 252
 253   if (MEM_P (operands[0]))
 254     operands[1] = force_reg (QImode, operands[1]);
 255 }")
 256
 257 (define_insn "*movqi_insn"
 258   [(set (match_operand:QI 0 "move_dest_operand" "=r,r,r,r,r,T,m")
 259         (match_operand:QI 1 "move_src_operand" "r,I,JQR,T,m,r,r"))]
 260   "register_operand (operands[0], QImode) || register_operand (operands[1], QImode)"
 261   "@
 262    mv %0,%1
 263    ldi %0,%#%1
 264    ldi %0,%#%1
 265    ldub %0,%1
 266    ldub %0,%1
 267    stb %1,%0
 268    stb %1,%0"
 269   [(set_attr "type" "int2,int2,int4,load2,load4,store2,store4")
 270    (set_attr "length" "2,2,4,2,4,2,4")])
 271
 272 (define_expand "movhi"
 273   [(set (match_operand:HI 0 "general_operand" "")
 274         (match_operand:HI 1 "general_operand" ""))]
 275   ""
 276   "
 277 {
 278   /* Fixup PIC cases.  */
 279   if (flag_pic)
 280     {
 281       if (symbolic_operand (operands[1], HImode))
 282         {
 283           if (reload_in_progress || reload_completed)
 284             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 285           else
 286             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 287         }
 288     }
 289
 290   /* Everything except mem = const or mem = mem can be done easily.  */
 291
 292   if (MEM_P (operands[0]))
 293     operands[1] = force_reg (HImode, operands[1]);
 294 }")
 295
 296 (define_insn "*movhi_insn"
 297   [(set (match_operand:HI 0 "move_dest_operand" "=r,r,r,r,r,r,T,m")
 298         (match_operand:HI 1 "move_src_operand" "r,I,JQR,K,T,m,r,r"))]
 299   "register_operand (operands[0], HImode) || register_operand (operands[1], HImode)"
 300   "@
 301    mv %0,%1
 302    ldi %0,%#%1
 303    ldi %0,%#%1
 304    ld24 %0,%#%1
 305    lduh %0,%1
 306    lduh %0,%1
 307    sth %1,%0
 308    sth %1,%0"
 309   [(set_attr "type" "int2,int2,int4,int4,load2,load4,store2,store4")
 310    (set_attr "length" "2,2,4,4,2,4,2,4")])
 311
 312 (define_expand "movsi_push"
 313   [(set (mem:SI (pre_dec:SI (match_operand:SI 0 "register_operand" "")))
 314         (match_operand:SI 1 "register_operand" ""))]
 315   ""
 316   "")
 317
 318 (define_expand "movsi_pop"
 319   [(set (match_operand:SI 0 "register_operand" "")
 320         (mem:SI (post_inc:SI (match_operand:SI 1 "register_operand" ""))))]
 321   ""
 322   "")
 323
 324 (define_expand "movsi"
 325   [(set (match_operand:SI 0 "general_operand" "")
 326         (match_operand:SI 1 "general_operand" ""))]
 327   ""
 328   "
 329 {
 330   /* Fixup PIC cases.  */
 331   if (flag_pic)
 332     {
 333       if (symbolic_operand (operands[1], SImode))
 334         {
 335           if (reload_in_progress || reload_completed)
 336             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 337           else
 338             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 339         }
 340     }
 341
 342   /* Everything except mem = const or mem = mem can be done easily.  */
 343
 344   if (MEM_P (operands[0]))
 345     operands[1] = force_reg (SImode, operands[1]);
 346
 347   /* Small Data Area reference?  */
 348   if (small_data_operand (operands[1], SImode))
 349     {
 350       emit_insn (gen_movsi_sda (operands[0], operands[1]));
 351       DONE;
 352     }
 353
 354   /* If medium or large code model, symbols have to be loaded with
 355      seth/add3.  */
 356   if (addr32_operand (operands[1], SImode))
 357     {
 358       emit_insn (gen_movsi_addr32 (operands[0], operands[1]));
 359       DONE;
 360     }
 361 }")
 362
 363 ;; ??? Do we need a const_double constraint here for large unsigned values?
 364 (define_insn "*movsi_insn"
 365   [(set (match_operand:SI 0 "move_dest_operand" "=r,r,r,r,r,r,r,r,r,T,S,m")
 366         (match_operand:SI 1 "move_src_operand" "r,I,J,MQ,L,n,T,U,m,r,r,r"))]
 367   "register_operand (operands[0], SImode) || register_operand (operands[1], SImode)"
 368   "*
 369 {
 370   if (REG_P (operands[0]) || GET_CODE (operands[1]) == SUBREG)
 371     {
 372       switch (GET_CODE (operands[1]))
 373         {
 374           HOST_WIDE_INT value;
 375
 376           default:
 377             break;
 378
 379           case REG:
 380           case SUBREG:
 381             return \"mv %0,%1\";
 382
 383           case MEM:
 384             if (GET_CODE (XEXP (operands[1], 0)) == POST_INC
 385                 && XEXP (XEXP (operands[1], 0), 0) == stack_pointer_rtx)
 386               return \"pop %0\";
 387
 388             return \"ld %0,%1\";
 389
 390           case CONST_INT:
 391             if (satisfies_constraint_J (operands[1]))
 392               return \"ldi %0,%#%1\\t; %X1\";
 393
 394             if (satisfies_constraint_M (operands[1]))
 395               return \"ld24 %0,%#%1\\t; %X1\";
 396
 397             if (satisfies_constraint_L (operands[1]))
 398               return \"seth %0,%#%T1\\t; %X1\";
 399
 400             return \"#\";
 401
 402           case CONST:
 403           case SYMBOL_REF:
 404           case LABEL_REF:
 405             if (TARGET_ADDR24)
 406               return \"ld24 %0,%#%1\";
 407
 408             return \"#\";
 409         }
 410     }
 411
 412   else if (MEM_P (operands[0])
 413            && (REG_P (operands[1]) || GET_CODE (operands[1]) == SUBREG))
 414     {
 415       if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
 416           && XEXP (XEXP (operands[0], 0), 0) == stack_pointer_rtx)
 417         return \"push %1\";
 418
 419       return \"st %1,%0\";
 420     }
 421
 422   gcc_unreachable ();
 423 }"
 424   [(set_attr "type" "int2,int2,int4,int4,int4,multi,load2,load2,load4,store2,store2,store4")
 425    (set_attr "length" "2,2,4,4,4,8,2,2,4,2,2,4")])
 426
 427 ; Try to use a four byte / two byte pair for constants not loadable with
 428 ; ldi, ld24, seth.
 429
 430 (define_split
 431  [(set (match_operand:SI 0 "register_operand" "")
 432        (match_operand:SI 1 "two_insn_const_operand" ""))]
 433   ""
 434   [(set (match_dup 0) (match_dup 2))
 435    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 3)))]
 436   "
 437 {
 438   unsigned HOST_WIDE_INT val = INTVAL (operands[1]);
 439   unsigned HOST_WIDE_INT tmp;
 440   int shift;
 441
 442   /* In all cases we will emit two instructions.  However we try to
 443      use 2 byte instructions wherever possible.  We can assume the
 444      constant isn't loadable with any of ldi, ld24, or seth.  */
 445
 446   /* See if we can load a 24-bit unsigned value and invert it.  */
 447   if (UINT24_P (~ val))
 448     {
 449       emit_insn (gen_movsi (operands[0], GEN_INT (~ val)));
 450       emit_insn (gen_one_cmplsi2 (operands[0], operands[0]));
 451       DONE;
 452     }
 453
 454   /* See if we can load a 24-bit unsigned value and shift it into place.
 455      0x01fffffe is just beyond ld24's range.  */
 456   for (shift = 1, tmp = 0x01fffffe;
 457        shift < 8;
 458        ++shift, tmp <<= 1)
 459     {
 460       if ((val & ~tmp) == 0)
 461         {
 462           emit_insn (gen_movsi (operands[0], GEN_INT (val >> shift)));
 463           emit_insn (gen_ashlsi3 (operands[0], operands[0], GEN_INT (shift)));
 464           DONE;
 465         }
 466     }
 467
 468   /* Can't use any two byte insn, fall back to seth/or3.  Use ~0xffff instead
 469      of 0xffff0000, since the later fails on a 64-bit host.  */
 470   operands[2] = GEN_INT ((val) & ~0xffff);
 471   operands[3] = GEN_INT ((val) & 0xffff);
 472 }")
 473
 474 (define_split
 475   [(set (match_operand:SI 0 "register_operand" "")
 476         (match_operand:SI 1 "seth_add3_operand" ""))]
 477   "TARGET_ADDR32"
 478   [(set (match_dup 0)
 479         (high:SI (match_dup 1)))
 480    (set (match_dup 0)
 481         (lo_sum:SI (match_dup 0)
 482                    (match_dup 1)))]
 483   "")
 484
 485 ;; Small data area support.
 486 ;; The address of _SDA_BASE_ is loaded into a register and all objects in
 487 ;; the small data area are indexed off that.  This is done for each reference
 488 ;; but cse will clean things up for us.  We let the compiler choose the
 489 ;; register to use so we needn't allocate (and maybe even fix) a special
 490 ;; register to use.  Since the load and store insns have a 16-bit offset the
 491 ;; total size of the data area can be 64K.  However, if the data area lives
 492 ;; above 16M (24 bits), _SDA_BASE_ will have to be loaded with seth/add3 which
 493 ;; would then yield 3 instructions to reference an object [though there would
 494 ;; be no net loss if two or more objects were referenced].  The 3 insns can be
 495 ;; reduced back to 2 if the size of the small data area were reduced to 32K
 496 ;; [then seth + ld/st would work for any object in the area].  Doing this
 497 ;; would require special handling of _SDA_BASE_ (its value would be
 498 ;; (.sdata + 32K) & 0xffff0000) and reloc computations would be different
 499 ;; [I think].  What to do about this is deferred until later and for now we
 500 ;; require .sdata to be in the first 16M.
 501
 502 (define_expand "movsi_sda"
 503   [(set (match_dup 2)
 504         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))
 505    (set (match_operand:SI 0 "register_operand" "")
 506         (lo_sum:SI (match_dup 2)
 507                    (match_operand:SI 1 "small_data_operand" "")))]
 508   ""
 509   "
 510 {
 511   if (reload_in_progress || reload_completed)
 512     operands[2] = operands[0];
 513   else
 514     operands[2] = gen_reg_rtx (SImode);
 515 }")
 516
 517 (define_insn "*load_sda_base_32"
 518   [(set (match_operand:SI 0 "register_operand" "=r")
 519         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))]
 520   "TARGET_ADDR32"
 521   "seth %0,%#shigh(_SDA_BASE_)\;add3 %0,%0,%#low(_SDA_BASE_)"
 522   [(set_attr "type" "multi")
 523    (set_attr "length" "8")])
 524
 525 (define_insn "*load_sda_base"
 526   [(set (match_operand:SI 0 "register_operand" "=r")
 527         (unspec:SI [(const_int 0)] UNSPEC_LOAD_SDA_BASE))]
 528   ""
 529   "ld24 %0,#_SDA_BASE_"
 530   [(set_attr "type" "int4")
 531    (set_attr "length" "4")])
 532
 533 ;; 32-bit address support.
 534
 535 (define_expand "movsi_addr32"
 536   [(set (match_dup 2)
 537         ; addr32_operand isn't used because it's too restrictive,
 538         ; seth_add3_operand is more general and thus safer.
 539         (high:SI (match_operand:SI 1 "seth_add3_operand" "")))
 540    (set (match_operand:SI 0 "register_operand" "")
 541         (lo_sum:SI (match_dup 2) (match_dup 1)))]
 542   ""
 543   "
 544 {
 545   if (reload_in_progress || reload_completed)
 546     operands[2] = operands[0];
 547   else
 548     operands[2] = gen_reg_rtx (SImode);
 549 }")
 550
 551 (define_insn "set_hi_si"
 552   [(set (match_operand:SI 0 "register_operand" "=r")
 553         (high:SI (match_operand 1 "symbolic_operand" "")))]
 554   ""
 555   "seth %0,%#shigh(%1)"
 556   [(set_attr "type" "int4")
 557    (set_attr "length" "4")])
 558
 559 (define_insn "lo_sum_si"
 560   [(set (match_operand:SI 0 "register_operand" "=r")
 561         (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
 562                    (match_operand:SI 2 "immediate_operand" "in")))]
 563   ""
 564   "add3 %0,%1,%#%B2"
 565   [(set_attr "type" "int4")
 566    (set_attr "length" "4")])
 567
 568 (define_expand "movdi"
 569   [(set (match_operand:DI 0 "general_operand" "")
 570         (match_operand:DI 1 "general_operand" ""))]
 571   ""
 572   "
 573 {
 574   /* Fixup PIC cases.  */
 575   if (flag_pic)
 576     {
 577       if (symbolic_operand (operands[1], DImode))
 578         {
 579           if (reload_in_progress || reload_completed)
 580             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 581           else
 582             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 583         }
 584     }
 585
 586   /* Everything except mem = const or mem = mem can be done easily.  */
 587
 588   if (MEM_P (operands[0]))
 589     operands[1] = force_reg (DImode, operands[1]);
 590 }")
 591
 592 (define_insn "*movdi_insn"
 593   [(set (match_operand:DI 0 "move_dest_operand" "=r,r,r,r,m")
 594         (match_operand:DI 1 "move_double_src_operand" "r,nG,F,m,r"))]
 595   "register_operand (operands[0], DImode) || register_operand (operands[1], DImode)"
 596   "#"
 597   [(set_attr "type" "multi,multi,multi,load8,store8")
 598    (set_attr "length" "4,4,16,6,6")])
 599
 600 (define_split
 601   [(set (match_operand:DI 0 "move_dest_operand" "")
 602         (match_operand:DI 1 "move_double_src_operand" ""))]
 603   "reload_completed"
 604   [(match_dup 2)]
 605   "operands[2] = gen_split_move_double (operands);")
 606 \f
 607 ;; Floating point move insns.
 608
 609 (define_expand "movsf"
 610   [(set (match_operand:SF 0 "general_operand" "")
 611         (match_operand:SF 1 "general_operand" ""))]
 612   ""
 613   "
 614 {
 615   /* Fixup PIC cases.  */
 616   if (flag_pic)
 617     {
 618       if (symbolic_operand (operands[1], SFmode))
 619         {
 620           if (reload_in_progress || reload_completed)
 621             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 622           else
 623             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 624         }
 625     }
 626
 627   /* Everything except mem = const or mem = mem can be done easily.  */
 628
 629   if (MEM_P (operands[0]))
 630     operands[1] = force_reg (SFmode, operands[1]);
 631 }")
 632
 633 (define_insn "*movsf_insn"
 634   [(set (match_operand:SF 0 "move_dest_operand" "=r,r,r,r,r,T,S,m")
 635         (match_operand:SF 1 "move_src_operand" "r,F,U,S,m,r,r,r"))]
 636   "register_operand (operands[0], SFmode) || register_operand (operands[1], SFmode)"
 637   "@
 638    mv %0,%1
 639    #
 640    ld %0,%1
 641    ld %0,%1
 642    ld %0,%1
 643    st %1,%0
 644    st %1,%0
 645    st %1,%0"
 646   ;; ??? Length of alternative 1 is either 2, 4 or 8.
 647   [(set_attr "type" "int2,multi,load2,load2,load4,store2,store2,store4")
 648    (set_attr "length" "2,8,2,2,4,2,2,4")])
 649
 650 (define_split
 651   [(set (match_operand:SF 0 "register_operand" "")
 652         (match_operand:SF 1 "const_double_operand" ""))]
 653   "reload_completed"
 654   [(set (match_dup 2) (match_dup 3))]
 655   "
 656 {
 657   operands[2] = operand_subword (operands[0], 0, 0, SFmode);
 658   operands[3] = operand_subword (operands[1], 0, 0, SFmode);
 659 }")
 660
 661 (define_expand "movdf"
 662   [(set (match_operand:DF 0 "general_operand" "")
 663         (match_operand:DF 1 "general_operand" ""))]
 664   ""
 665   "
 666 {
 667   /* Fixup PIC cases.  */
 668   if (flag_pic)
 669     {
 670       if (symbolic_operand (operands[1], DFmode))
 671         {
 672           if (reload_in_progress || reload_completed)
 673             operands[1] = m32r_legitimize_pic_address (operands[1], operands[0]);
 674           else
 675             operands[1] = m32r_legitimize_pic_address (operands[1], NULL_RTX);
 676         }
 677     }
 678
 679   /* Everything except mem = const or mem = mem can be done easily.  */
 680
 681   if (MEM_P (operands[0]))
 682     operands[1] = force_reg (DFmode, operands[1]);
 683 }")
 684
 685 (define_insn "*movdf_insn"
 686   [(set (match_operand:DF 0 "move_dest_operand" "=r,r,r,m")
 687         (match_operand:DF 1 "move_double_src_operand" "r,F,m,r"))]
 688   "register_operand (operands[0], DFmode) || register_operand (operands[1], DFmode)"
 689   "#"
 690   [(set_attr "type" "multi,multi,load8,store8")
 691    (set_attr "length" "4,16,6,6")])
 692
 693 (define_split
 694   [(set (match_operand:DF 0 "move_dest_operand" "")
 695         (match_operand:DF 1 "move_double_src_operand" ""))]
 696   "reload_completed"
 697   [(match_dup 2)]
 698   "operands[2] = gen_split_move_double (operands);")
 699 \f
 700 ;; Zero extension instructions.
 701
 702 (define_insn "zero_extendqihi2"
 703   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
 704         (zero_extend:HI (match_operand:QI 1 "extend_operand" "r,T,m")))]
 705   ""
 706   "@
 707    and3 %0,%1,%#255
 708    ldub %0,%1
 709    ldub %0,%1"
 710   [(set_attr "type" "int4,load2,load4")
 711    (set_attr "length" "4,2,4")])
 712
 713 (define_insn "zero_extendqisi2"
 714   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
 715         (zero_extend:SI (match_operand:QI 1 "extend_operand" "r,T,m")))]
 716   ""
 717   "@
 718    and3 %0,%1,%#255
 719    ldub %0,%1
 720    ldub %0,%1"
 721   [(set_attr "type" "int4,load2,load4")
 722    (set_attr "length" "4,2,4")])
 723
 724 (define_insn "zero_extendhisi2"
 725   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
 726         (zero_extend:SI (match_operand:HI 1 "extend_operand" "r,T,m")))]
 727   ""
 728   "@
 729    and3 %0,%1,%#65535
 730    lduh %0,%1
 731    lduh %0,%1"
 732   [(set_attr "type" "int4,load2,load4")
 733    (set_attr "length" "4,2,4")])
 734 \f
 735 ;; Signed conversions from a smaller integer to a larger integer
 736 (define_insn "extendqihi2"
 737   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
 738         (sign_extend:HI (match_operand:QI 1 "extend_operand" "0,T,m")))]
 739   ""
 740   "@
 741     #
 742     ldb %0,%1
 743     ldb %0,%1"
 744   [(set_attr "type" "multi,load2,load4")
 745    (set_attr "length" "2,2,4")])
 746
 747 (define_split
 748   [(set (match_operand:HI 0 "register_operand" "")
 749         (sign_extend:HI (match_operand:QI 1 "register_operand" "")))]
 750   "reload_completed"
 751   [(match_dup 2)
 752    (match_dup 3)]
 753   "
 754 {
 755   rtx op0   = gen_lowpart (SImode, operands[0]);
 756   rtx shift = GEN_INT (24);
 757
 758   operands[2] = gen_ashlsi3 (op0, op0, shift);
 759   operands[3] = gen_ashrsi3 (op0, op0, shift);
 760 }")
 761
 762 (define_insn "extendqisi2"
 763   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
 764         (sign_extend:SI (match_operand:QI 1 "extend_operand" "0,T,m")))]
 765   ""
 766   "@
 767     #
 768     ldb %0,%1
 769     ldb %0,%1"
 770   [(set_attr "type" "multi,load2,load4")
 771    (set_attr "length" "4,2,4")])
 772
 773 (define_split
 774   [(set (match_operand:SI 0 "register_operand" "")
 775         (sign_extend:SI (match_operand:QI 1 "register_operand" "")))]
 776   "reload_completed"
 777   [(match_dup 2)
 778    (match_dup 3)]
 779   "
 780 {
 781   rtx shift = GEN_INT (24);
 782
 783   operands[2] = gen_ashlsi3 (operands[0], operands[0], shift);
 784   operands[3] = gen_ashrsi3 (operands[0], operands[0], shift);
 785 }")
 786
 787 (define_insn "extendhisi2"
 788   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
 789         (sign_extend:SI (match_operand:HI 1 "extend_operand" "0,T,m")))]
 790   ""
 791   "@
 792     #
 793     ldh %0,%1
 794     ldh %0,%1"
 795   [(set_attr "type" "multi,load2,load4")
 796    (set_attr "length" "4,2,4")])
 797
 798 (define_split
 799   [(set (match_operand:SI 0 "register_operand" "")
 800         (sign_extend:SI (match_operand:HI 1 "register_operand" "")))]
 801   "reload_completed"
 802   [(match_dup 2)
 803    (match_dup 3)]
 804   "
 805 {
 806   rtx shift = GEN_INT (16);
 807
 808   operands[2] = gen_ashlsi3 (operands[0], operands[0], shift);
 809   operands[3] = gen_ashrsi3 (operands[0], operands[0], shift);
 810 }")
 811 \f
 812 ;; Arithmetic instructions.
 813
 814 ; ??? Adding an alternative to split add3 of small constants into two
 815 ; insns yields better instruction packing but slower code.  Adds of small
 816 ; values is done a lot.
 817
 818 (define_insn "addsi3"
 819   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
 820         (plus:SI (match_operand:SI 1 "register_operand" "%0,0,r")
 821                  (match_operand:SI 2 "nonmemory_operand" "r,I,J")))]
 822   ""
 823   "@
 824    add %0,%2
 825    addi %0,%#%2
 826    add3 %0,%1,%#%2"
 827   [(set_attr "type" "int2,int2,int4")
 828    (set_attr "length" "2,2,4")])
 829
 830 ;(define_split
 831 ;  [(set (match_operand:SI 0 "register_operand" "")
 832 ;       (plus:SI (match_operand:SI 1 "register_operand" "")
 833 ;                (match_operand:SI 2 "int8_operand" "")))]
 834 ;  "reload_completed
 835 ;   && REGNO (operands[0]) != REGNO (operands[1])
 836 ;   && satisfies_constraint_I (operands[2])
 837 ;   && INTVAL (operands[2]) != 0"
 838 ;  [(set (match_dup 0) (match_dup 1))
 839 ;   (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))]
 840 ;  "")
 841
 842 (define_insn "adddi3"
 843   [(set (match_operand:DI 0 "register_operand" "=r")
 844         (plus:DI (match_operand:DI 1 "register_operand" "%0")
 845                  (match_operand:DI 2 "register_operand" "r")))
 846    (clobber (reg:CC 17))]
 847   ""
 848   "#"
 849   [(set_attr "type" "multi")
 850    (set_attr "length" "6")])
 851
 852 ;; ??? The cmp clears the condition bit.  Can we speed up somehow?
 853 (define_split
 854   [(set (match_operand:DI 0 "register_operand" "")
 855         (plus:DI (match_operand:DI 1 "register_operand" "")
 856                  (match_operand:DI 2 "register_operand" "")))
 857    (clobber (reg:CC 17))]
 858   "reload_completed"
 859   [(parallel [(set (reg:CC 17)
 860                    (const_int 0))
 861               (use (match_dup 4))])
 862    (parallel [(set (match_dup 4)
 863                    (plus:SI (match_dup 4)
 864                             (plus:SI (match_dup 5)
 865                                      (ne:SI (reg:CC 17) (const_int 0)))))
 866               (set (reg:CC 17)
 867                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])
 868    (parallel [(set (match_dup 6)
 869                    (plus:SI (match_dup 6)
 870                             (plus:SI (match_dup 7)
 871                                      (ne:SI (reg:CC 17) (const_int 0)))))
 872               (set (reg:CC 17)
 873                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])]
 874   "
 875 {
 876   operands[4] = operand_subword (operands[0], (WORDS_BIG_ENDIAN != 0), 0, DImode);
 877   operands[5] = operand_subword (operands[2], (WORDS_BIG_ENDIAN != 0), 0, DImode);
 878   operands[6] = operand_subword (operands[0], (WORDS_BIG_ENDIAN == 0), 0, DImode);
 879   operands[7] = operand_subword (operands[2], (WORDS_BIG_ENDIAN == 0), 0, DImode);
 880 }")
 881
 882 (define_insn "*clear_c"
 883   [(set (reg:CC 17)
 884         (const_int 0))
 885    (use (match_operand:SI 0 "register_operand" "r"))]
 886   ""
 887   "cmp %0,%0"
 888   [(set_attr "type" "int2")
 889    (set_attr "length" "2")])
 890
 891 (define_insn "*add_carry"
 892   [(set (match_operand:SI 0 "register_operand" "=r")
 893         (plus:SI (match_operand:SI 1 "register_operand" "%0")
 894                  (plus:SI (match_operand:SI 2 "register_operand" "r")
 895                           (ne:SI (reg:CC 17) (const_int 0)))))
 896    (set (reg:CC 17)
 897         (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))]
 898   ""
 899   "addx %0,%2"
 900   [(set_attr "type" "int2")
 901    (set_attr "length" "2")])
 902
 903 (define_insn "subsi3"
 904   [(set (match_operand:SI 0 "register_operand" "=r")
 905         (minus:SI (match_operand:SI 1 "register_operand" "0")
 906                   (match_operand:SI 2 "register_operand" "r")))]
 907   ""
 908   "sub %0,%2"
 909   [(set_attr "type" "int2")
 910    (set_attr "length" "2")])
 911
 912 (define_insn "subdi3"
 913   [(set (match_operand:DI 0 "register_operand" "=r")
 914         (minus:DI (match_operand:DI 1 "register_operand" "0")
 915                   (match_operand:DI 2 "register_operand" "r")))
 916    (clobber (reg:CC 17))]
 917   ""
 918   "#"
 919   [(set_attr "type" "multi")
 920    (set_attr "length" "6")])
 921
 922 ;; ??? The cmp clears the condition bit.  Can we speed up somehow?
 923 (define_split
 924   [(set (match_operand:DI 0 "register_operand" "")
 925         (minus:DI (match_operand:DI 1 "register_operand" "")
 926                   (match_operand:DI 2 "register_operand" "")))
 927    (clobber (reg:CC 17))]
 928   "reload_completed"
 929   [(parallel [(set (reg:CC 17)
 930                    (const_int 0))
 931               (use (match_dup 4))])
 932    (parallel [(set (match_dup 4)
 933                    (minus:SI (match_dup 4)
 934                              (minus:SI (match_dup 5)
 935                                        (ne:SI (reg:CC 17) (const_int 0)))))
 936               (set (reg:CC 17)
 937                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])
 938    (parallel [(set (match_dup 6)
 939                    (minus:SI (match_dup 6)
 940                              (minus:SI (match_dup 7)
 941                                        (ne:SI (reg:CC 17) (const_int 0)))))
 942               (set (reg:CC 17)
 943                    (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))])]
 944   "
 945 {
 946   operands[4] = operand_subword (operands[0], (WORDS_BIG_ENDIAN != 0), 0, DImode);
 947   operands[5] = operand_subword (operands[2], (WORDS_BIG_ENDIAN != 0), 0, DImode);
 948   operands[6] = operand_subword (operands[0], (WORDS_BIG_ENDIAN == 0), 0, DImode);
 949   operands[7] = operand_subword (operands[2], (WORDS_BIG_ENDIAN == 0), 0, DImode);
 950 }")
 951
 952 (define_insn "*sub_carry"
 953   [(set (match_operand:SI 0 "register_operand" "=r")
 954         (minus:SI (match_operand:SI 1 "register_operand" "%0")
 955                   (minus:SI (match_operand:SI 2 "register_operand" "r")
 956                             (ne:SI (reg:CC 17) (const_int 0)))))
 957    (set (reg:CC 17)
 958         (unspec:CC [(const_int 0)] UNSPEC_SET_CBIT))]
 959   ""
 960   "subx %0,%2"
 961   [(set_attr "type" "int2")
 962    (set_attr "length" "2")])
 963 \f
 964 ; Multiply/Divide instructions.
 965
 966 (define_insn "mulhisi3"
 967   [(set (match_operand:SI 0 "register_operand" "=r")
 968         (mult:SI (sign_extend:SI (match_operand:HI 1 "register_operand" "r"))
 969                  (sign_extend:SI (match_operand:HI 2 "register_operand" "r"))))]
 970   ""
 971   "mullo %1,%2\;mvfacmi %0"
 972   [(set_attr "type" "multi")
 973    (set_attr "length" "4")])
 974
 975 (define_insn "mulsi3"
 976   [(set (match_operand:SI 0 "register_operand" "=r")
 977         (mult:SI (match_operand:SI 1 "register_operand" "%0")
 978                  (match_operand:SI 2 "register_operand" "r")))]
 979   ""
 980   "mul %0,%2"
 981   [(set_attr "type" "mul2")
 982    (set_attr "length" "2")])
 983
 984 (define_insn "divsi3"
 985   [(set (match_operand:SI 0 "register_operand" "=r")
 986         (div:SI (match_operand:SI 1 "register_operand" "0")
 987                 (match_operand:SI 2 "register_operand" "r")))]
 988   ""
 989   "div %0,%2"
 990   [(set_attr "type" "div4")
 991    (set_attr "length" "4")])
 992
 993 (define_insn "udivsi3"
 994   [(set (match_operand:SI 0 "register_operand" "=r")
 995         (udiv:SI (match_operand:SI 1 "register_operand" "0")
 996                  (match_operand:SI 2 "register_operand" "r")))]
 997   ""
 998   "divu %0,%2"
 999   [(set_attr "type" "div4")
1000    (set_attr "length" "4")])
1001
1002 (define_insn "modsi3"
1003   [(set (match_operand:SI 0 "register_operand" "=r")
1004         (mod:SI (match_operand:SI 1 "register_operand" "0")
1005                 (match_operand:SI 2 "register_operand" "r")))]
1006   ""
1007   "rem %0,%2"
1008   [(set_attr "type" "div4")
1009    (set_attr "length" "4")])
1010
1011 (define_insn "umodsi3"
1012   [(set (match_operand:SI 0 "register_operand" "=r")
1013         (umod:SI (match_operand:SI 1 "register_operand" "0")
1014                  (match_operand:SI 2 "register_operand" "r")))]
1015   ""
1016   "remu %0,%2"
1017   [(set_attr "type" "div4")
1018    (set_attr "length" "4")])
1019 \f
1020 ;; Boolean instructions.
1021 ;;
1022 ;; We don't define the DImode versions as expand_binop does a good enough job.
1023 ;; And if it doesn't it should be fixed.
1024
1025 (define_insn "andsi3"
1026   [(set (match_operand:SI 0 "register_operand" "=r,r")
1027         (and:SI (match_operand:SI 1 "register_operand" "%0,r")
1028                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1029   ""
1030   "*
1031 {
1032   /* If we are worried about space, see if we can break this up into two
1033      short instructions, which might eliminate a NOP being inserted.  */
1034   if (optimize_size
1035       && m32r_not_same_reg (operands[0], operands[1])
1036       && satisfies_constraint_I (operands[2]))
1037     return \"#\";
1038
1039   else if (CONST_INT_P (operands[2]))
1040     return \"and3 %0,%1,%#%X2\";
1041
1042   return \"and %0,%2\";
1043 }"
1044   [(set_attr "type" "int2,int4")
1045    (set_attr "length" "2,4")])
1046
1047 (define_split
1048   [(set (match_operand:SI 0 "register_operand" "")
1049         (and:SI (match_operand:SI 1 "register_operand" "")
1050                 (match_operand:SI 2 "int8_operand" "")))]
1051   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1052   [(set (match_dup 0) (match_dup 2))
1053    (set (match_dup 0) (and:SI (match_dup 0) (match_dup 1)))]
1054   "")
1055
1056 (define_insn "iorsi3"
1057   [(set (match_operand:SI 0 "register_operand" "=r,r")
1058         (ior:SI (match_operand:SI 1 "register_operand" "%0,r")
1059                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1060   ""
1061   "*
1062 {
1063   /* If we are worried about space, see if we can break this up into two
1064      short instructions, which might eliminate a NOP being inserted.  */
1065   if (optimize_size
1066       && m32r_not_same_reg (operands[0], operands[1])
1067       && satisfies_constraint_I (operands[2]))
1068     return \"#\";
1069
1070   else if (CONST_INT_P (operands[2]))
1071     return \"or3 %0,%1,%#%X2\";
1072
1073   return \"or %0,%2\";
1074 }"
1075   [(set_attr "type" "int2,int4")
1076    (set_attr "length" "2,4")])
1077
1078 (define_split
1079   [(set (match_operand:SI 0 "register_operand" "")
1080         (ior:SI (match_operand:SI 1 "register_operand" "")
1081                 (match_operand:SI 2 "int8_operand" "")))]
1082   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1083   [(set (match_dup 0) (match_dup 2))
1084    (set (match_dup 0) (ior:SI (match_dup 0) (match_dup 1)))]
1085   "")
1086
1087 (define_insn "xorsi3"
1088   [(set (match_operand:SI 0 "register_operand" "=r,r")
1089         (xor:SI (match_operand:SI 1 "register_operand" "%0,r")
1090                 (match_operand:SI 2 "reg_or_uint16_operand" "r,K")))]
1091   ""
1092   "*
1093 {
1094   /* If we are worried about space, see if we can break this up into two
1095      short instructions, which might eliminate a NOP being inserted.  */
1096   if (optimize_size
1097       && m32r_not_same_reg (operands[0], operands[1])
1098       && satisfies_constraint_I (operands[2]))
1099     return \"#\";
1100
1101   else if (CONST_INT_P (operands[2]))
1102     return \"xor3 %0,%1,%#%X2\";
1103
1104   return \"xor %0,%2\";
1105 }"
1106   [(set_attr "type" "int2,int4")
1107    (set_attr "length" "2,4")])
1108
1109 (define_split
1110   [(set (match_operand:SI 0 "register_operand" "")
1111         (xor:SI (match_operand:SI 1 "register_operand" "")
1112                 (match_operand:SI 2 "int8_operand" "")))]
1113   "optimize_size && m32r_not_same_reg (operands[0], operands[1])"
1114   [(set (match_dup 0) (match_dup 2))
1115    (set (match_dup 0) (xor:SI (match_dup 0) (match_dup 1)))]
1116   "")
1117
1118 (define_insn "negsi2"
1119   [(set (match_operand:SI 0 "register_operand" "=r")
1120         (neg:SI (match_operand:SI 1 "register_operand" "r")))]
1121   ""
1122   "neg %0,%1"
1123   [(set_attr "type" "int2")
1124    (set_attr "length" "2")])
1125
1126 (define_insn "one_cmplsi2"
1127   [(set (match_operand:SI 0 "register_operand" "=r")
1128         (not:SI (match_operand:SI 1 "register_operand" "r")))]
1129   ""
1130   "not %0,%1"
1131   [(set_attr "type" "int2")
1132    (set_attr "length" "2")])
1133 \f
1134 ;; Shift instructions.
1135
1136 (define_insn "ashlsi3"
1137   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1138         (ashift:SI (match_operand:SI 1 "register_operand" "0,0,r")
1139                    (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1140   ""
1141   "@
1142    sll %0,%2
1143    slli %0,%#%2
1144    sll3 %0,%1,%#%2"
1145   [(set_attr "type" "shift2,shift2,shift4")
1146    (set_attr "length" "2,2,4")])
1147
1148 (define_insn "ashrsi3"
1149   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1150         (ashiftrt:SI (match_operand:SI 1 "register_operand" "0,0,r")
1151                      (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1152   ""
1153   "@
1154    sra %0,%2
1155    srai %0,%#%2
1156    sra3 %0,%1,%#%2"
1157   [(set_attr "type" "shift2,shift2,shift4")
1158    (set_attr "length" "2,2,4")])
1159
1160 (define_insn "lshrsi3"
1161   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1162         (lshiftrt:SI (match_operand:SI 1 "register_operand" "0,0,r")
1163                      (match_operand:SI 2 "reg_or_uint16_operand" "r,O,K")))]
1164   ""
1165   "@
1166    srl %0,%2
1167    srli %0,%#%2
1168    srl3 %0,%1,%#%2"
1169   [(set_attr "type" "shift2,shift2,shift4")
1170    (set_attr "length" "2,2,4")])
1171 \f
1172 ;; Compare instructions.
1173 ;; This controls RTL generation and register allocation.
1174
1175 ;; We generate RTL for comparisons and branches by having the cmpxx
1176 ;; patterns store away the operands.  Then the bcc patterns
1177 ;; emit RTL for both the compare and the branch.
1178 ;;
1179 ;; On the m32r it is more efficient to use the bxxz instructions and
1180 ;; thus merge the compare and branch into one instruction, so they are
1181 ;; preferred.
1182
1183 (define_insn "cmp_eqsi_zero_insn"
1184   [(set (reg:CC 17)
1185         (eq:CC (match_operand:SI 0 "register_operand" "r,r")
1186                (match_operand:SI 1 "reg_or_zero_operand" "r,P")))]
1187   "TARGET_M32RX || TARGET_M32R2"
1188   "@
1189    cmpeq %0, %1
1190    cmpz  %0"
1191   [(set_attr "type" "int4")
1192    (set_attr "length" "4")])
1193
1194 ;; The cmp_xxx_insn patterns set the condition bit to the result of the
1195 ;; comparison.  There isn't a "compare equal" instruction so cmp_eqsi_insn
1196 ;; is quite inefficient.  However, it is rarely used.
1197
1198 (define_insn "cmp_eqsi_insn"
1199   [(set (reg:CC 17)
1200         (eq:CC (match_operand:SI 0 "register_operand" "r,r")
1201                (match_operand:SI 1 "reg_or_cmp_int16_operand" "r,P")))
1202    (clobber (match_scratch:SI 2 "=&r,&r"))]
1203   ""
1204   "*
1205 {
1206   if (which_alternative == 0)
1207     {
1208          return \"mv %2,%0\;sub %2,%1\;cmpui %2,#1\";
1209     }
1210   else
1211     {
1212         if (INTVAL (operands [1]) == 0)
1213           return \"cmpui %0, #1\";
1214         else if (REGNO (operands [2]) == REGNO (operands [0]))
1215           return \"addi %0,%#%N1\;cmpui %2,#1\";
1216         else
1217           return \"add3 %2,%0,%#%N1\;cmpui %2,#1\";
1218     }
1219 }"
1220   [(set_attr "type" "multi,multi")
1221    (set_attr "length" "8,8")])
1222
1223 (define_insn "cmp_ltsi_insn"
1224   [(set (reg:CC 17)
1225         (lt:CC (match_operand:SI 0 "register_operand" "r,r")
1226                (match_operand:SI 1 "reg_or_int16_operand" "r,J")))]
1227   ""
1228   "@
1229    cmp %0,%1
1230    cmpi %0,%#%1"
1231   [(set_attr "type" "int2,int4")
1232    (set_attr "length" "2,4")])
1233
1234 (define_insn "cmp_ltusi_insn"
1235   [(set (reg:CC 17)
1236         (ltu:CC (match_operand:SI 0 "register_operand" "r,r")
1237                 (match_operand:SI 1 "reg_or_int16_operand" "r,J")))]
1238   ""
1239   "@
1240    cmpu %0,%1
1241    cmpui %0,%#%1"
1242   [(set_attr "type" "int2,int4")
1243    (set_attr "length" "2,4")])
1244 \f
1245 ;; These control RTL generation for conditional jump insns.
1246
1247 (define_expand "cbranchsi4"
1248   ; the comparison is emitted by gen_compare if needed.
1249   [(set (pc)
1250         (if_then_else (match_operator 0 "ordered_comparison_operator"
1251                        [(match_operand:SI 1 "register_operand" "")
1252                         (match_operand:SI 2 "reg_or_cmp_int16_operand" "")])
1253                       (label_ref (match_operand 3 "" ""))
1254                       (pc)))]
1255   ""
1256   "
1257 {
1258   operands[0] = gen_compare (GET_CODE (operands[0]), operands[1], operands[2], FALSE);
1259   operands[1] = XEXP (operands[0], 0);
1260   operands[2] = XEXP (operands[0], 1);
1261 }")
1262
1263 ;; Now match both normal and inverted jump.
1264
1265 (define_insn "*branch_insn"
1266   [(set (pc)
1267         (if_then_else (match_operator 1 "eqne_comparison_operator"
1268                                       [(reg 17) (const_int 0)])
1269                       (label_ref (match_operand 0 "" ""))
1270                       (pc)))]
1271   ""
1272   "*
1273 {
1274   static char instruction[40];
1275   sprintf (instruction, \"%s%s %%l0\",
1276            (GET_CODE (operands[1]) == NE) ? \"bc\" : \"bnc\",
1277            (get_attr_length (insn) == 2) ? \".s\" : \"\");
1278   return instruction;
1279 }"
1280   [(set_attr "type" "branch")
1281    ; cf PR gcc/28508
1282    ; We use 300/600 instead of 512,1024 to account for inaccurate insn
1283    ; lengths and insn alignments that are complex to track.
1284    ; It's not important that we be hyper-precise here.  It may be more
1285    ; important blah blah blah when the chip supports parallel execution
1286    ; blah blah blah but until then blah blah blah this is simple and
1287    ; suffices.
1288    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1289                                                  (const_int 300))
1290                                            (const_int 600))
1291                                       (const_int 2)
1292                                       (const_int 4)))])
1293
1294 (define_insn "*rev_branch_insn"
1295   [(set (pc)
1296         (if_then_else (match_operator 1 "eqne_comparison_operator"
1297                                       [(reg 17) (const_int 0)])
1298                       (pc)
1299                       (label_ref (match_operand 0 "" ""))))]
1300   ;"REVERSIBLE_CC_MODE (GET_MODE (XEXP (operands[1], 0)))"
1301   ""
1302   "*
1303 {
1304   static char instruction[40];
1305   sprintf (instruction, \"%s%s %%l0\",
1306            (GET_CODE (operands[1]) == EQ) ? \"bc\" : \"bnc\",
1307            (get_attr_length (insn) == 2) ? \".s\" : \"\");
1308   return instruction;
1309 }"
1310   [(set_attr "type" "branch")
1311    ; cf PR gcc/28508
1312    ; We use 300/600 instead of 512,1024 to account for inaccurate insn
1313    ; lengths and insn alignments that are complex to track.
1314    ; It's not important that we be hyper-precise here.  It may be more
1315    ; important blah blah blah when the chip supports parallel execution
1316    ; blah blah blah but until then blah blah blah this is simple and
1317    ; suffices.
1318    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1319                                                  (const_int 300))
1320                                            (const_int 600))
1321                                       (const_int 2)
1322                                       (const_int 4)))])
1323
1324 ; reg/reg compare and branch insns
1325
1326 (define_insn "*reg_branch_insn"
1327   [(set (pc)
1328         (if_then_else (match_operator 1 "eqne_comparison_operator"
1329                                       [(match_operand:SI 2 "register_operand" "r")
1330                                        (match_operand:SI 3 "register_operand" "r")])
1331                       (label_ref (match_operand 0 "" ""))
1332                       (pc)))]
1333   ""
1334   "*
1335 {
1336   /* Is branch target reachable with beq/bne?  */
1337   if (get_attr_length (insn) == 4)
1338     {
1339       if (GET_CODE (operands[1]) == EQ)
1340         return \"beq %2,%3,%l0\";
1341       else
1342         return \"bne %2,%3,%l0\";
1343     }
1344   else
1345     {
1346       if (GET_CODE (operands[1]) == EQ)
1347         return \"bne %2,%3,1f\;bra %l0\;1:\";
1348       else
1349         return \"beq %2,%3,1f\;bra %l0\;1:\";
1350     }
1351 }"
1352   [(set_attr "type" "branch")
1353   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1354   ; which is complex to track and inaccurate length specs.
1355    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1356                                                  (const_int 25000))
1357                                            (const_int 50000))
1358                                       (const_int 4)
1359                                       (const_int 8)))])
1360
1361 (define_insn "*rev_reg_branch_insn"
1362   [(set (pc)
1363         (if_then_else (match_operator 1 "eqne_comparison_operator"
1364                                       [(match_operand:SI 2 "register_operand" "r")
1365                                        (match_operand:SI 3 "register_operand" "r")])
1366                       (pc)
1367                       (label_ref (match_operand 0 "" ""))))]
1368   ""
1369   "*
1370 {
1371   /* Is branch target reachable with beq/bne?  */
1372   if (get_attr_length (insn) == 4)
1373     {
1374       if (GET_CODE (operands[1]) == NE)
1375         return \"beq %2,%3,%l0\";
1376       else
1377         return \"bne %2,%3,%l0\";
1378     }
1379   else
1380     {
1381       if (GET_CODE (operands[1]) == NE)
1382         return \"bne %2,%3,1f\;bra %l0\;1:\";
1383       else
1384         return \"beq %2,%3,1f\;bra %l0\;1:\";
1385     }
1386 }"
1387   [(set_attr "type" "branch")
1388   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1389   ; which is complex to track and inaccurate length specs.
1390    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1391                                                  (const_int 25000))
1392                                            (const_int 50000))
1393                                       (const_int 4)
1394                                       (const_int 8)))])
1395
1396 ; reg/zero compare and branch insns
1397
1398 (define_insn "*zero_branch_insn"
1399   [(set (pc)
1400         (if_then_else (match_operator 1 "signed_comparison_operator"
1401                                       [(match_operand:SI 2 "register_operand" "r")
1402                                        (const_int 0)])
1403                       (label_ref (match_operand 0 "" ""))
1404                       (pc)))]
1405   ""
1406   "*
1407 {
1408   const char *br,*invbr;
1409   char asmtext[40];
1410
1411   switch (GET_CODE (operands[1]))
1412     {
1413       case EQ : br = \"eq\"; invbr = \"ne\"; break;
1414       case NE : br = \"ne\"; invbr = \"eq\"; break;
1415       case LE : br = \"le\"; invbr = \"gt\"; break;
1416       case GT : br = \"gt\"; invbr = \"le\"; break;
1417       case LT : br = \"lt\"; invbr = \"ge\"; break;
1418       case GE : br = \"ge\"; invbr = \"lt\"; break;
1419
1420       default: gcc_unreachable ();
1421     }
1422
1423   /* Is branch target reachable with bxxz?  */
1424   if (get_attr_length (insn) == 4)
1425     {
1426       sprintf (asmtext, \"b%sz %%2,%%l0\", br);
1427       output_asm_insn (asmtext, operands);
1428     }
1429   else
1430     {
1431       sprintf (asmtext, \"b%sz %%2,1f\;bra %%l0\;1:\", invbr);
1432       output_asm_insn (asmtext, operands);
1433     }
1434   return \"\";
1435 }"
1436   [(set_attr "type" "branch")
1437   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1438   ; which is complex to track and inaccurate length specs.
1439    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1440                                                  (const_int 25000))
1441                                            (const_int 50000))
1442                                       (const_int 4)
1443                                       (const_int 8)))])
1444
1445 (define_insn "*rev_zero_branch_insn"
1446   [(set (pc)
1447         (if_then_else (match_operator 1 "eqne_comparison_operator"
1448                                       [(match_operand:SI 2 "register_operand" "r")
1449                                        (const_int 0)])
1450                       (pc)
1451                       (label_ref (match_operand 0 "" ""))))]
1452   ""
1453   "*
1454 {
1455   const char *br,*invbr;
1456   char asmtext[40];
1457
1458   switch (GET_CODE (operands[1]))
1459     {
1460       case EQ : br = \"eq\"; invbr = \"ne\"; break;
1461       case NE : br = \"ne\"; invbr = \"eq\"; break;
1462       case LE : br = \"le\"; invbr = \"gt\"; break;
1463       case GT : br = \"gt\"; invbr = \"le\"; break;
1464       case LT : br = \"lt\"; invbr = \"ge\"; break;
1465       case GE : br = \"ge\"; invbr = \"lt\"; break;
1466
1467       default: gcc_unreachable ();
1468     }
1469
1470   /* Is branch target reachable with bxxz?  */
1471   if (get_attr_length (insn) == 4)
1472     {
1473       sprintf (asmtext, \"b%sz %%2,%%l0\", invbr);
1474       output_asm_insn (asmtext, operands);
1475     }
1476   else
1477     {
1478       sprintf (asmtext, \"b%sz %%2,1f\;bra %%l0\;1:\", br);
1479       output_asm_insn (asmtext, operands);
1480     }
1481   return \"\";
1482 }"
1483   [(set_attr "type" "branch")
1484   ; We use 25000/50000 instead of 32768/65536 to account for slot filling
1485   ; which is complex to track and inaccurate length specs.
1486    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1487                                                  (const_int 25000))
1488                                            (const_int 50000))
1489                                       (const_int 4)
1490                                       (const_int 8)))])
1491 \f
1492 ;; S<cc> operations to set a register to 1/0 based on a comparison
1493
1494 (define_expand "cstoresi4"
1495   [(match_operand:SI 0 "register_operand" "")
1496    (match_operator:SI 1 "ordered_comparison_operator"
1497     [(match_operand:SI 2 "register_operand" "")
1498      (match_operand:SI 3 "reg_or_cmp_int16_operand" "")])]
1499   ""
1500   "
1501 {
1502   if (GET_MODE (operands[0]) != SImode)
1503     FAIL;
1504
1505   if (!gen_cond_store (GET_CODE (operands[1]),
1506                        operands[0], operands[2], operands[3]))
1507     FAIL;
1508
1509   DONE;
1510 }")
1511
1512 (define_insn "seq_insn_m32rx"
1513   [(set (match_operand:SI 0 "register_operand" "=r")
1514         (eq:SI (match_operand:SI 1 "register_operand" "%r")
1515                (match_operand:SI 2 "reg_or_zero_operand" "rP")))
1516    (clobber (reg:CC 17))]
1517   "TARGET_M32RX || TARGET_M32R2"
1518   "#"
1519   [(set_attr "type" "multi")
1520    (set_attr "length" "6")])
1521
1522 (define_split
1523   [(set (match_operand:SI 0 "register_operand" "")
1524         (eq:SI (match_operand:SI 1 "register_operand" "")
1525                (match_operand:SI 2 "reg_or_zero_operand" "")))
1526    (clobber (reg:CC 17))]
1527   "TARGET_M32RX || TARGET_M32R2"
1528   [(set (reg:CC 17)
1529         (eq:CC (match_dup 1)
1530                (match_dup 2)))
1531    (set (match_dup 0)
1532         (ne:SI (reg:CC 17) (const_int 0)))]
1533   "")
1534
1535 (define_insn "seq_zero_insn"
1536   [(set (match_operand:SI 0 "register_operand" "=r")
1537         (eq:SI (match_operand:SI 1 "register_operand" "r")
1538                (const_int 0)))
1539    (clobber (reg:CC 17))]
1540   "TARGET_M32R"
1541   "#"
1542   [(set_attr "type" "multi")
1543    (set_attr "length" "6")])
1544
1545 (define_split
1546   [(set (match_operand:SI 0 "register_operand" "")
1547         (eq:SI (match_operand:SI 1 "register_operand" "")
1548                (const_int 0)))
1549    (clobber (reg:CC 17))]
1550   "TARGET_M32R"
1551   [(match_dup 3)]
1552   "
1553 {
1554   rtx op0 = operands[0];
1555   rtx op1 = operands[1];
1556
1557   start_sequence ();
1558   emit_insn (gen_cmp_ltusi_insn (op1, const1_rtx));
1559   emit_insn (gen_movcc_insn (op0));
1560   operands[3] = get_insns ();
1561   end_sequence ();
1562 }")
1563
1564 (define_insn "seq_insn"
1565   [(set (match_operand:SI 0 "register_operand" "=r,r,??r,r")
1566         (eq:SI (match_operand:SI 1 "register_operand" "r,r,r,r")
1567                (match_operand:SI 2 "reg_or_eq_int16_operand" "r,r,r,PK")))
1568    (clobber (reg:CC 17))
1569    (clobber (match_scratch:SI 3 "=1,2,&r,r"))]
1570   "TARGET_M32R"
1571   "#"
1572   [(set_attr "type" "multi")
1573    (set_attr "length" "8,8,10,10")])
1574
1575 (define_split
1576   [(set (match_operand:SI 0 "register_operand" "")
1577         (eq:SI (match_operand:SI 1 "register_operand" "")
1578                (match_operand:SI 2 "reg_or_eq_int16_operand" "")))
1579    (clobber (reg:CC 17))
1580    (clobber (match_scratch:SI 3 ""))]
1581   "TARGET_M32R && reload_completed"
1582   [(match_dup 4)]
1583   "
1584 {
1585   rtx op0 = operands[0];
1586   rtx op1 = operands[1];
1587   rtx op2 = operands[2];
1588   rtx op3 = operands[3];
1589   HOST_WIDE_INT value;
1590
1591   if (REG_P (op2) && REG_P (op3)
1592       && REGNO (op2) == REGNO (op3))
1593     {
1594       op1 = operands[2];
1595       op2 = operands[1];
1596     }
1597
1598   start_sequence ();
1599   if (REG_P (op1) && REG_P (op3)
1600       && REGNO (op1) != REGNO (op3))
1601     {
1602       emit_move_insn (op3, op1);
1603       op1 = op3;
1604     }
1605
1606   if (satisfies_constraint_P (op2) && (value = INTVAL (op2)) != 0)
1607     emit_insn (gen_addsi3 (op3, op1, GEN_INT (-value)));
1608   else
1609     emit_insn (gen_xorsi3 (op3, op1, op2));
1610
1611   emit_insn (gen_cmp_ltusi_insn (op3, const1_rtx));
1612   emit_insn (gen_movcc_insn (op0));
1613   operands[4] = get_insns ();
1614   end_sequence ();
1615 }")
1616
1617 (define_insn "sne_zero_insn"
1618   [(set (match_operand:SI 0 "register_operand" "=r")
1619         (ne:SI (match_operand:SI 1 "register_operand" "r")
1620                (const_int 0)))
1621    (clobber (reg:CC 17))
1622    (clobber (match_scratch:SI 2 "=&r"))]
1623   ""
1624   "#"
1625   [(set_attr "type" "multi")
1626    (set_attr "length" "6")])
1627
1628 (define_split
1629   [(set (match_operand:SI 0 "register_operand" "")
1630         (ne:SI (match_operand:SI 1 "register_operand" "")
1631                (const_int 0)))
1632    (clobber (reg:CC 17))
1633    (clobber (match_scratch:SI 2 ""))]
1634   "reload_completed"
1635   [(set (match_dup 2)
1636         (const_int 0))
1637    (set (reg:CC 17)
1638         (ltu:CC (match_dup 2)
1639                 (match_dup 1)))
1640    (set (match_dup 0)
1641         (ne:SI (reg:CC 17) (const_int 0)))]
1642   "")
1643
1644 (define_insn "slt_insn"
1645   [(set (match_operand:SI 0 "register_operand" "=r,r")
1646         (lt:SI (match_operand:SI 1 "register_operand" "r,r")
1647                (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1648    (clobber (reg:CC 17))]
1649   ""
1650   "#"
1651   [(set_attr "type" "multi")
1652    (set_attr "length" "4,6")])
1653
1654 (define_split
1655   [(set (match_operand:SI 0 "register_operand" "")
1656         (lt:SI (match_operand:SI 1 "register_operand" "")
1657                (match_operand:SI 2 "reg_or_int16_operand" "")))
1658    (clobber (reg:CC 17))]
1659   ""
1660   [(set (reg:CC 17)
1661         (lt:CC (match_dup 1)
1662                (match_dup 2)))
1663    (set (match_dup 0)
1664         (ne:SI (reg:CC 17) (const_int 0)))]
1665   "")
1666
1667 (define_insn "sle_insn"
1668   [(set (match_operand:SI 0 "register_operand" "=r")
1669         (le:SI (match_operand:SI 1 "register_operand" "r")
1670                (match_operand:SI 2 "register_operand" "r")))
1671    (clobber (reg:CC 17))]
1672   ""
1673   "#"
1674   [(set_attr "type" "multi")
1675    (set_attr "length" "8")])
1676
1677 (define_split
1678   [(set (match_operand:SI 0 "register_operand" "")
1679         (le:SI (match_operand:SI 1 "register_operand" "")
1680                (match_operand:SI 2 "register_operand" "")))
1681    (clobber (reg:CC 17))]
1682   "!optimize_size"
1683   [(set (reg:CC 17)
1684         (lt:CC (match_dup 2)
1685                (match_dup 1)))
1686    (set (match_dup 0)
1687         (ne:SI (reg:CC 17) (const_int 0)))
1688    (set (match_dup 0)
1689         (xor:SI (match_dup 0)
1690                 (const_int 1)))]
1691   "")
1692
1693 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1694 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1695 (define_split
1696   [(set (match_operand:SI 0 "register_operand" "")
1697         (le:SI (match_operand:SI 1 "register_operand" "")
1698                (match_operand:SI 2 "register_operand" "")))
1699    (clobber (reg:CC 17))]
1700   "optimize_size"
1701   [(set (reg:CC 17)
1702         (lt:CC (match_dup 2)
1703                (match_dup 1)))
1704    (set (match_dup 0)
1705         (ne:SI (reg:CC 17) (const_int 0)))
1706    (set (match_dup 0)
1707         (plus:SI (match_dup 0)
1708                  (const_int -1)))
1709    (set (match_dup 0)
1710         (neg:SI (match_dup 0)))]
1711   "")
1712
1713 (define_insn "sge_insn"
1714   [(set (match_operand:SI 0 "register_operand" "=r,r")
1715         (ge:SI (match_operand:SI 1 "register_operand" "r,r")
1716                (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1717    (clobber (reg:CC 17))]
1718   ""
1719   "#"
1720   [(set_attr "type" "multi")
1721    (set_attr "length" "8,10")])
1722
1723 (define_split
1724   [(set (match_operand:SI 0 "register_operand" "")
1725         (ge:SI (match_operand:SI 1 "register_operand" "")
1726                (match_operand:SI 2 "reg_or_int16_operand" "")))
1727    (clobber (reg:CC 17))]
1728   "!optimize_size"
1729   [(set (reg:CC 17)
1730         (lt:CC (match_dup 1)
1731                (match_dup 2)))
1732    (set (match_dup 0)
1733         (ne:SI (reg:CC 17) (const_int 0)))
1734    (set (match_dup 0)
1735         (xor:SI (match_dup 0)
1736                 (const_int 1)))]
1737   "")
1738
1739 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1740 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1741 (define_split
1742   [(set (match_operand:SI 0 "register_operand" "")
1743         (ge:SI (match_operand:SI 1 "register_operand" "")
1744                (match_operand:SI 2 "reg_or_int16_operand" "")))
1745    (clobber (reg:CC 17))]
1746   "optimize_size"
1747   [(set (reg:CC 17)
1748         (lt:CC (match_dup 1)
1749                (match_dup 2)))
1750    (set (match_dup 0)
1751         (ne:SI (reg:CC 17) (const_int 0)))
1752    (set (match_dup 0)
1753         (plus:SI (match_dup 0)
1754                  (const_int -1)))
1755    (set (match_dup 0)
1756         (neg:SI (match_dup 0)))]
1757   "")
1758
1759 (define_insn "sltu_insn"
1760   [(set (match_operand:SI 0 "register_operand" "=r,r")
1761         (ltu:SI (match_operand:SI 1 "register_operand" "r,r")
1762                 (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1763    (clobber (reg:CC 17))]
1764   ""
1765   "#"
1766   [(set_attr "type" "multi")
1767    (set_attr "length" "6,8")])
1768
1769 (define_split
1770   [(set (match_operand:SI 0 "register_operand" "")
1771         (ltu:SI (match_operand:SI 1 "register_operand" "")
1772                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1773    (clobber (reg:CC 17))]
1774   ""
1775   [(set (reg:CC 17)
1776         (ltu:CC (match_dup 1)
1777                 (match_dup 2)))
1778    (set (match_dup 0)
1779         (ne:SI (reg:CC 17) (const_int 0)))]
1780   "")
1781
1782 (define_insn "sleu_insn"
1783   [(set (match_operand:SI 0 "register_operand" "=r")
1784         (leu:SI (match_operand:SI 1 "register_operand" "r")
1785                 (match_operand:SI 2 "register_operand" "r")))
1786    (clobber (reg:CC 17))]
1787   ""
1788   "#"
1789   [(set_attr "type" "multi")
1790    (set_attr "length" "8")])
1791
1792 (define_split
1793   [(set (match_operand:SI 0 "register_operand" "")
1794         (leu:SI (match_operand:SI 1 "register_operand" "")
1795                 (match_operand:SI 2 "register_operand" "")))
1796    (clobber (reg:CC 17))]
1797   "!optimize_size"
1798   [(set (reg:CC 17)
1799         (ltu:CC (match_dup 2)
1800                 (match_dup 1)))
1801    (set (match_dup 0)
1802         (ne:SI (reg:CC 17) (const_int 0)))
1803    (set (match_dup 0)
1804         (xor:SI (match_dup 0)
1805                 (const_int 1)))]
1806   "")
1807
1808 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1809 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1810 (define_split
1811   [(set (match_operand:SI 0 "register_operand" "")
1812         (leu:SI (match_operand:SI 1 "register_operand" "")
1813                 (match_operand:SI 2 "register_operand" "")))
1814    (clobber (reg:CC 17))]
1815   "optimize_size"
1816   [(set (reg:CC 17)
1817         (ltu:CC (match_dup 2)
1818                 (match_dup 1)))
1819    (set (match_dup 0)
1820         (ne:SI (reg:CC 17) (const_int 0)))
1821    (set (match_dup 0)
1822         (plus:SI (match_dup 0)
1823                  (const_int -1)))
1824    (set (match_dup 0)
1825         (neg:SI (match_dup 0)))]
1826   "")
1827
1828 (define_insn "sgeu_insn"
1829   [(set (match_operand:SI 0 "register_operand" "=r,r")
1830         (geu:SI (match_operand:SI 1 "register_operand" "r,r")
1831                 (match_operand:SI 2 "reg_or_int16_operand" "r,J")))
1832    (clobber (reg:CC 17))]
1833   ""
1834   "#"
1835   [(set_attr "type" "multi")
1836    (set_attr "length" "8,10")])
1837
1838 (define_split
1839   [(set (match_operand:SI 0 "register_operand" "")
1840         (geu:SI (match_operand:SI 1 "register_operand" "")
1841                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1842    (clobber (reg:CC 17))]
1843   "!optimize_size"
1844   [(set (reg:CC 17)
1845         (ltu:CC (match_dup 1)
1846                 (match_dup 2)))
1847    (set (match_dup 0)
1848         (ne:SI (reg:CC 17) (const_int 0)))
1849    (set (match_dup 0)
1850         (xor:SI (match_dup 0)
1851                 (const_int 1)))]
1852   "")
1853
1854 ;; If optimizing for space, use -(reg - 1) to invert the comparison rather than
1855 ;; xor reg,reg,1 which might eliminate a NOP being inserted.
1856 (define_split
1857   [(set (match_operand:SI 0 "register_operand" "")
1858         (geu:SI (match_operand:SI 1 "register_operand" "")
1859                 (match_operand:SI 2 "reg_or_int16_operand" "")))
1860    (clobber (reg:CC 17))]
1861   "optimize_size"
1862   [(set (reg:CC 17)
1863         (ltu:CC (match_dup 1)
1864                 (match_dup 2)))
1865    (set (match_dup 0)
1866         (ne:SI (reg:CC 17) (const_int 0)))
1867    (set (match_dup 0)
1868         (plus:SI (match_dup 0)
1869                  (const_int -1)))
1870    (set (match_dup 0)
1871         (neg:SI (match_dup 0)))]
1872   "")
1873
1874 (define_insn "movcc_insn"
1875   [(set (match_operand:SI 0 "register_operand" "=r")
1876         (ne:SI (reg:CC 17) (const_int 0)))]
1877   ""
1878   "mvfc %0, cbr"
1879   [(set_attr "type" "misc")
1880    (set_attr "length" "2")])
1881
1882 \f
1883 ;; Unconditional and other jump instructions.
1884
1885 (define_insn "jump"
1886   [(set (pc) (label_ref (match_operand 0 "" "")))]
1887   ""
1888   "bra %l0"
1889   [(set_attr "type" "uncond_branch")
1890    (set (attr "length") (if_then_else (ltu (plus (minus (match_dup 0) (pc))
1891                                                  (const_int 400))
1892                                            (const_int 800))
1893                                       (const_int 2)
1894                                       (const_int 4)))])
1895
1896 (define_insn "indirect_jump"
1897   [(set (pc) (match_operand:SI 0 "address_operand" "p"))]
1898   ""
1899   "jmp %a0"
1900   [(set_attr "type" "uncond_branch")
1901    (set_attr "length" "2")])
1902
1903 (define_insn "return_lr"
1904   [(parallel [(return) (use (reg:SI 14))])]
1905   ""
1906   "jmp lr"
1907   [(set_attr "type" "uncond_branch")
1908    (set_attr "length" "2")])
1909
1910 (define_insn "return_rte"
1911   [(return)]
1912   ""
1913   "rte"
1914   [(set_attr "type" "uncond_branch")
1915    (set_attr "length" "2")])
1916
1917 (define_expand "return"
1918   [(return)]
1919   "direct_return ()"
1920   "
1921 {
1922   emit_jump_insn (gen_return_lr ());
1923   DONE;
1924 }")
1925
1926 (define_expand "return_normal"
1927   [(return)]
1928   "!direct_return ()"
1929   "
1930 {
1931   enum m32r_function_type fn_type;
1932
1933   fn_type = m32r_compute_function_type (current_function_decl);
1934   if (M32R_INTERRUPT_P (fn_type))
1935     {
1936       emit_jump_insn (gen_return_rte ());
1937       DONE;
1938     }
1939
1940   emit_jump_insn (gen_return_lr ());
1941   DONE;
1942 }")
1943
1944 (define_expand "tablejump"
1945   [(parallel [(set (pc) (match_operand 0 "register_operand" "r"))
1946               (use (label_ref (match_operand 1 "" "")))])]
1947   ""
1948   "
1949 {
1950   /* In pic mode, our address differences are against the base of the
1951      table.  Add that base value back in; CSE ought to be able to combine
1952      the two address loads.  */
1953   if (flag_pic)
1954     {
1955       rtx tmp, tmp2;
1956
1957       tmp = gen_rtx_LABEL_REF (Pmode, operands[1]);
1958       tmp2 = operands[0];
1959       tmp = gen_rtx_PLUS (Pmode, tmp2, tmp);
1960       operands[0] = memory_address (Pmode, tmp);
1961     }
1962 }")
1963
1964 (define_insn "*tablejump_insn"
1965   [(set (pc) (match_operand:SI 0 "address_operand" "p"))
1966    (use (label_ref (match_operand 1 "" "")))]
1967   ""
1968   "jmp %a0"
1969   [(set_attr "type" "uncond_branch")
1970    (set_attr "length" "2")])
1971
1972 (define_expand "call"
1973   ;; operands[1] is stack_size_rtx
1974   ;; operands[2] is next_arg_register
1975   [(parallel [(call (match_operand:SI 0 "call_operand" "")
1976                     (match_operand 1 "" ""))
1977              (clobber (reg:SI 14))])]
1978   ""
1979   "
1980 {
1981   if (flag_pic)
1982     crtl->uses_pic_offset_table = 1;
1983 }")
1984
1985 (define_insn "*call_via_reg"
1986   [(call (mem:SI (match_operand:SI 0 "register_operand" "r"))
1987          (match_operand 1 "" ""))
1988    (clobber (reg:SI 14))]
1989   ""
1990   "jl %0"
1991   [(set_attr "type" "call")
1992    (set_attr "length" "2")])
1993
1994 (define_insn "*call_via_label"
1995   [(call (mem:SI (match_operand:SI 0 "call_address_operand" ""))
1996          (match_operand 1 "" ""))
1997    (clobber (reg:SI 14))]
1998   ""
1999   "*
2000 {
2001   int call26_p = call26_operand (operands[0], FUNCTION_MODE);
2002
2003   if (! call26_p)
2004     {
2005       /* We may not be able to reach with a `bl' insn so punt and leave it to
2006          the linker.
2007          We do this here, rather than doing a force_reg in the define_expand
2008          so these insns won't be separated, say by scheduling, thus simplifying
2009          the linker.  */
2010       return \"seth r14,%T0\;add3 r14,r14,%B0\;jl r14\";
2011     }
2012   else
2013     return \"bl %0\";
2014 }"
2015   [(set_attr "type" "call")
2016    (set (attr "length")
2017         (if_then_else (eq (symbol_ref "call26_operand (operands[0], FUNCTION_MODE)")
2018                           (const_int 0))
2019                       (const_int 12) ; 10 + 2 for nop filler
2020                       ; The return address must be on a 4 byte boundary so
2021                       ; there's no point in using a value of 2 here.  A 2 byte
2022                       ; insn may go in the left slot but we currently can't
2023                       ; use such knowledge.
2024                       (const_int 4)))])
2025
2026 (define_expand "call_value"
2027   ;; operand 2 is stack_size_rtx
2028   ;; operand 3 is next_arg_register
2029   [(parallel [(set (match_operand 0 "register_operand" "=r")
2030                    (call (match_operand:SI 1 "call_operand" "")
2031                          (match_operand 2 "" "")))
2032              (clobber (reg:SI 14))])]
2033   ""
2034   "
2035 {
2036   if (flag_pic)
2037     crtl->uses_pic_offset_table = 1;
2038 }")
2039
2040 (define_insn "*call_value_via_reg"
2041   [(set (match_operand 0 "register_operand" "=r")
2042         (call (mem:SI (match_operand:SI 1 "register_operand" "r"))
2043               (match_operand 2 "" "")))
2044    (clobber (reg:SI 14))]
2045   ""
2046   "jl %1"
2047   [(set_attr "type" "call")
2048    (set_attr "length" "2")])
2049
2050 (define_insn "*call_value_via_label"
2051   [(set (match_operand 0 "register_operand" "=r")
2052         (call (mem:SI (match_operand:SI 1 "call_address_operand" ""))
2053               (match_operand 2 "" "")))
2054    (clobber (reg:SI 14))]
2055   ""
2056   "*
2057 {
2058   int call26_p = call26_operand (operands[1], FUNCTION_MODE);
2059
2060   if (flag_pic)
2061     crtl->uses_pic_offset_table = 1;
2062
2063   if (! call26_p)
2064     {
2065       /* We may not be able to reach with a `bl' insn so punt and leave it to
2066          the linker.
2067          We do this here, rather than doing a force_reg in the define_expand
2068          so these insns won't be separated, say by scheduling, thus simplifying
2069          the linker.  */
2070       return \"seth r14,%T1\;add3 r14,r14,%B1\;jl r14\";
2071     }
2072   else
2073     return \"bl %1\";
2074 }"
2075   [(set_attr "type" "call")
2076    (set (attr "length")
2077         (if_then_else (eq (symbol_ref "call26_operand (operands[1], FUNCTION_MODE)")
2078                           (const_int 0))
2079                       (const_int 12) ; 10 + 2 for nop filler
2080                       ; The return address must be on a 4 byte boundary so
2081                       ; there's no point in using a value of 2 here.  A 2 byte
2082                       ; insn may go in the left slot but we currently can't
2083                       ; use such knowledge.
2084                       (const_int 4)))])
2085 \f
2086 (define_insn "nop"
2087   [(const_int 0)]
2088   ""
2089   "nop"
2090   [(set_attr "type" "int2")
2091    (set_attr "length" "2")])
2092
2093 ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and
2094 ;; all of memory.  This blocks insns from being moved across this point.
2095
2096 (define_insn "blockage"
2097   [(unspec_volatile [(const_int 0)] UNSPECV_BLOCKAGE)]
2098   ""
2099   "")
2100
2101 ;; Special pattern to flush the icache.
2102
2103 (define_insn "flush_icache"
2104   [(unspec_volatile [(match_operand 0 "memory_operand" "m")]
2105                     UNSPECV_FLUSH_ICACHE)
2106    (match_operand 1 "" "")
2107    (clobber (reg:SI 17))]
2108   ""
2109   "* return \"trap %#%1 ; flush-icache\";"
2110   [(set_attr "type" "int4")
2111    (set_attr "length" "4")])
2112 \f
2113 ;; Speed up fabs and provide correct sign handling for -0
2114
2115 (define_insn "absdf2"
2116   [(set (match_operand:DF 0 "register_operand" "=r")
2117         (abs:DF (match_operand:DF 1 "register_operand" "0")))]
2118   ""
2119   "#"
2120   [(set_attr "type" "multi")
2121    (set_attr "length" "4")])
2122
2123 (define_split
2124   [(set (match_operand:DF 0 "register_operand" "")
2125         (abs:DF (match_operand:DF 1 "register_operand" "")))]
2126   "reload_completed"
2127   [(set (match_dup 2)
2128         (ashift:SI (match_dup 2)
2129                    (const_int 1)))
2130    (set (match_dup 2)
2131         (lshiftrt:SI (match_dup 2)
2132                      (const_int 1)))]
2133   "operands[2] = gen_highpart (SImode, operands[0]);")
2134
2135 (define_insn "abssf2"
2136   [(set (match_operand:SF 0 "register_operand" "=r")
2137         (abs:SF (match_operand:SF 1 "register_operand" "0")))]
2138   ""
2139   "#"
2140   [(set_attr "type" "multi")
2141    (set_attr "length" "4")])
2142
2143 (define_split
2144   [(set (match_operand:SF 0 "register_operand" "")
2145         (abs:SF (match_operand:SF 1 "register_operand" "")))]
2146   "reload_completed"
2147   [(set (match_dup 2)
2148         (ashift:SI (match_dup 2)
2149                    (const_int 1)))
2150    (set (match_dup 2)
2151         (lshiftrt:SI (match_dup 2)
2152                      (const_int 1)))]
2153   "operands[2] = gen_highpart (SImode, operands[0]);")
2154 \f
2155 ;; Conditional move instructions
2156 ;; Based on those done for the d10v
2157
2158 (define_expand "movsicc"
2159   [
2160    (set (match_operand:SI 0 "register_operand" "r")
2161         (if_then_else:SI (match_operand 1 "" "")
2162                          (match_operand:SI 2 "conditional_move_operand" "O")
2163                          (match_operand:SI 3 "conditional_move_operand" "O")
2164         )
2165    )
2166   ]
2167   ""
2168   "
2169 {
2170   if (! zero_and_one (operands [2], operands [3]))
2171     FAIL;
2172
2173   /* Generate the comparison that will set the carry flag.  */
2174   operands[1] = gen_compare (GET_CODE (operands[1]), XEXP (operands[1], 0),
2175                              XEXP (operands[1], 1), TRUE);
2176
2177   /* See other movsicc pattern below for reason why.  */
2178   emit_insn (gen_blockage ());
2179 }")
2180
2181 ;; Generate the conditional instructions based on how the carry flag is examined.
2182 (define_insn "*movsicc_internal"
2183   [(set (match_operand:SI 0 "register_operand" "=r")
2184         (if_then_else:SI (match_operand 1 "carry_compare_operand" "")
2185                          (match_operand:SI 2 "conditional_move_operand" "O")
2186                          (match_operand:SI 3 "conditional_move_operand" "O")
2187         )
2188    )]
2189   "zero_and_one (operands [2], operands[3])"
2190   "* return emit_cond_move (operands, insn);"
2191   [(set_attr "type" "multi")
2192    (set_attr "length" "8")
2193   ]
2194 )
2195
2196 \f
2197 ;; Block moves, see m32r.c for more details.
2198 ;; Argument 0 is the destination
2199 ;; Argument 1 is the source
2200 ;; Argument 2 is the length
2201 ;; Argument 3 is the alignment
2202
2203 (define_expand "movmemsi"
2204   [(parallel [(set (match_operand:BLK 0 "general_operand" "")
2205                    (match_operand:BLK 1 "general_operand" ""))
2206               (use (match_operand:SI  2 "immediate_operand" ""))
2207               (use (match_operand:SI  3 "immediate_operand" ""))])]
2208   ""
2209   "
2210 {
2211   if (operands[0])              /* Avoid unused code messages.  */
2212     {
2213      if (m32r_expand_block_move (operands))
2214        DONE;
2215      else
2216        FAIL;
2217     }
2218 }")
2219
2220 ;; Insn generated by block moves
2221
2222 (define_insn "movmemsi_internal"
2223   [(set (mem:BLK (match_operand:SI 0 "register_operand" "r"))   ;; destination
2224         (mem:BLK (match_operand:SI 1 "register_operand" "r")))  ;; source
2225    (use (match_operand:SI 2 "m32r_block_immediate_operand" "J"));; # bytes to move
2226    (set (match_operand:SI 3 "register_operand" "=0")
2227         (plus:SI (minus (match_dup 2) (const_int 4))
2228                  (match_dup 0)))
2229    (set (match_operand:SI 4 "register_operand" "=1")
2230         (plus:SI (match_dup 1)
2231                  (match_dup 2)))
2232    (clobber (match_scratch:SI 5 "=&r"))  ;; temp1
2233    (clobber (match_scratch:SI 6 "=&r"))] ;; temp2
2234   ""
2235   "* m32r_output_block_move (insn, operands); return \"\"; "
2236   [(set_attr "type"     "store8")
2237    (set_attr "length"   "72")]) ;; Maximum
2238
2239 ;; PIC
2240
2241 /* When generating pic, we need to load the symbol offset into a register.
2242    So that the optimizer does not confuse this with a normal symbol load
2243    we use an unspec.  The offset will be loaded from a constant pool entry,
2244    since that is the only type of relocation we can use.  */
2245
2246 (define_insn "pic_load_addr"
2247   [(set (match_operand:SI 0 "register_operand" "=r")
2248         (unspec:SI [(match_operand 1 "" "")] UNSPEC_PIC_LOAD_ADDR))]
2249   "flag_pic"
2250   "ld24 %0,%#%1"
2251   [(set_attr "type" "int4")])
2252
2253 (define_insn "gotoff_load_addr"
2254   [(set (match_operand:SI 0 "register_operand" "=r")
2255         (unspec:SI [(match_operand 1 "" "")] UNSPEC_GOTOFF))]
2256   "flag_pic"
2257   "seth %0, %#shigh(%1@GOTOFF)\;add3 %0, %0, low(%1@GOTOFF)"
2258   [(set_attr "type"     "int4")
2259    (set_attr "length"   "8")])
2260
2261 ;; Load program counter insns.
2262
2263 (define_insn "get_pc"
2264   [(clobber (reg:SI 14))
2265    (set (match_operand 0 "register_operand" "=r,r")
2266         (unspec [(match_operand 1 "" "")] UNSPEC_GET_PC))
2267    (use (match_operand:SI 2 "immediate_operand" "W,i"))]
2268   "flag_pic"
2269   "@
2270    bl.s .+4\;seth %0,%#shigh(%1)\;add3 %0,%0,%#low(%1+4)\;add %0,lr
2271    bl.s .+4\;ld24 %0,%#%1\;add %0,lr"
2272   [(set_attr "length" "12,8")])
2273
2274 (define_expand "builtin_setjmp_receiver"
2275   [(label_ref (match_operand 0 "" ""))]
2276   "flag_pic"
2277   "
2278 {
2279   m32r_load_pic_register ();
2280   DONE;
2281 }")