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