llvm/lib/Target/Xtensa/XtensaInstrInfo.td

   1 //===- XtensaInstrInfo.td - Target Description for Xtensa -*- tablegen -*--===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   6 // See https://llvm.org/LICENSE.txt for license information.
   7 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   8 //
   9 //===----------------------------------------------------------------------===//
  10 //
  11 // This file describes the Xtensa instructions in TableGen format.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 include "XtensaInstrFormats.td"
  16 include "XtensaOperands.td"
  17 include "XtensaOperators.td"
  18
  19 //===----------------------------------------------------------------------===//
  20 // Arithmetic & Logical instructions
  21 //===----------------------------------------------------------------------===//
  22
  23 class ArithLogic_RRR<bits<4> oper2, bits<4> oper1, string instrAsm,
  24       SDPatternOperator opNode, bit isComm = 0>
  25   : RRR_Inst<0x00, oper1, oper2, (outs AR:$r), (ins AR:$s, AR:$t),
  26              instrAsm#"\t$r, $s, $t",
  27             [(set AR:$r, (opNode AR:$s, AR:$t))]> {
  28   let isCommutable = isComm;
  29   let isReMaterializable = 0;
  30 }
  31
  32 def ADD : ArithLogic_RRR<0x08, 0x00, "add", add, 1>;
  33 def SUB : ArithLogic_RRR<0x0C, 0x00, "sub", sub>;
  34 def AND : ArithLogic_RRR<0x01, 0x00, "and", and, 1>;
  35 def OR  : ArithLogic_RRR<0x02, 0x00, "or", or, 1>;
  36 def XOR : ArithLogic_RRR<0x03, 0x00, "xor", xor, 1>;
  37
  38 class ADDX<bits<4> oper, string instrAsm, list<dag> pattern>
  39   : RRR_Inst<0x00, 0x00, oper, (outs AR:$r), (ins AR:$s, AR:$t),
  40              instrAsm#"\t$r, $s, $t", pattern>;
  41
  42 def ADDX2 : ADDX<0x09, "addx2", [(set AR:$r, (add AR:$t, (shl AR:$s, (i32 1))))]>;
  43 def ADDX4 : ADDX<0x0A, "addx4", [(set AR:$r, (add AR:$t, (shl AR:$s, (i32 2))))]>;
  44 def ADDX8 : ADDX<0x0B, "addx8", [(set AR:$r, (add AR:$t, (shl AR:$s, (i32 3))))]>;
  45
  46 class SUBX<bits<4> oper, string instrAsm, list<dag> pattern>
  47   : RRR_Inst<0x00, 0x00, oper, (outs AR:$r), (ins AR:$s, AR:$t),
  48              instrAsm#"\t$r, $s, $t", pattern>;
  49
  50 def SUBX2 : SUBX<0x0D, "subx2", [(set AR:$r, (sub (shl AR:$s, (i32 1)), AR:$t))]>;
  51 def SUBX4 : SUBX<0x0E, "subx4", [(set AR:$r, (sub (shl AR:$s, (i32 2)), AR:$t))]>;
  52 def SUBX8 : SUBX<0x0F, "subx8", [(set AR:$r, (sub (shl AR:$s, (i32 3)), AR:$t))]>;
  53
  54 def ABS : RRR_Inst<0x00, 0x00, 0x06, (outs AR:$r), (ins AR:$t),
  55                   "abs\t$r, $t", []> {
  56   let s = 0x1;
  57 }
  58
  59 def ADDI : RRI8_Inst<0x02, (outs AR:$t), (ins AR:$s, imm8:$imm8),
  60                     "addi\t$t, $s, $imm8",
  61                     [(set AR:$t, (add AR:$s, imm8:$imm8))]> {
  62   let r = 0x0C;
  63 }
  64
  65 def ADDMI : RRI8_Inst<0x02, (outs AR:$t), (ins AR:$s, imm8_sh8:$imm_sh8),
  66                      "addmi\t$t, $s, $imm_sh8",
  67                      [(set AR:$t, (add AR:$s, imm8_sh8:$imm_sh8))]> {
  68   bits<16> imm_sh8;
  69
  70   let r = 0x0D;
  71   let imm8 = imm_sh8{15-8};
  72 }
  73
  74 def NEG : RRR_Inst<0x00, 0x00, 0x06, (outs AR:$r), (ins AR:$t),
  75                   "neg\t$r, $t",
  76                   [(set AR:$r, (ineg AR:$t))]> {
  77   let s = 0x00;
  78 }
  79
  80 //===----------------------------------------------------------------------===//
  81 // Move instructions
  82 //===----------------------------------------------------------------------===//
  83 def MOVI : RRI8_Inst<0x02, (outs AR:$t), (ins imm12m:$imm),
  84                     "movi\t$t, $imm",
  85                     [(set AR:$t, imm12m:$imm)]> {
  86   bits<12> imm;
  87
  88   let imm8{7-0} = imm{7-0};
  89   let s{3-0} = imm{11-8};
  90   let r = 0xa;
  91 }
  92
  93 def MOVEQZ : RRR_Inst<0x00, 0x03, 0x08, (outs AR:$r), (ins AR:$s, AR:$t),
  94                      "moveqz\t$r, $s, $t", []>;
  95 def MOVNEZ : RRR_Inst<0x00, 0x03, 0x09, (outs AR:$r), (ins AR:$s, AR:$t),
  96                      "movnez\t$r, $s, $t", []>;
  97 def MOVLTZ : RRR_Inst<0x00, 0x03, 0x0A, (outs AR:$r), (ins AR:$s, AR:$t),
  98                      "movltz\t$r, $s, $t", []>;
  99 def MOVGEZ : RRR_Inst<0x00, 0x03, 0x0B, (outs AR:$r), (ins AR:$s, AR:$t),
 100                      "movgez\t$r, $s, $t", []>;
 101
 102 //===----------------------------------------------------------------------===//
 103 // Shift instructions
 104 //===----------------------------------------------------------------------===//
 105
 106 let Uses = [SAR] in {
 107   def SLL : RRR_Inst<0x00, 0x01, 0x0A, (outs AR:$r), (ins AR:$s),
 108                     "sll\t$r, $s", []> {
 109     let t = 0x00;
 110   }
 111
 112   def SRA : RRR_Inst<0x00, 0x01, 0x0B, (outs AR:$r), (ins AR:$t),
 113                     "sra\t$r, $t", []> {
 114     let s = 0x00;
 115   }
 116
 117   def SRC : RRR_Inst<0x00, 0x01, 0x08, (outs AR:$r), (ins AR:$s, AR:$t),
 118                     "src\t$r, $s, $t", []>;
 119
 120   def SRL : RRR_Inst<0x00, 0x01, 0x09, (outs AR:$r), (ins AR:$t),
 121                     "srl\t$r, $t", []> {
 122     let s = 0x00;
 123   }
 124 }
 125
 126 let Defs = [SAR] in {
 127   def SSL : RRR_Inst<0x00, 0x00, 0x04, (outs), (ins AR:$s),
 128                     "ssl\t$s", []> {
 129     let r = 0x01;
 130     let t = 0x00;
 131   }
 132
 133   def SSR : RRR_Inst<0x00, 0x00, 0x04, (outs), (ins AR:$s),
 134                     "ssr\t$s", []> {
 135     let r = 0x00;
 136     let t = 0x00;
 137   }
 138 }
 139
 140 def EXTUI : RRR_Inst<0x00, 0x04, 0x00, (outs AR:$r), (ins AR:$t, uimm5:$imm1, imm1_16:$imm2),
 141                     "extui\t$r, $t, $imm1, $imm2",
 142                     [(set AR:$r, (Xtensa_extui AR:$t, uimm5:$imm1, imm1_16:$imm2))]> {
 143   bits<5> imm1;
 144   bits<4> imm2;
 145
 146   let s = imm1{3-0};
 147   let Inst{16} = imm1{4};
 148   let Inst{23-20} = imm2;
 149 }
 150
 151 def SRAI : RRR_Inst<0x00, 0x01, 0x02, (outs AR:$r), (ins AR:$t, uimm5:$sa),
 152                    "srai\t$r, $t, $sa",
 153                    [(set AR:$r, (sra AR:$t, uimm5:$sa))]> {
 154   bits<5> sa;
 155
 156   let Inst{20} = sa{4};
 157   let s = sa{3-0};
 158 }
 159
 160 def SRLI : RRR_Inst<0x00, 0x01, 0x04, (outs AR:$r), (ins AR:$t, uimm4:$sa),
 161                    "srli\t$r, $t, $sa",
 162                    [(set AR:$r, (srl AR:$t, uimm4:$sa))]> {
 163   bits<4> sa;
 164
 165   let s = sa;
 166 }
 167
 168 def SLLI : RRR_Inst<0x00, 0x01, 0x00, (outs AR:$r), (ins AR:$s, shimm1_31:$sa),
 169                    "slli\t$r, $s, $sa",
 170                    [(set AR:$r, (shl AR:$s, shimm1_31:$sa))]> {
 171   bits<5> sa;
 172
 173   let Inst{20} = sa{4};
 174   let t = sa{3-0};
 175 }
 176
 177 def SSA8L : RRR_Inst<0x00, 0x00, 0x04, (outs), (ins AR:$s),
 178                     "ssa8l\t$s", []> {
 179   let r = 0x2;
 180   let t = 0x0;
 181 }
 182
 183 def SSAI : RRR_Inst<0x00, 0x00, 0x04, (outs), (ins uimm5:$imm),
 184                    "ssai\t$imm", []> {
 185   bits<5> imm;
 186
 187   let r = 0x04;
 188   let s = imm{3-0};
 189   let t{3-1} = 0;
 190   let t{0} = imm{4};
 191 }
 192
 193 //===----------------------------------------------------------------------===//
 194 // Load and store instructions
 195 //===----------------------------------------------------------------------===//
 196
 197 // Load instructions
 198 let mayLoad = 1, usesCustomInserter = 1 in {
 199
 200   class Load_RRI8<bits<4> oper, string instrAsm, SDPatternOperator opNode,
 201         ComplexPattern addrOp, Operand memOp>
 202           : RRI8_Inst<0x02, (outs AR:$t), (ins memOp:$addr),
 203                 instrAsm#"\t$t, $addr",
 204                [(set AR:$t, (opNode addrOp:$addr))]> {
 205     bits<12> addr;
 206
 207     let r = oper;
 208     let imm8{7-0} = addr{11-4};
 209     let s{3-0} = addr{3-0};
 210   }
 211 }
 212
 213 def L8UI  : Load_RRI8<0x00, "l8ui", zextloadi8, addr_ish1, mem8>;
 214 def L16SI : Load_RRI8<0x09, "l16si", sextloadi16, addr_ish2, mem16>;
 215 def L16UI : Load_RRI8<0x01, "l16ui", zextloadi16, addr_ish2, mem16>;
 216 def L32I  : Load_RRI8<0x02, "l32i", load, addr_ish4, mem32>;
 217
 218 // Store instructions
 219 let mayStore = 1, usesCustomInserter = 1 in {
 220   class Store_II8<bits<4> oper, string instrAsm, SDPatternOperator opNode,
 221         ComplexPattern addrOp, Operand memOp>
 222           : RRI8_Inst<0x02, (outs), (ins AR:$t, memOp:$addr),
 223                 instrAsm#"\t$t, $addr",
 224                [(opNode AR:$t, addrOp:$addr)]> {
 225     bits<12> addr;
 226
 227     let r = oper;
 228     let imm8{7-0} = addr{11-4};
 229     let s{3-0} = addr{3-0};
 230   }
 231 }
 232
 233 def S8I  : Store_II8<0x04, "s8i", truncstorei8, addr_ish1, mem8>;
 234 def S16I : Store_II8<0x05, "s16i", truncstorei16, addr_ish2, mem16>;
 235 def S32I : Store_II8<0x06, "s32i", store, addr_ish4, mem32>;
 236
 237 def L32R : RI16_Inst<0x01, (outs AR:$t), (ins L32Rtarget:$label),
 238                     "l32r\t$t, $label", []> {
 239   bits<16> label;
 240   let imm16 = label;
 241 }
 242
 243 // pcrel addr loading using L32R
 244 def : Pat<(Xtensa_pcrel_wrapper tconstpool : $in), (L32R tconstpool : $in)>;
 245
 246 // FrameIndexes are legalized when they are operands from load/store
 247 // instructions. The same not happens for stack address copies, so an
 248 // add op with mem ComplexPattern is used and the stack address copy
 249 // can be matched.
 250 // Setting of attribute mayLoad is trick to process instruction operands
 251 // in function XtensaRegisterInfo::eliminateFI
 252
 253 let isCodeGenOnly = 1, mayLoad = 1 in {
 254
 255   def LEA_ADD : RRI8_Inst<0x02, (outs AR:$t), (ins mem32:$addr),
 256        "addi\t$t, $addr",
 257        [(set AR:$t, addr_ish4:$addr)]> {
 258     bits<12> addr;
 259
 260     let r = 0x0C;
 261     let imm8{7-0} = addr{11-4};
 262     let s{3-0} = addr{3-0};
 263   }
 264 }
 265
 266 //extending loads
 267 def : Pat<(i32 (extloadi1  addr_ish1:$addr)), (L8UI addr_ish1:$addr)>;
 268 def : Pat<(i32 (extloadi8  addr_ish1:$addr)), (L8UI addr_ish1:$addr)>;
 269 def : Pat<(i32 (extloadi16 addr_ish2:$addr)), (L16UI addr_ish2:$addr)>;
 270
 271 //===----------------------------------------------------------------------===//
 272 // Conditional branch instructions
 273 //===----------------------------------------------------------------------===//
 274 let isBranch = 1, isTerminator = 1 in {
 275   class Branch_RR<bits<4> oper, string instrAsm, CondCode CC>
 276       : RRI8_Inst<0x07, (outs),
 277                  (ins AR:$s, AR:$t, brtarget:$target),
 278                   instrAsm#"\t$s, $t, $target",
 279                  [(brcc CC, AR:$s, AR:$t,  bb:$target)]> {
 280     bits<8> target;
 281
 282     let r = oper;
 283     let imm8 = target;
 284   }
 285
 286   class Branch_RI<bits<4> oper, string instrAsm, CondCode CC>
 287       : RRI8_Inst<0x06, (outs),
 288                  (ins AR:$s, b4const:$imm, brtarget:$target),
 289                   instrAsm#"\t$s, $imm, $target",
 290                  [(brcc CC, AR:$s, b4const:$imm,  bb:$target)]> {
 291     bits<4> imm;
 292     bits<8> target;
 293
 294     let t = oper;
 295     let r = imm;
 296     let imm8 = target;
 297   }
 298
 299   class Branch_RIU<bits<4> oper, string instrAsm, CondCode CC>
 300     : RRI8_Inst<0x06, (outs),
 301                (ins AR:$s, b4constu:$imm, brtarget:$target),
 302                 instrAsm#"\t$s, $imm, $target",
 303                [(brcc CC, AR:$s, b4constu:$imm,  bb:$target)]> {
 304     bits<4> imm;
 305     bits<8> target;
 306
 307     let t = oper;
 308     let r = imm;
 309     let imm8 = target;
 310   }
 311
 312   class Branch_RZ<bits<2> n, bits<2> m, string instrAsm, CondCode CC>
 313     : BRI12_Inst<0x06, n, m, (outs),
 314                 (ins AR:$s, brtarget:$target),
 315                  instrAsm#"\t$s, $target",
 316                 [(brcc CC, AR:$s, (i32 0),  bb:$target)]> {
 317     bits<12> target;
 318
 319     let imm12 = target;
 320   }
 321 }
 322
 323 def BEQ   : Branch_RR<0x01, "beq", SETEQ>;
 324 def BNE   : Branch_RR<0x09, "bne", SETNE>;
 325 def BGE   : Branch_RR<0x0A, "bge", SETGE>;
 326 def BLT   : Branch_RR<0x02, "blt", SETLT>;
 327 def BGEU  : Branch_RR<0x0B, "bgeu", SETUGE>;
 328 def BLTU  : Branch_RR<0x03, "bltu", SETULT>;
 329
 330 def BEQI  : Branch_RI<0x02, "beqi", SETEQ>;
 331 def BNEI  : Branch_RI<0x06, "bnei", SETNE>;
 332 def BGEI  : Branch_RI<0x0E, "bgei", SETGE>;
 333 def BLTI  : Branch_RI<0x0A, "blti", SETLT>;
 334 def BGEUI : Branch_RIU<0x0F, "bgeui", SETUGE>;
 335 def BLTUI : Branch_RIU<0x0B, "bltui", SETULT>;
 336
 337 def BEQZ  : Branch_RZ<0x01, 0x00, "beqz", SETEQ>;
 338 def BNEZ  : Branch_RZ<0x01, 0x01, "bnez", SETNE>;
 339 def BGEZ  : Branch_RZ<0x01, 0x03, "bgez", SETGE>;
 340 def BLTZ  : Branch_RZ<0x01, 0x02, "bltz", SETLT>;
 341
 342 def BALL : RRI8_Inst<0x07, (outs),
 343                     (ins AR:$s, AR:$t, brtarget:$target),
 344                     "ball\t$s, $t, $target", []> {
 345   bits<8> target;
 346
 347   let r = 0x04;
 348   let imm8 = target;
 349 }
 350
 351 def BANY : RRI8_Inst<0x07, (outs),
 352                     (ins AR:$s, AR:$t, brtarget:$target),
 353                     "bany\t$s, $t, $target", []> {
 354   bits<8> target;
 355
 356   let r = 0x08;
 357   let imm8 = target;
 358 }
 359
 360 def BBC : RRI8_Inst<0x07, (outs),
 361                    (ins AR:$s, AR:$t, brtarget:$target),
 362                    "bbc\t$s, $t, $target", []> {
 363   bits<8> target;
 364
 365   let r = 0x05;
 366   let imm8 = target;
 367 }
 368
 369 def BBS : RRI8_Inst<0x07, (outs),
 370                    (ins AR:$s, AR:$t, brtarget:$target),
 371                    "bbs\t$s, $t, $target", []> {
 372   bits<8> target;
 373
 374   let r = 0x0d;
 375   let imm8 = target;
 376 }
 377
 378 def BNALL : RRI8_Inst<0x07, (outs),
 379                     (ins AR:$s, AR:$t, brtarget:$target),
 380                     "bnall\t$s, $t, $target", []> {
 381   bits<8> target;
 382
 383   let r = 0x0c;
 384   let imm8 = target;
 385 }
 386
 387 def BNONE : RRI8_Inst<0x07, (outs),
 388                      (ins AR:$s, AR:$t, brtarget:$target),
 389                      "bnone\t$s, $t, $target", []> {
 390   bits<8> target;
 391
 392   let r = 0x00;
 393   let imm8 = target;
 394 }
 395
 396 def BBCI : RRI8_Inst<0x07, (outs),
 397                     (ins AR:$s, uimm5:$imm, brtarget:$target),
 398                     "bbci\t$s, $imm, $target", []> {
 399   bits<8> target;
 400   bits<5> imm;
 401
 402   let r{3-1} = 0x3;
 403   let r{0} = imm{4};
 404   let t{3-0} = imm{3-0};
 405   let imm8 = target;
 406 }
 407
 408 def BBSI : RRI8_Inst<0x07, (outs),
 409                     (ins AR:$s, uimm5:$imm, brtarget:$target),
 410                     "bbsi\t$s, $imm, $target", []> {
 411   bits<8> target;
 412   bits<5> imm;
 413
 414   let r{3-1} = 0x7;
 415   let r{0} = imm{4};
 416   let t{3-0} = imm{3-0};
 417   let imm8 = target;
 418 }
 419
 420 def : Pat<(brcond AR:$s, bb:$target), (BNEZ AR:$s, bb:$target)>;
 421
 422 //===----------------------------------------------------------------------===//
 423 // Call and jump instructions
 424 //===----------------------------------------------------------------------===//
 425
 426 let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
 427   def J : CALL_Inst<0x06, (outs), (ins jumptarget:$offset),
 428                    "j\t$offset",
 429                    [(br bb:$offset)]> {
 430     let n = 0x0;
 431   }
 432
 433   def JX : CALLX_Inst<0x00, 0x00, 0x00, (outs), (ins AR:$s),
 434                      "jx\t$s",
 435                      [(brind AR:$s)]> {
 436     let m = 0x2;
 437     let n = 0x2;
 438     let r = 0;
 439     let isIndirectBranch = 1;
 440   }
 441 }
 442
 443 let isCall = 1, Defs = [A0] in {
 444   def CALL0 : CALL_Inst<0x05, (outs), (ins pcrel32call:$offset),
 445                        "call0\t$offset", []> {
 446     let n = 0;
 447   }
 448
 449   def CALLX0 : CALLX_Inst<0x00, 0x00, 0x00, (outs), (ins AR:$s),
 450                          "callx0\t$s", []> {
 451     let m = 0x3;
 452     let n = 0x0;
 453     let r = 0;
 454   }
 455 }
 456
 457 let isReturn = 1, isTerminator = 1,
 458     isBarrier = 1, Uses = [A0] in {
 459
 460   def RET : CALLX_Inst<0x00, 0x00, 0x00, (outs), (ins),
 461                       "ret", [(Xtensa_ret)]> {
 462     let m = 0x2;
 463     let n = 0x0;
 464     let s = 0;
 465     let r = 0;
 466   }
 467 }
 468
 469 // Call patterns
 470 def : Pat<(Xtensa_call (i32 tglobaladdr:$dst)),
 471           (CALL0 tglobaladdr:$dst)>;
 472 def : Pat<(Xtensa_call (i32 texternalsym:$dst)),
 473           (CALL0 texternalsym:$dst)>;
 474 def : Pat<(Xtensa_call AR:$dst),
 475           (CALLX0 AR:$dst)>;
 476
 477 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1, Size = 3 in {
 478   def BR_JT: Pseudo<(outs), (ins AR:$s, i32imm:$jt),
 479                     "!br_jt_p, $s, $jt",
 480                     [(Xtensa_brjt AR:$s, tjumptable:$jt)]>;
 481 }
 482
 483 //===----------------------------------------------------------------------===//
 484 // Mem barrier instructions
 485 //===----------------------------------------------------------------------===//
 486
 487 def MEMW :  RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 488                     "memw", []> {
 489   let r = 0x2;
 490   let t = 0x0c;
 491   let s = 0x0;
 492 }
 493
 494 def EXTW : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 495                    "extw", []> {
 496   let r = 0x2;
 497   let s = 0x0;
 498   let t = 0xd;
 499   let hasSideEffects = 1;
 500 }
 501
 502 //===----------------------------------------------------------------------===//
 503 // Processor control instructions
 504 //===----------------------------------------------------------------------===//
 505
 506 def DSYNC : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 507                     "dsync", []> {
 508   let r = 0x2;
 509   let s = 0x0;
 510   let t = 0x3;
 511   let hasSideEffects = 1;
 512 }
 513
 514 def ISYNC : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 515                     "isync", []> {
 516   let r = 0x2;
 517   let s = 0x0;
 518   let t = 0x0;
 519   let hasSideEffects = 1;
 520 }
 521
 522 def RSYNC : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 523                     "rsync", []> {
 524   let r = 0x2;
 525   let s = 0x0;
 526   let t = 0x1;
 527   let hasSideEffects = 1;
 528 }
 529
 530 def ESYNC : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 531                     "esync", []> {
 532   let r = 0x2;
 533   let s = 0x0;
 534   let t = 0x2;
 535   let hasSideEffects = 1;
 536 }
 537
 538 def NOP : RRR_Inst<0x00, 0x00, 0x00, (outs), (ins),
 539                   "nop", []> {
 540   let r = 0x02;
 541   let s = 0x00;
 542   let t = 0x0f;
 543 }
 544
 545 def WSR : RSR_Inst<0x00, 0x03, 0x01, (outs SR:$sr), (ins AR:$t),
 546                   "wsr\t$t, $sr", []>;
 547
 548 def RSR : RSR_Inst<0x00, 0x03, 0x00, (outs AR:$t), (ins SR:$sr),
 549                   "rsr\t$t, $sr", []>;
 550
 551 def XSR : RSR_Inst<0x00, 0x01, 0x06, (outs AR:$ard, SR:$srd), (ins AR:$t, SR:$sr),
 552                   "xsr\t$t, $sr", []> {
 553   let Constraints = "$ard = $t, $srd = $sr";
 554 }
 555
 556 //===----------------------------------------------------------------------===//
 557 // Stack allocation
 558 //===----------------------------------------------------------------------===//
 559
 560 // ADJCALLSTACKDOWN/UP implicitly use/def SP because they may be expanded into
 561 // a stack adjustment and the codegen must know that they may modify the stack
 562 // pointer before prolog-epilog rewriting occurs.
 563 let Defs = [SP], Uses = [SP] in {
 564   def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i32imm:$amt1, i32imm:$amt2),
 565                                "#ADJCALLSTACKDOWN",
 566                                [(Xtensa_callseq_start timm:$amt1, timm:$amt2)]>;
 567   def ADJCALLSTACKUP   : Pseudo<(outs), (ins i32imm:$amt1, i32imm:$amt2),
 568                                "#ADJCALLSTACKUP",
 569                                [(Xtensa_callseq_end timm:$amt1, timm:$amt2)]>;
 570 }
 571
 572 //===----------------------------------------------------------------------===//
 573 // Generic select instruction
 574 //===----------------------------------------------------------------------===//
 575 let usesCustomInserter = 1 in {
 576   def SELECT : Pseudo<(outs AR:$dst), (ins AR:$lhs, AR:$rhs, AR:$t, AR:$f, i32imm:$cond),
 577                      "!select $dst, $lhs, $rhs, $t, $f, $cond",
 578                      [(set i32:$dst, (Xtensa_select_cc i32:$lhs, i32:$rhs, i32:$t, i32:$f, imm:$cond))]>;
 579 }
 580
 581 //===----------------------------------------------------------------------===//
 582 // Code Density instructions
 583 //===----------------------------------------------------------------------===//
 584
 585 class ArithLogic_RRRN<bits<4> oper0, string instrAsm,
 586       SDPatternOperator opNode, bit isComm = 0>
 587   : RRRN_Inst<oper0, (outs AR:$r), (ins AR:$s, AR:$t),
 588               instrAsm#"\t$r, $s, $t",
 589              [(set AR:$r, (opNode AR:$s, AR:$t))]>, Requires<[HasDensity]> {
 590   let isCommutable = isComm;
 591   let isReMaterializable = 0;
 592 }
 593
 594 def ADD_N : ArithLogic_RRRN<0x0a, "add.n", add, 1>;
 595
 596 def ADDI_N : RRRN_Inst<0x0B, (outs AR:$r), (ins AR:$s, imm1n_15:$imm),
 597                       "addi.n\t$r, $s, $imm",
 598                       [(set AR:$r, (add AR:$s, imm1n_15:$imm))]>, Requires<[HasDensity]> {
 599   bits<4> imm;
 600
 601   let t = imm;
 602 }
 603
 604 // Conditional branch instructions.
 605 let isBranch = 1, isTerminator = 1 in {
 606   def BEQZ_N : RI6_Inst<0xC, 0x1, 0x0, (outs), (ins AR:$s, brtarget:$target),
 607                        "beqz.n\t$s, $target", []>, Requires<[HasDensity]> {
 608     bits<6> target;
 609
 610     let imm6 = target;
 611   }
 612
 613   def BNEZ_N : RI6_Inst<0xC, 0x1, 0x1, (outs), (ins AR:$s, brtarget:$target),
 614                        "bnez.n\t$s, $target", []>, Requires<[HasDensity]> {
 615     bits<6> target;
 616
 617     let imm6 = target;
 618   }
 619 }
 620
 621 def ILL_N : RRRN_Inst<0x0D, (outs), (ins),
 622                      "ill.n", []>, Requires<[HasDensity]> {
 623   let r = 0xF;
 624   let s = 0x0;
 625   let t = 0x6;
 626 }
 627
 628 def MOV_N : RRRN_Inst<0x0D, (outs AR:$t), (ins AR:$s),
 629                      "mov.n\t$t, $s", []>, Requires<[HasDensity]> {
 630   let r = 0;
 631 }
 632
 633 def : InstAlias<"mov\t $t, $s", (OR AR:$t, AR:$s, AR:$s)>;
 634
 635 def MOVI_N : RI7_Inst<0xc, 0x0, (outs AR:$s), (ins imm32n_95:$imm7),
 636                      "movi.n\t$s, $imm7",
 637                      [(set AR:$s, imm32n_95:$imm7)]>, Requires<[HasDensity]>;
 638
 639 def : InstAlias<"_movi.n\t$s, $imm7", (MOVI_N AR:$s, imm32n_95:$imm7)>;
 640
 641 def NOP_N : RRRN_Inst<0x0D, (outs), (ins),
 642                      "nop.n", []>, Requires<[HasDensity]> {
 643   let r = 0xF;
 644   let s = 0x0;
 645   let t = 0x3;
 646 }
 647
 648 // Load instruction
 649 let mayLoad = 1, usesCustomInserter = 1 in {
 650   def L32I_N : RRRN_Inst<0x8, (outs AR:$t), (ins mem32n:$addr),
 651                         "l32i.n\t$t, $addr", []>, Requires<[HasDensity]> {
 652     bits<8> addr;
 653
 654     let r{3-0} = addr{7-4};
 655     let s{3-0} = addr{3-0};
 656   }
 657 }
 658
 659 // Store instruction
 660 let mayStore = 1, usesCustomInserter = 1 in {
 661   def S32I_N : RRRN_Inst<0x9, (outs), (ins  AR:$t, mem32n:$addr),
 662                         "s32i.n\t$t, $addr", []>, Requires<[HasDensity]> {
 663     bits<8> addr;
 664
 665     let r{3-0} = addr{7-4};
 666     let s{3-0} = addr{3-0};
 667   }
 668 }
 669
 670 //Return instruction
 671 let isReturn = 1, isTerminator = 1,
 672     isBarrier = 1, Uses = [A0] in {
 673   def RET_N : RRRN_Inst<0x0D, (outs), (ins),
 674                        "ret.n", [(Xtensa_ret)]>,
 675                        Requires<[HasDensity]> {
 676     let r = 0x0F;
 677     let s = 0;
 678     let t = 0;
 679   }
 680 }