contrib/llvm/lib/Target/BPF/BPFInstrInfo.td

   1 //===-- BPFInstrInfo.td - Target Description for BPF Target ---------------===//
   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 BPF instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 include "BPFInstrFormats.td"
  15
  16 // Instruction Operands and Patterns
  17
  18 // These are target-independent nodes, but have target-specific formats.
  19 def SDT_BPFCallSeqStart : SDCallSeqStart<[SDTCisVT<0, iPTR>,
  20                                           SDTCisVT<1, iPTR>]>;
  21 def SDT_BPFCallSeqEnd   : SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
  22 def SDT_BPFCall         : SDTypeProfile<0, -1, [SDTCisVT<0, iPTR>]>;
  23 def SDT_BPFSetFlag      : SDTypeProfile<0, 3, [SDTCisSameAs<0, 1>]>;
  24 def SDT_BPFSelectCC     : SDTypeProfile<1, 5, [SDTCisSameAs<1, 2>,
  25                                                SDTCisSameAs<0, 4>,
  26                                                SDTCisSameAs<4, 5>]>;
  27 def SDT_BPFBrCC         : SDTypeProfile<0, 4, [SDTCisSameAs<0, 1>,
  28                                                SDTCisVT<3, OtherVT>]>;
  29 def SDT_BPFWrapper      : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
  30                                                SDTCisPtrTy<0>]>;
  31
  32 def BPFcall         : SDNode<"BPFISD::CALL", SDT_BPFCall,
  33                              [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
  34                               SDNPVariadic]>;
  35 def BPFretflag      : SDNode<"BPFISD::RET_FLAG", SDTNone,
  36                              [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
  37 def BPFcallseq_start: SDNode<"ISD::CALLSEQ_START", SDT_BPFCallSeqStart,
  38                              [SDNPHasChain, SDNPOutGlue]>;
  39 def BPFcallseq_end  : SDNode<"ISD::CALLSEQ_END",   SDT_BPFCallSeqEnd,
  40                              [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
  41 def BPFbrcc         : SDNode<"BPFISD::BR_CC", SDT_BPFBrCC,
  42                              [SDNPHasChain, SDNPOutGlue, SDNPInGlue]>;
  43
  44 def BPFselectcc     : SDNode<"BPFISD::SELECT_CC", SDT_BPFSelectCC, [SDNPInGlue]>;
  45 def BPFWrapper      : SDNode<"BPFISD::Wrapper", SDT_BPFWrapper>;
  46
  47 def brtarget : Operand<OtherVT>;
  48 def calltarget : Operand<i64>;
  49
  50 def u64imm   : Operand<i64> {
  51   let PrintMethod = "printImm64Operand";
  52 }
  53
  54 def i64immSExt32 : PatLeaf<(i64 imm),
  55                 [{return isInt<32>(N->getSExtValue()); }]>;
  56
  57 // Addressing modes.
  58 def ADDRri : ComplexPattern<i64, 2, "SelectAddr", [], []>;
  59 def FIri : ComplexPattern<i64, 2, "SelectFIAddr", [add, or], []>;
  60
  61 // Address operands
  62 def MEMri : Operand<i64> {
  63   let PrintMethod = "printMemOperand";
  64   let EncoderMethod = "getMemoryOpValue";
  65   let DecoderMethod = "decodeMemoryOpValue";
  66   let MIOperandInfo = (ops GPR, i16imm);
  67 }
  68
  69 // Conditional code predicates - used for pattern matching for jump instructions
  70 def BPF_CC_EQ  : PatLeaf<(i64 imm),
  71                          [{return (N->getZExtValue() == ISD::SETEQ);}]>;
  72 def BPF_CC_NE  : PatLeaf<(i64 imm),
  73                          [{return (N->getZExtValue() == ISD::SETNE);}]>;
  74 def BPF_CC_GE  : PatLeaf<(i64 imm),
  75                          [{return (N->getZExtValue() == ISD::SETGE);}]>;
  76 def BPF_CC_GT  : PatLeaf<(i64 imm),
  77                          [{return (N->getZExtValue() == ISD::SETGT);}]>;
  78 def BPF_CC_GTU : PatLeaf<(i64 imm),
  79                          [{return (N->getZExtValue() == ISD::SETUGT);}]>;
  80 def BPF_CC_GEU : PatLeaf<(i64 imm),
  81                          [{return (N->getZExtValue() == ISD::SETUGE);}]>;
  82
  83 // jump instructions
  84 class JMP_RR<bits<4> Opc, string OpcodeStr, PatLeaf Cond>
  85     : InstBPF<(outs), (ins GPR:$dst, GPR:$src, brtarget:$BrDst),
  86               "if $dst "#OpcodeStr#" $src goto $BrDst",
  87               [(BPFbrcc i64:$dst, i64:$src, Cond, bb:$BrDst)]> {
  88   bits<4> op;
  89   bits<1> BPFSrc;
  90   bits<4> dst;
  91   bits<4> src;
  92   bits<16> BrDst;
  93
  94   let Inst{63-60} = op;
  95   let Inst{59} = BPFSrc;
  96   let Inst{55-52} = src;
  97   let Inst{51-48} = dst;
  98   let Inst{47-32} = BrDst;
  99
 100   let op = Opc;
 101   let BPFSrc = 1;
 102   let BPFClass = 5; // BPF_JMP
 103 }
 104
 105 class JMP_RI<bits<4> Opc, string OpcodeStr, PatLeaf Cond>
 106     : InstBPF<(outs), (ins GPR:$dst, i64imm:$imm, brtarget:$BrDst),
 107               "if $dst "#OpcodeStr#" $imm goto $BrDst",
 108               [(BPFbrcc i64:$dst, i64immSExt32:$imm, Cond, bb:$BrDst)]> {
 109   bits<4> op;
 110   bits<1> BPFSrc;
 111   bits<4> dst;
 112   bits<16> BrDst;
 113   bits<32> imm;
 114
 115   let Inst{63-60} = op;
 116   let Inst{59} = BPFSrc;
 117   let Inst{51-48} = dst;
 118   let Inst{47-32} = BrDst;
 119   let Inst{31-0} = imm;
 120
 121   let op = Opc;
 122   let BPFSrc = 0;
 123   let BPFClass = 5; // BPF_JMP
 124 }
 125
 126 multiclass J<bits<4> Opc, string OpcodeStr, PatLeaf Cond> {
 127   def _rr : JMP_RR<Opc, OpcodeStr, Cond>;
 128   def _ri : JMP_RI<Opc, OpcodeStr, Cond>;
 129 }
 130
 131 let isBranch = 1, isTerminator = 1, hasDelaySlot=0 in {
 132 // cmp+goto instructions
 133 defm JEQ  : J<0x1, "==",  BPF_CC_EQ>;
 134 defm JUGT : J<0x2, ">", BPF_CC_GTU>;
 135 defm JUGE : J<0x3, ">=", BPF_CC_GEU>;
 136 defm JNE  : J<0x5, "!=",  BPF_CC_NE>;
 137 defm JSGT : J<0x6, "s>", BPF_CC_GT>;
 138 defm JSGE : J<0x7, "s>=", BPF_CC_GE>;
 139 }
 140
 141 // ALU instructions
 142 class ALU_RI<bits<4> Opc, string OpcodeStr, SDNode OpNode>
 143     : InstBPF<(outs GPR:$dst), (ins GPR:$src2, i64imm:$imm),
 144               "$dst "#OpcodeStr#" $imm",
 145               [(set GPR:$dst, (OpNode GPR:$src2, i64immSExt32:$imm))]> {
 146   bits<4> op;
 147   bits<1> BPFSrc;
 148   bits<4> dst;
 149   bits<32> imm;
 150
 151   let Inst{63-60} = op;
 152   let Inst{59} = BPFSrc;
 153   let Inst{51-48} = dst;
 154   let Inst{31-0} = imm;
 155
 156   let op = Opc;
 157   let BPFSrc = 0;
 158   let BPFClass = 7; // BPF_ALU64
 159 }
 160
 161 class ALU_RR<bits<4> Opc, string OpcodeStr, SDNode OpNode>
 162     : InstBPF<(outs GPR:$dst), (ins GPR:$src2, GPR:$src),
 163               "$dst "#OpcodeStr#" $src",
 164               [(set GPR:$dst, (OpNode i64:$src2, i64:$src))]> {
 165   bits<4> op;
 166   bits<1> BPFSrc;
 167   bits<4> dst;
 168   bits<4> src;
 169
 170   let Inst{63-60} = op;
 171   let Inst{59} = BPFSrc;
 172   let Inst{55-52} = src;
 173   let Inst{51-48} = dst;
 174
 175   let op = Opc;
 176   let BPFSrc = 1;
 177   let BPFClass = 7; // BPF_ALU64
 178 }
 179
 180 multiclass ALU<bits<4> Opc, string OpcodeStr, SDNode OpNode> {
 181   def _rr : ALU_RR<Opc, OpcodeStr, OpNode>;
 182   def _ri : ALU_RI<Opc, OpcodeStr, OpNode>;
 183 }
 184
 185 let Constraints = "$dst = $src2" in {
 186 let isAsCheapAsAMove = 1 in {
 187   defm ADD : ALU<0x0, "+=", add>;
 188   defm SUB : ALU<0x1, "-=", sub>;
 189   defm OR  : ALU<0x4, "|=", or>;
 190   defm AND : ALU<0x5, "&=", and>;
 191   defm SLL : ALU<0x6, "<<=", shl>;
 192   defm SRL : ALU<0x7, ">>=", srl>;
 193   defm XOR : ALU<0xa, "^=", xor>;
 194   defm SRA : ALU<0xc, "s>>=", sra>;
 195 }
 196   defm MUL : ALU<0x2, "*=", mul>;
 197   defm DIV : ALU<0x3, "/=", udiv>;
 198 }
 199
 200 class MOV_RR<string OpcodeStr>
 201     : InstBPF<(outs GPR:$dst), (ins GPR:$src),
 202               "$dst "#OpcodeStr#" $src",
 203               []> {
 204   bits<4> op;
 205   bits<1> BPFSrc;
 206   bits<4> dst;
 207   bits<4> src;
 208
 209   let Inst{63-60} = op;
 210   let Inst{59} = BPFSrc;
 211   let Inst{55-52} = src;
 212   let Inst{51-48} = dst;
 213
 214   let op = 0xb;     // BPF_MOV
 215   let BPFSrc = 1;   // BPF_X
 216   let BPFClass = 7; // BPF_ALU64
 217 }
 218
 219 class MOV_RI<string OpcodeStr>
 220     : InstBPF<(outs GPR:$dst), (ins i64imm:$imm),
 221               "$dst "#OpcodeStr#" $imm",
 222               [(set GPR:$dst, (i64 i64immSExt32:$imm))]> {
 223   bits<4> op;
 224   bits<1> BPFSrc;
 225   bits<4> dst;
 226   bits<32> imm;
 227
 228   let Inst{63-60} = op;
 229   let Inst{59} = BPFSrc;
 230   let Inst{51-48} = dst;
 231   let Inst{31-0} = imm;
 232
 233   let op = 0xb;     // BPF_MOV
 234   let BPFSrc = 0;   // BPF_K
 235   let BPFClass = 7; // BPF_ALU64
 236 }
 237
 238 class LD_IMM64<bits<4> Pseudo, string OpcodeStr>
 239     : InstBPF<(outs GPR:$dst), (ins u64imm:$imm),
 240               "$dst "#OpcodeStr#" ${imm}ll",
 241               [(set GPR:$dst, (i64 imm:$imm))]> {
 242
 243   bits<3> mode;
 244   bits<2> size;
 245   bits<4> dst;
 246   bits<64> imm;
 247
 248   let Inst{63-61} = mode;
 249   let Inst{60-59} = size;
 250   let Inst{51-48} = dst;
 251   let Inst{55-52} = Pseudo;
 252   let Inst{47-32} = 0;
 253   let Inst{31-0} = imm{31-0};
 254
 255   let mode = 0;     // BPF_IMM
 256   let size = 3;     // BPF_DW
 257   let BPFClass = 0; // BPF_LD
 258 }
 259
 260 let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
 261 def LD_imm64 : LD_IMM64<0, "=">;
 262 def MOV_rr : MOV_RR<"=">;
 263 def MOV_ri : MOV_RI<"=">;
 264 }
 265
 266 def FI_ri
 267     : InstBPF<(outs GPR:$dst), (ins MEMri:$addr),
 268                "lea\t$dst, $addr",
 269                [(set i64:$dst, FIri:$addr)]> {
 270   // This is a tentative instruction, and will be replaced
 271   // with MOV_rr and ADD_ri in PEI phase
 272   let Inst{63-61} = 0;
 273   let Inst{60-59} = 3;
 274   let Inst{51-48} = 0;
 275   let Inst{55-52} = 2;
 276   let Inst{47-32} = 0;
 277   let Inst{31-0} = 0;
 278   let BPFClass = 0;
 279 }
 280
 281
 282 def LD_pseudo
 283     : InstBPF<(outs GPR:$dst), (ins i64imm:$pseudo, u64imm:$imm),
 284               "ld_pseudo\t$dst, $pseudo, $imm",
 285               [(set GPR:$dst, (int_bpf_pseudo imm:$pseudo, imm:$imm))]> {
 286
 287   bits<3> mode;
 288   bits<2> size;
 289   bits<4> dst;
 290   bits<64> imm;
 291   bits<4> pseudo;
 292
 293   let Inst{63-61} = mode;
 294   let Inst{60-59} = size;
 295   let Inst{51-48} = dst;
 296   let Inst{55-52} = pseudo;
 297   let Inst{47-32} = 0;
 298   let Inst{31-0} = imm{31-0};
 299
 300   let mode = 0;     // BPF_IMM
 301   let size = 3;     // BPF_DW
 302   let BPFClass = 0; // BPF_LD
 303 }
 304
 305 // STORE instructions
 306 class STORE<bits<2> SizeOp, string OpcodeStr, list<dag> Pattern>
 307     : InstBPF<(outs), (ins GPR:$src, MEMri:$addr),
 308               "*("#OpcodeStr#" *)($addr) = $src", Pattern> {
 309   bits<3> mode;
 310   bits<2> size;
 311   bits<4> src;
 312   bits<20> addr;
 313
 314   let Inst{63-61} = mode;
 315   let Inst{60-59} = size;
 316   let Inst{51-48} = addr{19-16}; // base reg
 317   let Inst{55-52} = src;
 318   let Inst{47-32} = addr{15-0}; // offset
 319
 320   let mode = 3;     // BPF_MEM
 321   let size = SizeOp;
 322   let BPFClass = 3; // BPF_STX
 323 }
 324
 325 class STOREi64<bits<2> Opc, string OpcodeStr, PatFrag OpNode>
 326     : STORE<Opc, OpcodeStr, [(OpNode i64:$src, ADDRri:$addr)]>;
 327
 328 def STW : STOREi64<0x0, "u32", truncstorei32>;
 329 def STH : STOREi64<0x1, "u16", truncstorei16>;
 330 def STB : STOREi64<0x2, "u8", truncstorei8>;
 331 def STD : STOREi64<0x3, "u64", store>;
 332
 333 // LOAD instructions
 334 class LOAD<bits<2> SizeOp, string OpcodeStr, list<dag> Pattern>
 335     : InstBPF<(outs GPR:$dst), (ins MEMri:$addr),
 336               "$dst = *("#OpcodeStr#" *)($addr)", Pattern> {
 337   bits<3> mode;
 338   bits<2> size;
 339   bits<4> dst;
 340   bits<20> addr;
 341
 342   let Inst{63-61} = mode;
 343   let Inst{60-59} = size;
 344   let Inst{51-48} = dst;
 345   let Inst{55-52} = addr{19-16};
 346   let Inst{47-32} = addr{15-0};
 347
 348   let mode = 3;     // BPF_MEM
 349   let size = SizeOp;
 350   let BPFClass = 1; // BPF_LDX
 351 }
 352
 353 class LOADi64<bits<2> SizeOp, string OpcodeStr, PatFrag OpNode>
 354     : LOAD<SizeOp, OpcodeStr, [(set i64:$dst, (OpNode ADDRri:$addr))]>;
 355
 356 def LDW : LOADi64<0x0, "u32", zextloadi32>;
 357 def LDH : LOADi64<0x1, "u16", zextloadi16>;
 358 def LDB : LOADi64<0x2, "u8", zextloadi8>;
 359 def LDD : LOADi64<0x3, "u64", load>;
 360
 361 class BRANCH<bits<4> Opc, string OpcodeStr, list<dag> Pattern>
 362     : InstBPF<(outs), (ins brtarget:$BrDst),
 363               !strconcat(OpcodeStr, " $BrDst"), Pattern> {
 364   bits<4> op;
 365   bits<16> BrDst;
 366   bits<1> BPFSrc;
 367
 368   let Inst{63-60} = op;
 369   let Inst{59} = BPFSrc;
 370   let Inst{47-32} = BrDst;
 371
 372   let op = Opc;
 373   let BPFSrc = 0;
 374   let BPFClass = 5; // BPF_JMP
 375 }
 376
 377 class CALL<string OpcodeStr>
 378     : InstBPF<(outs), (ins calltarget:$BrDst),
 379               !strconcat(OpcodeStr, " $BrDst"), []> {
 380   bits<4> op;
 381   bits<32> BrDst;
 382   bits<1> BPFSrc;
 383
 384   let Inst{63-60} = op;
 385   let Inst{59} = BPFSrc;
 386   let Inst{31-0} = BrDst;
 387
 388   let op = 8;       // BPF_CALL
 389   let BPFSrc = 0;
 390   let BPFClass = 5; // BPF_JMP
 391 }
 392
 393 // Jump always
 394 let isBranch = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1 in {
 395   def JMP : BRANCH<0x0, "goto", [(br bb:$BrDst)]>;
 396 }
 397
 398 // Jump and link
 399 let isCall=1, hasDelaySlot=0, Uses = [R11],
 400     // Potentially clobbered registers
 401     Defs = [R0, R1, R2, R3, R4, R5] in {
 402   def JAL  : CALL<"call">;
 403 }
 404
 405 class NOP_I<string OpcodeStr>
 406     : InstBPF<(outs), (ins i32imm:$imm),
 407               !strconcat(OpcodeStr, "\t$imm"), []> {
 408   // mov r0, r0 == nop
 409   bits<4> op;
 410   bits<1> BPFSrc;
 411   bits<4> dst;
 412   bits<4> src;
 413
 414   let Inst{63-60} = op;
 415   let Inst{59} = BPFSrc;
 416   let Inst{55-52} = src;
 417   let Inst{51-48} = dst;
 418
 419   let op = 0xb;     // BPF_MOV
 420   let BPFSrc = 1;   // BPF_X
 421   let BPFClass = 7; // BPF_ALU64
 422   let src = 0;      // R0
 423   let dst = 0;      // R0
 424 }
 425
 426 let hasSideEffects = 0 in
 427   def NOP : NOP_I<"nop">;
 428
 429 class RET<string OpcodeStr>
 430     : InstBPF<(outs), (ins),
 431               !strconcat(OpcodeStr, ""), [(BPFretflag)]> {
 432   bits<4> op;
 433
 434   let Inst{63-60} = op;
 435   let Inst{59} = 0;
 436   let Inst{31-0} = 0;
 437
 438   let op = 9;       // BPF_EXIT
 439   let BPFClass = 5; // BPF_JMP
 440 }
 441
 442 let isReturn = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1,
 443     isNotDuplicable = 1 in {
 444   def RET : RET<"exit">;
 445 }
 446
 447 // ADJCALLSTACKDOWN/UP pseudo insns
 448 let Defs = [R11], Uses = [R11] in {
 449 def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2),
 450                               "#ADJCALLSTACKDOWN $amt1 $amt2",
 451                               [(BPFcallseq_start timm:$amt1, timm:$amt2)]>;
 452 def ADJCALLSTACKUP   : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2),
 453                               "#ADJCALLSTACKUP $amt1 $amt2",
 454                               [(BPFcallseq_end timm:$amt1, timm:$amt2)]>;
 455 }
 456
 457 let usesCustomInserter = 1 in {
 458   def Select : Pseudo<(outs GPR:$dst),
 459                       (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR:$src, GPR:$src2),
 460                       "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2",
 461                       [(set i64:$dst,
 462                        (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i64:$src, i64:$src2))]>;
 463 }
 464
 465 // load 64-bit global addr into register
 466 def : Pat<(BPFWrapper tglobaladdr:$in), (LD_imm64 tglobaladdr:$in)>;
 467
 468 // 0xffffFFFF doesn't fit into simm32, optimize common case
 469 def : Pat<(i64 (and (i64 GPR:$src), 0xffffFFFF)),
 470           (SRL_ri (SLL_ri (i64 GPR:$src), 32), 32)>;
 471
 472 // Calls
 473 def : Pat<(BPFcall tglobaladdr:$dst), (JAL tglobaladdr:$dst)>;
 474 def : Pat<(BPFcall texternalsym:$dst), (JAL texternalsym:$dst)>;
 475 def : Pat<(BPFcall imm:$dst), (JAL imm:$dst)>;
 476
 477 // Loads
 478 def : Pat<(extloadi8  ADDRri:$src), (i64 (LDB ADDRri:$src))>;
 479 def : Pat<(extloadi16 ADDRri:$src), (i64 (LDH ADDRri:$src))>;
 480 def : Pat<(extloadi32 ADDRri:$src), (i64 (LDW ADDRri:$src))>;
 481
 482 // Atomics
 483 class XADD<bits<2> SizeOp, string OpcodeStr, PatFrag OpNode>
 484     : InstBPF<(outs GPR:$dst), (ins MEMri:$addr, GPR:$val),
 485               "lock *("#OpcodeStr#" *)($addr) += $val",
 486               [(set GPR:$dst, (OpNode ADDRri:$addr, GPR:$val))]> {
 487   bits<3> mode;
 488   bits<2> size;
 489   bits<4> dst;
 490   bits<20> addr;
 491
 492   let Inst{63-61} = mode;
 493   let Inst{60-59} = size;
 494   let Inst{51-48} = addr{19-16}; // base reg
 495   let Inst{55-52} = dst;
 496   let Inst{47-32} = addr{15-0}; // offset
 497
 498   let mode = 6;     // BPF_XADD
 499   let size = SizeOp;
 500   let BPFClass = 3; // BPF_STX
 501 }
 502
 503 let Constraints = "$dst = $val" in {
 504 def XADD32 : XADD<0, "u32", atomic_load_add_32>;
 505 def XADD64 : XADD<3, "u64", atomic_load_add_64>;
 506 // undefined def XADD16 : XADD<1, "xadd16", atomic_load_add_16>;
 507 // undefined def XADD8  : XADD<2, "xadd8", atomic_load_add_8>;
 508 }
 509
 510 // bswap16, bswap32, bswap64
 511 class BSWAP<bits<32> SizeOp, string OpcodeStr, list<dag> Pattern>
 512     : InstBPF<(outs GPR:$dst), (ins GPR:$src),
 513               !strconcat(OpcodeStr, "\t$dst"),
 514               Pattern> {
 515   bits<4> op;
 516   bits<1> BPFSrc;
 517   bits<4> dst;
 518   bits<32> imm;
 519
 520   let Inst{63-60} = op;
 521   let Inst{59} = BPFSrc;
 522   let Inst{51-48} = dst;
 523   let Inst{31-0} = imm;
 524
 525   let op = 0xd;     // BPF_END
 526   let BPFSrc = 1;   // BPF_TO_BE (TODO: use BPF_TO_LE for big-endian target)
 527   let BPFClass = 4; // BPF_ALU
 528   let imm = SizeOp;
 529 }
 530
 531 let Constraints = "$dst = $src" in {
 532 def BSWAP16 : BSWAP<16, "bswap16", [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>;
 533 def BSWAP32 : BSWAP<32, "bswap32", [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>;
 534 def BSWAP64 : BSWAP<64, "bswap64", [(set GPR:$dst, (bswap GPR:$src))]>;
 535 }
 536
 537 let Defs = [R0, R1, R2, R3, R4, R5], Uses = [R6], hasSideEffects = 1,
 538     hasExtraDefRegAllocReq = 1, hasExtraSrcRegAllocReq = 1, mayLoad = 1 in {
 539 class LOAD_ABS<bits<2> SizeOp, string OpcodeStr, Intrinsic OpNode>
 540     : InstBPF<(outs), (ins GPR:$skb, i64imm:$imm),
 541               "r0 = *("#OpcodeStr#" *)skb[$imm]",
 542               [(set R0, (OpNode GPR:$skb, i64immSExt32:$imm))]> {
 543   bits<3> mode;
 544   bits<2> size;
 545   bits<32> imm;
 546
 547   let Inst{63-61} = mode;
 548   let Inst{60-59} = size;
 549   let Inst{31-0} = imm;
 550
 551   let mode = 1;     // BPF_ABS
 552   let size = SizeOp;
 553   let BPFClass = 0; // BPF_LD
 554 }
 555
 556 class LOAD_IND<bits<2> SizeOp, string OpcodeStr, Intrinsic OpNode>
 557     : InstBPF<(outs), (ins GPR:$skb, GPR:$val),
 558               "r0 = *("#OpcodeStr#" *)skb[$val]",
 559               [(set R0, (OpNode GPR:$skb, GPR:$val))]> {
 560   bits<3> mode;
 561   bits<2> size;
 562   bits<4> val;
 563
 564   let Inst{63-61} = mode;
 565   let Inst{60-59} = size;
 566   let Inst{55-52} = val;
 567
 568   let mode = 2;     // BPF_IND
 569   let size = SizeOp;
 570   let BPFClass = 0; // BPF_LD
 571 }
 572 }
 573
 574 def LD_ABS_B : LOAD_ABS<2, "u8", int_bpf_load_byte>;
 575 def LD_ABS_H : LOAD_ABS<1, "u16", int_bpf_load_half>;
 576 def LD_ABS_W : LOAD_ABS<0, "u32", int_bpf_load_word>;
 577
 578 def LD_IND_B : LOAD_IND<2, "u8", int_bpf_load_byte>;
 579 def LD_IND_H : LOAD_IND<1, "u16", int_bpf_load_half>;
 580 def LD_IND_W : LOAD_IND<0, "u32", int_bpf_load_word>;