lib/Target/XCore/XCoreInstrInfo.td

   1 //===- XCoreInstrInfo.td - Target Description for XCore ----*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the XCore instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 // Uses of CP, DP are not currently reflected in the patterns, since
  15 // having a physical register as an operand prevents loop hoisting and
  16 // since the value of these registers never changes during the life of the
  17 // function.
  18
  19 //===----------------------------------------------------------------------===//
  20 // Instruction format superclass.
  21 //===----------------------------------------------------------------------===//
  22
  23 include "XCoreInstrFormats.td"
  24
  25 //===----------------------------------------------------------------------===//
  26 // Feature predicates.
  27 //===----------------------------------------------------------------------===//
  28
  29 // HasXS1B - This predicate is true when the target processor supports XS1B
  30 // instructions.
  31 def HasXS1B : Predicate<"Subtarget.isXS1B()">;
  32
  33 //===----------------------------------------------------------------------===//
  34 // XCore specific DAG Nodes.
  35 //
  36
  37 // Call
  38 def SDT_XCoreBranchLink : SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>;
  39 def XCoreBranchLink     : SDNode<"XCoreISD::BL",SDT_XCoreBranchLink,
  40                             [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  41
  42 def XCoreRetsp       : SDNode<"XCoreISD::RETSP", SDTNone,
  43                          [SDNPHasChain, SDNPOptInFlag]>;
  44
  45 def SDT_XCoreAddress    : SDTypeProfile<1, 1,
  46                             [SDTCisSameAs<0, 1>, SDTCisPtrTy<0>]>;
  47
  48 def pcrelwrapper : SDNode<"XCoreISD::PCRelativeWrapper", SDT_XCoreAddress,
  49                            []>;
  50
  51 def dprelwrapper : SDNode<"XCoreISD::DPRelativeWrapper", SDT_XCoreAddress,
  52                            []>;
  53
  54 def cprelwrapper : SDNode<"XCoreISD::CPRelativeWrapper", SDT_XCoreAddress,
  55                            []>;
  56
  57 def SDT_XCoreStwsp    : SDTypeProfile<0, 2, [SDTCisInt<1>]>;
  58 def XCoreStwsp        : SDNode<"XCoreISD::STWSP", SDT_XCoreStwsp,
  59                                [SDNPHasChain]>;
  60
  61 // These are target-independent nodes, but have target-specific formats.
  62 def SDT_XCoreCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
  63 def SDT_XCoreCallSeqEnd   : SDCallSeqEnd<[ SDTCisVT<0, i32>,
  64                                         SDTCisVT<1, i32> ]>;
  65
  66 def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_XCoreCallSeqStart,
  67                            [SDNPHasChain, SDNPOutFlag]>;
  68 def callseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_XCoreCallSeqEnd,
  69                            [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  70
  71 //===----------------------------------------------------------------------===//
  72 // Instruction Pattern Stuff
  73 //===----------------------------------------------------------------------===//
  74
  75 def div4_xform : SDNodeXForm<imm, [{
  76   // Transformation function: imm/4
  77   assert(N->getZExtValue() % 4 == 0);
  78   return getI32Imm(N->getZExtValue()/4);
  79 }]>;
  80
  81 def msksize_xform : SDNodeXForm<imm, [{
  82   // Transformation function: get the size of a mask
  83   assert(isMask_32(N->getZExtValue()));
  84   // look for the first non-zero bit
  85   return getI32Imm(32 - CountLeadingZeros_32(N->getZExtValue()));
  86 }]>;
  87
  88 def neg_xform : SDNodeXForm<imm, [{
  89   // Transformation function: -imm
  90   uint32_t value = N->getZExtValue();
  91   return getI32Imm(-value);
  92 }]>;
  93
  94 def bpwsub_xform : SDNodeXForm<imm, [{
  95   // Transformation function: 32-imm
  96   uint32_t value = N->getZExtValue();
  97   return getI32Imm(32-value);
  98 }]>;
  99
 100 def div4neg_xform : SDNodeXForm<imm, [{
 101   // Transformation function: -imm/4
 102   uint32_t value = N->getZExtValue();
 103   assert(-value % 4 == 0);
 104   return getI32Imm(-value/4);
 105 }]>;
 106
 107 def immUs4Neg : PatLeaf<(imm), [{
 108   uint32_t value = (uint32_t)N->getZExtValue();
 109   return (-value)%4 == 0 && (-value)/4 <= 11;
 110 }]>;
 111
 112 def immUs4 : PatLeaf<(imm), [{
 113   uint32_t value = (uint32_t)N->getZExtValue();
 114   return value%4 == 0 && value/4 <= 11;
 115 }]>;
 116
 117 def immUsNeg : PatLeaf<(imm), [{
 118   return -((uint32_t)N->getZExtValue()) <= 11;
 119 }]>;
 120
 121 def immUs : PatLeaf<(imm), [{
 122   return (uint32_t)N->getZExtValue() <= 11;
 123 }]>;
 124
 125 def immU6 : PatLeaf<(imm), [{
 126   return (uint32_t)N->getZExtValue() < (1 << 6);
 127 }]>;
 128
 129 def immU10 : PatLeaf<(imm), [{
 130   return (uint32_t)N->getZExtValue() < (1 << 10);
 131 }]>;
 132
 133 def immU16 : PatLeaf<(imm), [{
 134   return (uint32_t)N->getZExtValue() < (1 << 16);
 135 }]>;
 136
 137 def immU20 : PatLeaf<(imm), [{
 138   return (uint32_t)N->getZExtValue() < (1 << 20);
 139 }]>;
 140
 141 def immMskBitp : PatLeaf<(imm), [{
 142   uint32_t value = (uint32_t)N->getZExtValue();
 143   if (!isMask_32(value)) {
 144     return false;
 145   }
 146   int msksize = 32 - CountLeadingZeros_32(value);
 147   return (msksize >= 1 && msksize <= 8)
 148           || msksize == 16
 149           || msksize == 24
 150           || msksize == 32;
 151 }]>;
 152
 153 def immBitp : PatLeaf<(imm), [{
 154   uint32_t value = (uint32_t)N->getZExtValue();
 155   return (value >= 1 && value <= 8)
 156           || value == 16
 157           || value == 24
 158           || value == 32;
 159 }]>;
 160
 161 def immBpwSubBitp : PatLeaf<(imm), [{
 162   uint32_t value = (uint32_t)N->getZExtValue();
 163   return (value >= 24 && value <= 31)
 164           || value == 16
 165           || value == 8
 166           || value == 0;
 167 }]>;
 168
 169 def lda16f : PatFrag<(ops node:$addr, node:$offset),
 170                      (add node:$addr, (shl node:$offset, 1))>;
 171 def lda16b : PatFrag<(ops node:$addr, node:$offset),
 172                      (sub node:$addr, (shl node:$offset, 1))>;
 173 def ldawf : PatFrag<(ops node:$addr, node:$offset),
 174                      (add node:$addr, (shl node:$offset, 2))>;
 175 def ldawb : PatFrag<(ops node:$addr, node:$offset),
 176                      (sub node:$addr, (shl node:$offset, 2))>;
 177
 178 // Instruction operand types
 179 def calltarget  : Operand<i32>;
 180 def brtarget : Operand<OtherVT>;
 181 def pclabel : Operand<i32>;
 182
 183 // Addressing modes
 184 def ADDRspii : ComplexPattern<i32, 2, "SelectADDRspii", [add, frameindex], []>;
 185 def ADDRdpii : ComplexPattern<i32, 2, "SelectADDRdpii", [add, dprelwrapper],
 186                  []>;
 187 def ADDRcpii : ComplexPattern<i32, 2, "SelectADDRcpii", [add, cprelwrapper],
 188                  []>;
 189
 190 // Address operands
 191 def MEMii : Operand<i32> {
 192   let PrintMethod = "printMemOperand";
 193   let MIOperandInfo = (ops i32imm, i32imm);
 194 }
 195
 196 //===----------------------------------------------------------------------===//
 197 // Instruction Class Templates
 198 //===----------------------------------------------------------------------===//
 199
 200 // Three operand short
 201
 202 multiclass F3R_2RUS<string OpcStr, SDNode OpNode> {
 203   def _3r: _F3R<
 204                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 205                  !strconcat(OpcStr, " $dst, $b, $c"),
 206                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 207   def _2rus : _F2RUS<
 208                  (outs GRRegs:$dst), (ins GRRegs:$b, i32imm:$c),
 209                  !strconcat(OpcStr, " $dst, $b, $c"),
 210                  [(set GRRegs:$dst, (OpNode GRRegs:$b, immUs:$c))]>;
 211 }
 212
 213 multiclass F3R_2RUS_np<string OpcStr> {
 214   def _3r: _F3R<
 215                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 216                  !strconcat(OpcStr, " $dst, $b, $c"),
 217                  []>;
 218   def _2rus : _F2RUS<
 219                  (outs GRRegs:$dst), (ins GRRegs:$b, i32imm:$c),
 220                  !strconcat(OpcStr, " $dst, $b, $c"),
 221                  []>;
 222 }
 223
 224 multiclass F3R_2RBITP<string OpcStr, SDNode OpNode> {
 225   def _3r: _F3R<
 226                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 227                  !strconcat(OpcStr, " $dst, $b, $c"),
 228                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 229   def _2rus : _F2RUS<
 230                  (outs GRRegs:$dst), (ins GRRegs:$b, i32imm:$c),
 231                  !strconcat(OpcStr, " $dst, $b, $c"),
 232                  [(set GRRegs:$dst, (OpNode GRRegs:$b, immBitp:$c))]>;
 233 }
 234
 235 class F3R<string OpcStr, SDNode OpNode> : _F3R<
 236                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 237                  !strconcat(OpcStr, " $dst, $b, $c"),
 238                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 239
 240 class F3R_np<string OpcStr> : _F3R<
 241                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 242                  !strconcat(OpcStr, " $dst, $b, $c"),
 243                  []>;
 244 // Three operand long
 245
 246 /// FL3R_L2RUS multiclass - Define a normal FL3R/FL2RUS pattern in one shot.
 247 multiclass FL3R_L2RUS<string OpcStr, SDNode OpNode> {
 248   def _l3r: _FL3R<
 249                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 250                  !strconcat(OpcStr, " $dst, $b, $c"),
 251                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 252   def _l2rus : _FL2RUS<
 253                  (outs GRRegs:$dst), (ins GRRegs:$b, i32imm:$c),
 254                  !strconcat(OpcStr, " $dst, $b, $c"),
 255                  [(set GRRegs:$dst, (OpNode GRRegs:$b, immUs:$c))]>;
 256 }
 257
 258 /// FL3R_L2RUS multiclass - Define a normal FL3R/FL2RUS pattern in one shot.
 259 multiclass FL3R_L2RBITP<string OpcStr, SDNode OpNode> {
 260   def _l3r: _FL3R<
 261                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 262                  !strconcat(OpcStr, " $dst, $b, $c"),
 263                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 264   def _l2rus : _FL2RUS<
 265                  (outs GRRegs:$dst), (ins GRRegs:$b, i32imm:$c),
 266                  !strconcat(OpcStr, " $dst, $b, $c"),
 267                  [(set GRRegs:$dst, (OpNode GRRegs:$b, immBitp:$c))]>;
 268 }
 269
 270 class FL3R<string OpcStr, SDNode OpNode> : _FL3R<
 271                  (outs GRRegs:$dst), (ins GRRegs:$b, GRRegs:$c),
 272                  !strconcat(OpcStr, " $dst, $b, $c"),
 273                  [(set GRRegs:$dst, (OpNode GRRegs:$b, GRRegs:$c))]>;
 274
 275 // Register - U6
 276 // Operand register - U6
 277 multiclass FRU6_LRU6_branch<string OpcStr> {
 278   def _ru6: _FRU6<
 279                  (outs), (ins GRRegs:$cond, brtarget:$dest),
 280                  !strconcat(OpcStr, " $cond, $dest"),
 281                  []>;
 282   def _lru6: _FLRU6<
 283                  (outs), (ins GRRegs:$cond, brtarget:$dest),
 284                  !strconcat(OpcStr, " $cond, $dest"),
 285                  []>;
 286 }
 287
 288 multiclass FRU6_LRU6_cp<string OpcStr> {
 289   def _ru6: _FRU6<
 290                  (outs GRRegs:$dst), (ins i32imm:$a),
 291                  !strconcat(OpcStr, " $dst, cp[$a]"),
 292                  []>;
 293   def _lru6: _FLRU6<
 294                  (outs GRRegs:$dst), (ins i32imm:$a),
 295                  !strconcat(OpcStr, " $dst, cp[$a]"),
 296                  []>;
 297 }
 298
 299 // U6
 300 multiclass FU6_LU6<string OpcStr, SDNode OpNode> {
 301   def _u6: _FU6<
 302                  (outs), (ins i32imm:$b),
 303                  !strconcat(OpcStr, " $b"),
 304                  [(OpNode immU6:$b)]>;
 305   def _lu6: _FLU6<
 306                  (outs), (ins i32imm:$b),
 307                  !strconcat(OpcStr, " $b"),
 308                  [(OpNode immU16:$b)]>;
 309 }
 310
 311 multiclass FU6_LU6_np<string OpcStr> {
 312   def _u6: _FU6<
 313                  (outs), (ins i32imm:$b),
 314                  !strconcat(OpcStr, " $b"),
 315                  []>;
 316   def _lu6: _FLU6<
 317                  (outs), (ins i32imm:$b),
 318                  !strconcat(OpcStr, " $b"),
 319                  []>;
 320 }
 321
 322 // U10
 323 multiclass FU10_LU10_np<string OpcStr> {
 324   def _u10: _FU10<
 325                  (outs), (ins i32imm:$b),
 326                  !strconcat(OpcStr, " $b"),
 327                  []>;
 328   def _lu10: _FLU10<
 329                  (outs), (ins i32imm:$b),
 330                  !strconcat(OpcStr, " $b"),
 331                  []>;
 332 }
 333
 334 // Two operand short
 335
 336 class F2R_np<string OpcStr> : _F2R<
 337                  (outs GRRegs:$dst), (ins GRRegs:$b),
 338                  !strconcat(OpcStr, " $dst, $b"),
 339                  []>;
 340
 341 // Two operand long
 342
 343 //===----------------------------------------------------------------------===//
 344 // Pseudo Instructions
 345 //===----------------------------------------------------------------------===//
 346
 347 let Defs = [SP], Uses = [SP] in {
 348 def ADJCALLSTACKDOWN : PseudoInstXCore<(outs), (ins i32imm:$amt),
 349                                "${:comment} ADJCALLSTACKDOWN $amt",
 350                                [(callseq_start timm:$amt)]>;
 351 def ADJCALLSTACKUP : PseudoInstXCore<(outs), (ins i32imm:$amt1, i32imm:$amt2),
 352                             "${:comment} ADJCALLSTACKUP $amt1",
 353                             [(callseq_end timm:$amt1, timm:$amt2)]>;
 354 }
 355
 356 def LDWFI : PseudoInstXCore<(outs GRRegs:$dst), (ins MEMii:$addr),
 357                              "${:comment} LDWFI $dst, $addr",
 358                              [(set GRRegs:$dst, (load ADDRspii:$addr))]>;
 359
 360 def LDAWFI : PseudoInstXCore<(outs GRRegs:$dst), (ins MEMii:$addr),
 361                              "${:comment} LDAWFI $dst, $addr",
 362                              [(set GRRegs:$dst, ADDRspii:$addr)]>;
 363
 364 def STWFI : PseudoInstXCore<(outs), (ins GRRegs:$src, MEMii:$addr),
 365                             "${:comment} STWFI $src, $addr",
 366                             [(store GRRegs:$src, ADDRspii:$addr)]>;
 367
 368 // SELECT_CC_* - Used to implement the SELECT_CC DAG operation.  Expanded by the
 369 // scheduler into a branch sequence.
 370 let usesCustomDAGSchedInserter = 1 in {
 371   def SELECT_CC : PseudoInstXCore<(outs GRRegs:$dst),
 372                               (ins GRRegs:$cond, GRRegs:$T, GRRegs:$F),
 373                               "${:comment} SELECT_CC PSEUDO!",
 374                               [(set GRRegs:$dst,
 375                                  (select GRRegs:$cond, GRRegs:$T, GRRegs:$F))]>;
 376 }
 377
 378 //===----------------------------------------------------------------------===//
 379 // Instructions
 380 //===----------------------------------------------------------------------===//
 381
 382 // Three operand short
 383 defm ADD : F3R_2RUS<"add", add>;
 384 defm SUB : F3R_2RUS<"sub", sub>;
 385 let neverHasSideEffects = 1 in {
 386 defm EQ : F3R_2RUS_np<"eq">;
 387 def LSS_3r : F3R_np<"lss">;
 388 def LSU_3r : F3R_np<"lsu">;
 389 }
 390 def AND_3r : F3R<"and", and>;
 391 def OR_3r : F3R<"or", or>;
 392
 393 let mayLoad=1 in {
 394 def LDW_3r : _F3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 395                   "ldw $dst, $addr[$offset]",
 396                   []>;
 397
 398 def LDW_2rus : _F2RUS<(outs GRRegs:$dst), (ins GRRegs:$addr, i32imm:$offset),
 399                   "ldw $dst, $addr[$offset]",
 400                   []>;
 401
 402 def LD16S_3r :  _F3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 403                   "ld16s $dst, $addr[$offset]",
 404                   []>;
 405
 406 def LD8U_3r :  _F3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 407                   "ld8u $dst, $addr[$offset]",
 408                   []>;
 409 }
 410
 411 let mayStore=1 in {
 412 def STW_3r : _F3R<(outs), (ins GRRegs:$val, GRRegs:$addr, GRRegs:$offset),
 413                   "stw $val, $addr[$offset]",
 414                   []>;
 415
 416 def STW_2rus : _F2RUS<(outs), (ins GRRegs:$val, GRRegs:$addr, i32imm:$offset),
 417                   "stw $val, $addr[$offset]",
 418                   []>;
 419 }
 420
 421 defm SHL : F3R_2RBITP<"shl", shl>;
 422 defm SHR : F3R_2RBITP<"shr", srl>;
 423 // TODO tsetr
 424
 425 // Three operand long
 426 def LDAWF_l3r : _FL3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 427                   "ldaw $dst, $addr[$offset]",
 428                   [(set GRRegs:$dst, (ldawf GRRegs:$addr, GRRegs:$offset))]>;
 429
 430 let neverHasSideEffects = 1 in
 431 def LDAWF_l2rus : _FL2RUS<(outs GRRegs:$dst),
 432                     (ins GRRegs:$addr, i32imm:$offset),
 433                     "ldaw $dst, $addr[$offset]",
 434                     []>;
 435
 436 def LDAWB_l3r : _FL3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 437                   "ldaw $dst, $addr[-$offset]",
 438                   [(set GRRegs:$dst, (ldawb GRRegs:$addr, GRRegs:$offset))]>;
 439
 440 let neverHasSideEffects = 1 in
 441 def LDAWB_l2rus : _FL2RUS<(outs GRRegs:$dst),
 442                     (ins GRRegs:$addr, i32imm:$offset),
 443                     "ldaw $dst, $addr[-$offset]",
 444                     []>;
 445
 446 def LDA16F_l3r : _FL3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 447                   "lda16 $dst, $addr[$offset]",
 448                   [(set GRRegs:$dst, (lda16f GRRegs:$addr, GRRegs:$offset))]>;
 449
 450 def LDA16B_l3r : _FL3R<(outs GRRegs:$dst), (ins GRRegs:$addr, GRRegs:$offset),
 451                   "lda16 $dst, $addr[-$offset]",
 452                   [(set GRRegs:$dst, (lda16b GRRegs:$addr, GRRegs:$offset))]>;
 453
 454 def MUL_l3r : FL3R<"mul", mul>;
 455 // Instructions which may trap are marked as side effecting.
 456 let hasSideEffects = 1 in {
 457 def DIVS_l3r : FL3R<"divs", sdiv>;
 458 def DIVU_l3r : FL3R<"divu", udiv>;
 459 def REMS_l3r : FL3R<"rems", srem>;
 460 def REMU_l3r : FL3R<"remu", urem>;
 461 }
 462 def XOR_l3r : FL3R<"xor", xor>;
 463 defm ASHR : FL3R_L2RBITP<"ashr", sra>;
 464 // TODO crc32, crc8, inpw, outpw
 465 let mayStore=1 in {
 466 def ST16_l3r : _FL3R<(outs), (ins GRRegs:$val, GRRegs:$addr, GRRegs:$offset),
 467                 "st16 $val, $addr[$offset]",
 468                 []>;
 469
 470 def ST8_l3r : _FL3R<(outs), (ins GRRegs:$val, GRRegs:$addr, GRRegs:$offset),
 471                 "st8 $val, $addr[$offset]",
 472                 []>;
 473 }
 474
 475 // Four operand long
 476 let Predicates = [HasXS1B], Constraints = "$src1 = $dst1,$src2 = $dst2" in {
 477 def MACCU_l4r : _L4R<(outs GRRegs:$dst1, GRRegs:$dst2),
 478                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3,
 479                       GRRegs:$src4),
 480                     "maccu $dst1, $dst2, $src3, $src4",
 481                     []>;
 482
 483 def MACCS_l4r : _L4R<(outs GRRegs:$dst1, GRRegs:$dst2),
 484                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3,
 485                       GRRegs:$src4),
 486                     "maccs $dst1, $dst2, $src3, $src4",
 487                     []>;
 488 }
 489
 490 // Five operand long
 491
 492 let Predicates = [HasXS1B] in {
 493 def LADD_l5r : _L5R<(outs GRRegs:$dst1, GRRegs:$dst2),
 494                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3),
 495                     "ladd $dst1, $dst2, $src1, $src2, $src3",
 496                     []>;
 497
 498 def LSUB_l5r : _L5R<(outs GRRegs:$dst1, GRRegs:$dst2),
 499                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3),
 500                     "lsub $dst1, $dst2, $src1, $src2, $src3",
 501                     []>;
 502
 503 def LDIV_l5r : _L5R<(outs GRRegs:$dst1, GRRegs:$dst2),
 504                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3),
 505                     "ldiv $dst1, $dst2, $src1, $src2, $src3",
 506                     []>;
 507 }
 508
 509 // Six operand long
 510
 511 def LMUL_l6r : _L6R<(outs GRRegs:$dst1, GRRegs:$dst2),
 512                     (ins GRRegs:$src1, GRRegs:$src2, GRRegs:$src3,
 513                       GRRegs:$src4),
 514                     "lmul $dst1, $dst2, $src1, $src2, $src3, $src4",
 515                     []>;
 516
 517 // Register - U6
 518
 519 //let Uses = [DP] in ...
 520 let neverHasSideEffects = 1, isReMaterializable = 1 in
 521 def LDAWDP_ru6: _FRU6<(outs GRRegs:$dst), (ins MEMii:$a),
 522                     "ldaw $dst, dp[$a]",
 523                     []>;
 524
 525 let isReMaterializable = 1 in
 526 def LDAWDP_lru6: _FLRU6<
 527                     (outs GRRegs:$dst), (ins MEMii:$a),
 528                     "ldaw $dst, dp[$a]",
 529                     [(set GRRegs:$dst, ADDRdpii:$a)]>;
 530
 531 let mayLoad=1 in
 532 def LDWDP_ru6: _FRU6<(outs GRRegs:$dst), (ins MEMii:$a),
 533                     "ldw $dst, dp[$a]",
 534                     []>;
 535
 536 def LDWDP_lru6: _FLRU6<
 537                     (outs GRRegs:$dst), (ins MEMii:$a),
 538                     "ldw $dst, dp[$a]",
 539                     [(set GRRegs:$dst, (load ADDRdpii:$a))]>;
 540
 541 let mayStore=1 in
 542 def STWDP_ru6 : _FRU6<(outs), (ins GRRegs:$val, MEMii:$addr),
 543                   "stw $val, dp[$addr]",
 544                   []>;
 545
 546 def STWDP_lru6 : _FLRU6<(outs), (ins GRRegs:$val, MEMii:$addr),
 547                   "stw $val, dp[$addr]",
 548                   [(store GRRegs:$val, ADDRdpii:$addr)]>;
 549
 550 //let Uses = [CP] in ..
 551 let mayLoad = 1, isReMaterializable = 1 in
 552 defm LDWCP : FRU6_LRU6_cp<"ldw">;
 553
 554 let Uses = [SP] in {
 555 let mayStore=1 in {
 556 def STWSP_ru6 : _FRU6<
 557                  (outs), (ins GRRegs:$val, i32imm:$index),
 558                  "stw $val, sp[$index]",
 559                  [(XCoreStwsp GRRegs:$val, immU6:$index)]>;
 560
 561 def STWSP_lru6 : _FLRU6<
 562                  (outs), (ins GRRegs:$val, i32imm:$index),
 563                  "stw $val, sp[$index]",
 564                  [(XCoreStwsp GRRegs:$val, immU16:$index)]>;
 565 }
 566
 567 let mayLoad=1 in {
 568 def LDWSP_ru6 : _FRU6<
 569                  (outs GRRegs:$dst), (ins i32imm:$b),
 570                  "ldw $dst, sp[$b]",
 571                  []>;
 572
 573 def LDWSP_lru6 : _FLRU6<
 574                  (outs GRRegs:$dst), (ins i32imm:$b),
 575                  "ldw $dst, sp[$b]",
 576                  []>;
 577 }
 578
 579 let neverHasSideEffects = 1 in {
 580 def LDAWSP_ru6 : _FRU6<
 581                  (outs GRRegs:$dst), (ins i32imm:$b),
 582                  "ldaw $dst, sp[$b]",
 583                  []>;
 584
 585 def LDAWSP_lru6 : _FLRU6<
 586                  (outs GRRegs:$dst), (ins i32imm:$b),
 587                  "ldaw $dst, sp[$b]",
 588                  []>;
 589
 590 def LDAWSP_ru6_RRegs : _FRU6<
 591                  (outs RRegs:$dst), (ins i32imm:$b),
 592                  "ldaw $dst, sp[$b]",
 593                  []>;
 594
 595 def LDAWSP_lru6_RRegs : _FLRU6<
 596                  (outs RRegs:$dst), (ins i32imm:$b),
 597                  "ldaw $dst, sp[$b]",
 598                  []>;
 599 }
 600 }
 601
 602 let isReMaterializable = 1 in {
 603 def LDC_ru6 : _FRU6<
 604                  (outs GRRegs:$dst), (ins i32imm:$b),
 605                  "ldc $dst, $b",
 606                  [(set GRRegs:$dst, immU6:$b)]>;
 607
 608 def LDC_lru6 : _FLRU6<
 609                  (outs GRRegs:$dst), (ins i32imm:$b),
 610                  "ldc $dst, $b",
 611                  [(set GRRegs:$dst, immU16:$b)]>;
 612 }
 613
 614 // Operand register - U6
 615 // TODO setc
 616 let isBranch = 1, isTerminator = 1 in {
 617 defm BRFT: FRU6_LRU6_branch<"bt">;
 618 defm BRBT: FRU6_LRU6_branch<"bt">;
 619 defm BRFF: FRU6_LRU6_branch<"bf">;
 620 defm BRBF: FRU6_LRU6_branch<"bf">;
 621 }
 622
 623 // U6
 624 let Defs = [SP], Uses = [SP] in {
 625 let neverHasSideEffects = 1 in
 626 defm EXTSP : FU6_LU6_np<"extsp">;
 627 let mayStore = 1 in
 628 defm ENTSP : FU6_LU6_np<"entsp">;
 629
 630 let isReturn = 1, isTerminator = 1, mayLoad = 1 in {
 631 defm RETSP : FU6_LU6<"retsp", XCoreRetsp>;
 632 }
 633 }
 634
 635 // TODO extdp, kentsp, krestsp, blat, setsr
 636 // clrsr, getsr, kalli
 637 let isBranch = 1, isTerminator = 1 in {
 638 def BRBU_u6 : _FU6<
 639                  (outs),
 640                  (ins brtarget:$target),
 641                  "bu $target",
 642                  []>;
 643
 644 def BRBU_lu6 : _FLU6<
 645                  (outs),
 646                  (ins brtarget:$target),
 647                  "bu $target",
 648                  []>;
 649
 650 def BRFU_u6 : _FU6<
 651                  (outs),
 652                  (ins brtarget:$target),
 653                  "bu $target",
 654                  []>;
 655
 656 def BRFU_lu6 : _FLU6<
 657                  (outs),
 658                  (ins brtarget:$target),
 659                  "bu $target",
 660                  []>;
 661 }
 662
 663 //let Uses = [CP] in ...
 664 let Predicates = [HasXS1B], Defs = [R11], neverHasSideEffects = 1,
 665   isReMaterializable = 1 in
 666 def LDAWCP_u6: _FRU6<(outs), (ins MEMii:$a),
 667                     "ldaw r11, cp[$a]",
 668                     []>;
 669
 670 let Predicates = [HasXS1B], Defs = [R11], isReMaterializable = 1 in
 671 def LDAWCP_lu6: _FLRU6<
 672                     (outs), (ins MEMii:$a),
 673                     "ldaw r11, cp[$a]",
 674                     [(set R11, ADDRcpii:$a)]>;
 675
 676 // U10
 677 // TODO ldwcpl, blacp
 678
 679 let Defs = [R11], isReMaterializable = 1, neverHasSideEffects = 1 in
 680 def LDAP_u10 : _FU10<
 681                   (outs),
 682                   (ins i32imm:$addr),
 683                   "ldap r11, $addr",
 684                   []>;
 685
 686 let Defs = [R11], isReMaterializable = 1 in
 687 def LDAP_lu10 : _FLU10<
 688                   (outs),
 689                   (ins i32imm:$addr),
 690                   "ldap r11, $addr",
 691                   [(set R11, (pcrelwrapper tglobaladdr:$addr))]>;
 692
 693 let isCall=1,
 694 // All calls clobber the the link register and the non-callee-saved registers:
 695 Defs = [R0, R1, R2, R3, R11, LR] in {
 696 def BL_u10 : _FU10<
 697                   (outs),
 698                   (ins calltarget:$target, variable_ops),
 699                   "bl $target",
 700                   [(XCoreBranchLink immU10:$target)]>;
 701
 702 def BL_lu10 : _FLU10<
 703                   (outs),
 704                   (ins calltarget:$target, variable_ops),
 705                   "bl $target",
 706                   [(XCoreBranchLink immU20:$target)]>;
 707 }
 708
 709 // Two operand short
 710 // TODO getr, getst
 711 def NOT : _F2R<(outs GRRegs:$dst), (ins GRRegs:$b),
 712                  "not $dst, $b",
 713                  [(set GRRegs:$dst, (not GRRegs:$b))]>;
 714
 715 def NEG : _F2R<(outs GRRegs:$dst), (ins GRRegs:$b),
 716                  "neg $dst, $b",
 717                  [(set GRRegs:$dst, (ineg GRRegs:$b))]>;
 718
 719 // TODO setd, eet, eef, getts, setpt, outct, inct, chkct, outt, intt, out,
 720 // in, outshr, inshr, testct, testwct, tinitpc, tinitdp, tinitsp, tinitcp,
 721 // tsetmr, sext (reg), zext (reg)
 722 let isTwoAddress = 1 in {
 723 let neverHasSideEffects = 1 in
 724 def SEXT_rus : _FRUS<(outs GRRegs:$dst), (ins GRRegs:$src1, i32imm:$src2),
 725                  "sext $dst, $src2",
 726                  []>;
 727
 728 let neverHasSideEffects = 1 in
 729 def ZEXT_rus : _FRUS<(outs GRRegs:$dst), (ins GRRegs:$src1, i32imm:$src2),
 730                  "zext $dst, $src2",
 731                  []>;
 732
 733 def ANDNOT_2r : _F2R<(outs GRRegs:$dst), (ins GRRegs:$src1, GRRegs:$src2),
 734                  "andnot $dst, $src2",
 735                  [(set GRRegs:$dst, (and GRRegs:$src1, (not GRRegs:$src2)))]>;
 736 }
 737
 738 let isReMaterializable = 1, neverHasSideEffects = 1 in
 739 def MKMSK_rus : _FRUS<(outs GRRegs:$dst), (ins i32imm:$size),
 740                  "mkmsk $dst, $size",
 741                  []>;
 742
 743 def MKMSK_2r : _FRUS<(outs GRRegs:$dst), (ins GRRegs:$size),
 744                  "mkmsk $dst, $size",
 745                  [(set GRRegs:$dst, (add (shl 1, GRRegs:$size), 0xffffffff))]>;
 746
 747 // Two operand long
 748 // TODO settw, setclk, setrdy, setpsc, endin, peek,
 749 // getd, testlcl, tinitlr, getps, setps
 750 def BITREV_l2r : _FL2R<(outs GRRegs:$dst), (ins GRRegs:$src),
 751                  "bitrev $dst, $src",
 752                  [(set GRRegs:$dst, (int_xcore_bitrev GRRegs:$src))]>;
 753
 754 def BYTEREV_l2r : _FL2R<(outs GRRegs:$dst), (ins GRRegs:$src),
 755                  "byterev $dst, $src",
 756                  [(set GRRegs:$dst, (bswap GRRegs:$src))]>;
 757
 758 def CLZ_l2r : _FL2R<(outs GRRegs:$dst), (ins GRRegs:$src),
 759                  "clz $dst, $src",
 760                  [(set GRRegs:$dst, (ctlz GRRegs:$src))]>;
 761
 762 // One operand short
 763 // TODO edu, eeu, waitet, waitef, freer, tstart, msync, mjoin, syncr, clrtp
 764 // bru, setdp, setcp, setv, setev, kcall
 765 // dgetreg
 766 let isBranch=1, isIndirectBranch=1, isTerminator=1 in
 767 def BAU_1r : _F1R<(outs), (ins GRRegs:$addr),
 768                  "bau $addr",
 769                  [(brind GRRegs:$addr)]>;
 770
 771 let Defs=[SP], neverHasSideEffects=1 in
 772 def SETSP_1r : _F1R<(outs), (ins GRRegs:$src),
 773                  "set sp, $src",
 774                  []>;
 775
 776 let isBarrier = 1, hasCtrlDep = 1 in
 777 def ECALLT_1r : _F1R<(outs), (ins GRRegs:$src),
 778                  "ecallt $src",
 779                  []>;
 780
 781 let isBarrier = 1, hasCtrlDep = 1 in
 782 def ECALLF_1r : _F1R<(outs), (ins GRRegs:$src),
 783                  "ecallf $src",
 784                  []>;
 785
 786 let isCall=1,
 787 // All calls clobber the the link register and the non-callee-saved registers:
 788 Defs = [R0, R1, R2, R3, R11, LR] in {
 789 def BLA_1r : _F1R<(outs), (ins GRRegs:$addr, variable_ops),
 790                  "bla $addr",
 791                  [(XCoreBranchLink GRRegs:$addr)]>;
 792 }
 793
 794 // Zero operand short
 795 // TODO waiteu, clre, ssync, freet, ldspc, stspc, ldssr, stssr, ldsed, stsed,
 796 // stet, geted, getet, getkep, getksp, setkep, getid, kret, dcall, dret,
 797 // dentsp, drestsp
 798
 799 let Defs = [R11] in
 800 def GETID_0R : _F0R<(outs), (ins),
 801                  "get r11, id",
 802                  [(set R11, (int_xcore_getid))]>;
 803
 804 //===----------------------------------------------------------------------===//
 805 // Non-Instruction Patterns
 806 //===----------------------------------------------------------------------===//
 807
 808 def : Pat<(XCoreBranchLink tglobaladdr:$addr), (BL_lu10 tglobaladdr:$addr)>;
 809 def : Pat<(XCoreBranchLink texternalsym:$addr), (BL_lu10 texternalsym:$addr)>;
 810
 811 /// sext_inreg
 812 def : Pat<(sext_inreg GRRegs:$b, i1), (SEXT_rus GRRegs:$b, 1)>;
 813 def : Pat<(sext_inreg GRRegs:$b, i8), (SEXT_rus GRRegs:$b, 8)>;
 814 def : Pat<(sext_inreg GRRegs:$b, i16), (SEXT_rus GRRegs:$b, 16)>;
 815
 816 /// loads
 817 def : Pat<(zextloadi8 (add GRRegs:$addr, GRRegs:$offset)),
 818           (LD8U_3r GRRegs:$addr, GRRegs:$offset)>;
 819 def : Pat<(zextloadi8 GRRegs:$addr), (LD8U_3r GRRegs:$addr, (LDC_ru6 0))>;
 820
 821 def : Pat<(sextloadi16 (lda16f GRRegs:$addr, GRRegs:$offset)),
 822           (LD16S_3r GRRegs:$addr, GRRegs:$offset)>;
 823 def : Pat<(sextloadi16 GRRegs:$addr), (LD16S_3r GRRegs:$addr, (LDC_ru6 0))>;
 824
 825 def : Pat<(load (ldawf GRRegs:$addr, GRRegs:$offset)),
 826           (LDW_3r GRRegs:$addr, GRRegs:$offset)>;
 827 def : Pat<(load (add GRRegs:$addr, immUs4:$offset)),
 828           (LDW_2rus GRRegs:$addr, (div4_xform immUs4:$offset))>;
 829 def : Pat<(load GRRegs:$addr), (LDW_2rus GRRegs:$addr, 0)>;
 830
 831 /// anyext
 832 def : Pat<(extloadi8 (add GRRegs:$addr, GRRegs:$offset)),
 833           (LD8U_3r GRRegs:$addr, GRRegs:$offset)>;
 834 def : Pat<(extloadi8 GRRegs:$addr), (LD8U_3r GRRegs:$addr, (LDC_ru6 0))>;
 835 def : Pat<(extloadi16 (lda16f GRRegs:$addr, GRRegs:$offset)),
 836           (LD16S_3r GRRegs:$addr, GRRegs:$offset)>;
 837 def : Pat<(extloadi16 GRRegs:$addr), (LD16S_3r GRRegs:$addr, (LDC_ru6 0))>;
 838
 839 /// stores
 840 def : Pat<(truncstorei8 GRRegs:$val, (add GRRegs:$addr, GRRegs:$offset)),
 841           (ST8_l3r GRRegs:$val, GRRegs:$addr, GRRegs:$offset)>;
 842 def : Pat<(truncstorei8 GRRegs:$val, GRRegs:$addr),
 843           (ST8_l3r GRRegs:$val, GRRegs:$addr, (LDC_ru6 0))>;
 844
 845 def : Pat<(truncstorei16 GRRegs:$val, (lda16f GRRegs:$addr, GRRegs:$offset)),
 846           (ST16_l3r GRRegs:$val, GRRegs:$addr, GRRegs:$offset)>;
 847 def : Pat<(truncstorei16 GRRegs:$val, GRRegs:$addr),
 848           (ST16_l3r GRRegs:$val, GRRegs:$addr, (LDC_ru6 0))>;
 849
 850 def : Pat<(store GRRegs:$val, (ldawf GRRegs:$addr, GRRegs:$offset)),
 851           (STW_3r GRRegs:$val, GRRegs:$addr, GRRegs:$offset)>;
 852 def : Pat<(store GRRegs:$val, (add GRRegs:$addr, immUs4:$offset)),
 853           (STW_2rus GRRegs:$val, GRRegs:$addr, (div4_xform immUs4:$offset))>;
 854 def : Pat<(store GRRegs:$val, GRRegs:$addr),
 855           (STW_2rus GRRegs:$val, GRRegs:$addr, 0)>;
 856
 857 /// cttz
 858 def : Pat<(cttz GRRegs:$src), (CLZ_l2r (BITREV_l2r GRRegs:$src))>;
 859
 860 /// trap
 861 def : Pat<(trap), (ECALLF_1r (LDC_ru6 0))>;
 862
 863 ///
 864 /// branch patterns
 865 ///
 866
 867 // unconditional branch
 868 def : Pat<(br bb:$addr), (BRFU_lu6 bb:$addr)>;
 869
 870 // direct match equal/notequal zero brcond
 871 def : Pat<(brcond (setne GRRegs:$lhs, 0), bb:$dst),
 872           (BRFT_lru6 GRRegs:$lhs, bb:$dst)>;
 873 def : Pat<(brcond (seteq GRRegs:$lhs, 0), bb:$dst),
 874           (BRFF_lru6 GRRegs:$lhs, bb:$dst)>;
 875
 876 def : Pat<(brcond (setle GRRegs:$lhs, GRRegs:$rhs), bb:$dst),
 877           (BRFF_lru6 (LSS_3r GRRegs:$rhs, GRRegs:$lhs), bb:$dst)>;
 878 def : Pat<(brcond (setule GRRegs:$lhs, GRRegs:$rhs), bb:$dst),
 879           (BRFF_lru6 (LSU_3r GRRegs:$rhs, GRRegs:$lhs), bb:$dst)>;
 880 def : Pat<(brcond (setge GRRegs:$lhs, GRRegs:$rhs), bb:$dst),
 881           (BRFF_lru6 (LSS_3r GRRegs:$lhs, GRRegs:$rhs), bb:$dst)>;
 882 def : Pat<(brcond (setuge GRRegs:$lhs, GRRegs:$rhs), bb:$dst),
 883           (BRFF_lru6 (LSU_3r GRRegs:$lhs, GRRegs:$rhs), bb:$dst)>;
 884 def : Pat<(brcond (setne GRRegs:$lhs, GRRegs:$rhs), bb:$dst),
 885           (BRFF_lru6 (EQ_3r GRRegs:$lhs, GRRegs:$rhs), bb:$dst)>;
 886 def : Pat<(brcond (setne GRRegs:$lhs, immUs:$rhs), bb:$dst),
 887           (BRFF_lru6 (EQ_2rus GRRegs:$lhs, immUs:$rhs), bb:$dst)>;
 888
 889 // generic brcond pattern
 890 def : Pat<(brcond GRRegs:$cond, bb:$addr), (BRFT_lru6 GRRegs:$cond, bb:$addr)>;
 891
 892
 893 ///
 894 /// Select patterns
 895 ///
 896
 897 // direct match equal/notequal zero select
 898 def : Pat<(select (setne GRRegs:$lhs, 0), GRRegs:$T, GRRegs:$F),
 899         (SELECT_CC GRRegs:$lhs, GRRegs:$T, GRRegs:$F)>;
 900
 901 def : Pat<(select (seteq GRRegs:$lhs, 0), GRRegs:$T, GRRegs:$F),
 902         (SELECT_CC GRRegs:$lhs, GRRegs:$F, GRRegs:$T)>;
 903
 904 def : Pat<(select (setle GRRegs:$lhs, GRRegs:$rhs), GRRegs:$T, GRRegs:$F),
 905           (SELECT_CC (LSS_3r GRRegs:$rhs, GRRegs:$lhs), GRRegs:$F, GRRegs:$T)>;
 906 def : Pat<(select (setule GRRegs:$lhs, GRRegs:$rhs), GRRegs:$T, GRRegs:$F),
 907           (SELECT_CC (LSU_3r GRRegs:$rhs, GRRegs:$lhs), GRRegs:$F, GRRegs:$T)>;
 908 def : Pat<(select (setge GRRegs:$lhs, GRRegs:$rhs), GRRegs:$T, GRRegs:$F),
 909           (SELECT_CC (LSS_3r GRRegs:$lhs, GRRegs:$rhs), GRRegs:$F, GRRegs:$T)>;
 910 def : Pat<(select (setuge GRRegs:$lhs, GRRegs:$rhs), GRRegs:$T, GRRegs:$F),
 911           (SELECT_CC (LSU_3r GRRegs:$lhs, GRRegs:$rhs), GRRegs:$F, GRRegs:$T)>;
 912 def : Pat<(select (setne GRRegs:$lhs, GRRegs:$rhs), GRRegs:$T, GRRegs:$F),
 913           (SELECT_CC (EQ_3r GRRegs:$lhs, GRRegs:$rhs), GRRegs:$F, GRRegs:$T)>;
 914 def : Pat<(select (setne GRRegs:$lhs, immUs:$rhs), GRRegs:$T, GRRegs:$F),
 915           (SELECT_CC (EQ_2rus GRRegs:$lhs, immUs:$rhs), GRRegs:$F, GRRegs:$T)>;
 916
 917 ///
 918 /// setcc patterns, only matched when none of the above brcond
 919 /// patterns match
 920 ///
 921
 922 // setcc 2 register operands
 923 def : Pat<(setle GRRegs:$lhs, GRRegs:$rhs),
 924           (EQ_2rus (LSS_3r GRRegs:$rhs, GRRegs:$lhs), 0)>;
 925 def : Pat<(setule GRRegs:$lhs, GRRegs:$rhs),
 926           (EQ_2rus (LSU_3r GRRegs:$rhs, GRRegs:$lhs), 0)>;
 927
 928 def : Pat<(setgt GRRegs:$lhs, GRRegs:$rhs),
 929           (LSS_3r GRRegs:$rhs, GRRegs:$lhs)>;
 930 def : Pat<(setugt GRRegs:$lhs, GRRegs:$rhs),
 931           (LSU_3r GRRegs:$rhs, GRRegs:$lhs)>;
 932
 933 def : Pat<(setge GRRegs:$lhs, GRRegs:$rhs),
 934           (EQ_2rus (LSS_3r GRRegs:$lhs, GRRegs:$rhs), 0)>;
 935 def : Pat<(setuge GRRegs:$lhs, GRRegs:$rhs),
 936           (EQ_2rus (LSU_3r GRRegs:$lhs, GRRegs:$rhs), 0)>;
 937
 938 def : Pat<(setlt GRRegs:$lhs, GRRegs:$rhs),
 939           (LSS_3r GRRegs:$lhs, GRRegs:$rhs)>;
 940 def : Pat<(setult GRRegs:$lhs, GRRegs:$rhs),
 941           (LSU_3r GRRegs:$lhs, GRRegs:$rhs)>;
 942
 943 def : Pat<(setne GRRegs:$lhs, GRRegs:$rhs),
 944           (EQ_2rus (EQ_3r GRRegs:$lhs, GRRegs:$rhs), 0)>;
 945
 946 def : Pat<(seteq GRRegs:$lhs, GRRegs:$rhs),
 947           (EQ_3r GRRegs:$lhs, GRRegs:$rhs)>;
 948
 949 // setcc reg/imm operands
 950 def : Pat<(seteq GRRegs:$lhs, immUs:$rhs),
 951           (EQ_2rus GRRegs:$lhs, immUs:$rhs)>;
 952 def : Pat<(setne GRRegs:$lhs, immUs:$rhs),
 953           (EQ_2rus (EQ_2rus GRRegs:$lhs, immUs:$rhs), 0)>;
 954
 955 // misc
 956 def : Pat<(add GRRegs:$addr, immUs4:$offset),
 957           (LDAWF_l2rus GRRegs:$addr, (div4_xform immUs4:$offset))>;
 958
 959 def : Pat<(sub GRRegs:$addr, immUs4:$offset),
 960           (LDAWB_l2rus GRRegs:$addr, (div4_xform immUs4:$offset))>;
 961
 962 def : Pat<(and GRRegs:$val, immMskBitp:$mask),
 963           (ZEXT_rus GRRegs:$val, (msksize_xform immMskBitp:$mask))>;
 964
 965 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
 966 def : Pat<(add GRRegs:$src1, immUsNeg:$src2),
 967           (SUB_2rus GRRegs:$src1, (neg_xform immUsNeg:$src2))>;
 968
 969 def : Pat<(add GRRegs:$src1, immUs4Neg:$src2),
 970           (LDAWB_l2rus GRRegs:$src1, (div4neg_xform immUs4Neg:$src2))>;
 971
 972 ///
 973 /// Some peepholes
 974 ///
 975
 976 def : Pat<(mul GRRegs:$src, 3),
 977           (LDA16F_l3r GRRegs:$src, GRRegs:$src)>;
 978
 979 def : Pat<(mul GRRegs:$src, 5),
 980           (LDAWF_l3r GRRegs:$src, GRRegs:$src)>;
 981
 982 def : Pat<(mul GRRegs:$src, -3),
 983           (LDAWB_l3r GRRegs:$src, GRRegs:$src)>;
 984
 985 // ashr X, 32 is equivalent to ashr X, 31 on the XCore.
 986 def : Pat<(sra GRRegs:$src, 31),
 987           (ASHR_l2rus GRRegs:$src, 32)>;
 988
 989 def : Pat<(sra (shl GRRegs:$src, immBpwSubBitp:$imm), immBpwSubBitp:$imm),
 990           (SEXT_rus GRRegs:$src, (bpwsub_xform immBpwSubBitp:$imm))>;