1 //===-- BPFInstrInfo.td - Target Description for BPF Target ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file describes the BPF instructions in TableGen format.
12 //===----------------------------------------------------------------------===//
14 include "BPFInstrFormats.td"
16 // Instruction Operands and Patterns
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>,
26 def SDT_BPFBrCC : SDTypeProfile<0, 4, [SDTCisSameAs<0, 1>,
27 SDTCisVT<3, OtherVT>]>;
28 def SDT_BPFWrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
31 def BPFcall : SDNode<"BPFISD::CALL", SDT_BPFCall,
32 [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
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]>;
43 def BPFselectcc : SDNode<"BPFISD::SELECT_CC", SDT_BPFSelectCC, [SDNPInGlue]>;
44 def BPFWrapper : SDNode<"BPFISD::Wrapper", SDT_BPFWrapper>;
46 def brtarget : Operand<OtherVT>;
47 def calltarget : Operand<i64>;
49 def u64imm : Operand<i64> {
50 let PrintMethod = "printImm64Operand";
53 def i64immSExt32 : PatLeaf<(imm),
54 [{return isInt<32>(N->getSExtValue()); }]>;
57 def ADDRri : ComplexPattern<i64, 2, "SelectAddr", [frameindex], []>;
60 def MEMri : Operand<i64> {
61 let PrintMethod = "printMemOperand";
62 let EncoderMethod = "getMemoryOpValue";
63 let MIOperandInfo = (ops GPR, i16imm);
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);}]>;
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)]> {
92 let Inst{59} = BPFSrc;
93 let Inst{55-52} = src;
94 let Inst{51-48} = dst;
95 let Inst{47-32} = BrDst;
99 let BPFClass = 5; // BPF_JMP
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)]> {
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;
120 let BPFClass = 5; // BPF_JMP
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>;
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>;
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))]> {
148 let Inst{63-60} = op;
149 let Inst{59} = BPFSrc;
150 let Inst{51-48} = dst;
151 let Inst{31-0} = imm;
155 let BPFClass = 7; // BPF_ALU64
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))]> {
167 let Inst{63-60} = op;
168 let Inst{59} = BPFSrc;
169 let Inst{55-52} = src;
170 let Inst{51-48} = dst;
174 let BPFClass = 7; // BPF_ALU64
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>;
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>;
193 defm MUL : ALU<0x2, "mul", mul>;
194 defm DIV : ALU<0x3, "div", udiv>;
197 class MOV_RR<string OpcodeStr>
198 : InstBPF<(outs GPR:$dst), (ins GPR:$src),
199 !strconcat(OpcodeStr, "\t$dst, $src"),
206 let Inst{63-60} = op;
207 let Inst{59} = BPFSrc;
208 let Inst{55-52} = src;
209 let Inst{51-48} = dst;
211 let op = 0xb; // BPF_MOV
212 let BPFSrc = 1; // BPF_X
213 let BPFClass = 7; // BPF_ALU64
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))]> {
225 let Inst{63-60} = op;
226 let Inst{59} = BPFSrc;
227 let Inst{51-48} = dst;
228 let Inst{31-0} = imm;
230 let op = 0xb; // BPF_MOV
231 let BPFSrc = 0; // BPF_K
232 let BPFClass = 7; // BPF_ALU64
235 class LD_IMM64<bits<4> Pseudo, string OpcodeStr>
236 : InstBPF<(outs GPR:$dst), (ins u64imm:$imm),
237 !strconcat(OpcodeStr, "\t$dst, $imm"),
238 [(set GPR:$dst, (i64 imm:$imm))]> {
245 let Inst{63-61} = mode;
246 let Inst{60-59} = size;
247 let Inst{51-48} = dst;
248 let Inst{55-52} = Pseudo;
250 let Inst{31-0} = imm{31-0};
252 let mode = 0; // BPF_IMM
253 let size = 3; // BPF_DW
254 let BPFClass = 0; // BPF_LD
257 let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
258 def LD_imm64 : LD_IMM64<0, "ld_64">;
259 def MOV_rr : MOV_RR<"mov">;
260 def MOV_ri : MOV_RI<"mov">;
264 : InstBPF<(outs GPR:$dst), (ins i64imm:$pseudo, u64imm:$imm),
265 "ld_pseudo\t$dst, $pseudo, $imm",
266 [(set GPR:$dst, (int_bpf_pseudo imm:$pseudo, imm:$imm))]> {
274 let Inst{63-61} = mode;
275 let Inst{60-59} = size;
276 let Inst{51-48} = dst;
277 let Inst{55-52} = pseudo;
279 let Inst{31-0} = imm{31-0};
281 let mode = 0; // BPF_IMM
282 let size = 3; // BPF_DW
283 let BPFClass = 0; // BPF_LD
286 // STORE instructions
287 class STORE<bits<2> SizeOp, string OpcodeStr, list<dag> Pattern>
288 : InstBPF<(outs), (ins GPR:$src, MEMri:$addr),
289 !strconcat(OpcodeStr, "\t$addr, $src"), Pattern> {
295 let Inst{63-61} = mode;
296 let Inst{60-59} = size;
297 let Inst{51-48} = addr{19-16}; // base reg
298 let Inst{55-52} = src;
299 let Inst{47-32} = addr{15-0}; // offset
301 let mode = 3; // BPF_MEM
303 let BPFClass = 3; // BPF_STX
306 class STOREi64<bits<2> Opc, string OpcodeStr, PatFrag OpNode>
307 : STORE<Opc, OpcodeStr, [(OpNode i64:$src, ADDRri:$addr)]>;
309 def STW : STOREi64<0x0, "stw", truncstorei32>;
310 def STH : STOREi64<0x1, "sth", truncstorei16>;
311 def STB : STOREi64<0x2, "stb", truncstorei8>;
312 def STD : STOREi64<0x3, "std", store>;
315 class LOAD<bits<2> SizeOp, string OpcodeStr, list<dag> Pattern>
316 : InstBPF<(outs GPR:$dst), (ins MEMri:$addr),
317 !strconcat(OpcodeStr, "\t$dst, $addr"), Pattern> {
323 let Inst{63-61} = mode;
324 let Inst{60-59} = size;
325 let Inst{51-48} = dst;
326 let Inst{55-52} = addr{19-16};
327 let Inst{47-32} = addr{15-0};
329 let mode = 3; // BPF_MEM
331 let BPFClass = 1; // BPF_LDX
334 class LOADi64<bits<2> SizeOp, string OpcodeStr, PatFrag OpNode>
335 : LOAD<SizeOp, OpcodeStr, [(set i64:$dst, (OpNode ADDRri:$addr))]>;
337 def LDW : LOADi64<0x0, "ldw", zextloadi32>;
338 def LDH : LOADi64<0x1, "ldh", zextloadi16>;
339 def LDB : LOADi64<0x2, "ldb", zextloadi8>;
340 def LDD : LOADi64<0x3, "ldd", load>;
342 class BRANCH<bits<4> Opc, string OpcodeStr, list<dag> Pattern>
343 : InstBPF<(outs), (ins brtarget:$BrDst),
344 !strconcat(OpcodeStr, "\t$BrDst"), Pattern> {
349 let Inst{63-60} = op;
350 let Inst{59} = BPFSrc;
351 let Inst{47-32} = BrDst;
355 let BPFClass = 5; // BPF_JMP
358 class CALL<string OpcodeStr>
359 : InstBPF<(outs), (ins calltarget:$BrDst),
360 !strconcat(OpcodeStr, "\t$BrDst"), []> {
365 let Inst{63-60} = op;
366 let Inst{59} = BPFSrc;
367 let Inst{31-0} = BrDst;
369 let op = 8; // BPF_CALL
371 let BPFClass = 5; // BPF_JMP
375 let isBranch = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1 in {
376 def JMP : BRANCH<0x0, "jmp", [(br bb:$BrDst)]>;
380 let isCall=1, hasDelaySlot=0, Uses = [R11],
381 // Potentially clobbered registers
382 Defs = [R0, R1, R2, R3, R4, R5] in {
383 def JAL : CALL<"call">;
386 class NOP_I<string OpcodeStr>
387 : InstBPF<(outs), (ins i32imm:$imm),
388 !strconcat(OpcodeStr, "\t$imm"), []> {
395 let Inst{63-60} = op;
396 let Inst{59} = BPFSrc;
397 let Inst{55-52} = src;
398 let Inst{51-48} = dst;
400 let op = 0xb; // BPF_MOV
401 let BPFSrc = 1; // BPF_X
402 let BPFClass = 7; // BPF_ALU64
407 let hasSideEffects = 0 in
408 def NOP : NOP_I<"nop">;
410 class RET<string OpcodeStr>
411 : InstBPF<(outs), (ins),
412 !strconcat(OpcodeStr, ""), [(BPFretflag)]> {
415 let Inst{63-60} = op;
419 let op = 9; // BPF_EXIT
420 let BPFClass = 5; // BPF_JMP
423 let isReturn = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1,
424 isNotDuplicable = 1 in {
425 def RET : RET<"ret">;
428 // ADJCALLSTACKDOWN/UP pseudo insns
429 let Defs = [R11], Uses = [R11] in {
430 def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i64imm:$amt),
431 "#ADJCALLSTACKDOWN $amt",
432 [(BPFcallseq_start timm:$amt)]>;
433 def ADJCALLSTACKUP : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2),
434 "#ADJCALLSTACKUP $amt1 $amt2",
435 [(BPFcallseq_end timm:$amt1, timm:$amt2)]>;
438 let usesCustomInserter = 1 in {
439 def Select : Pseudo<(outs GPR:$dst),
440 (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR:$src, GPR:$src2),
441 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2",
443 (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i64:$src, i64:$src2))]>;
446 // load 64-bit global addr into register
447 def : Pat<(BPFWrapper tglobaladdr:$in), (LD_imm64 tglobaladdr:$in)>;
449 // 0xffffFFFF doesn't fit into simm32, optimize common case
450 def : Pat<(i64 (and (i64 GPR:$src), 0xffffFFFF)),
451 (SRL_ri (SLL_ri (i64 GPR:$src), 32), 32)>;
454 def : Pat<(BPFcall tglobaladdr:$dst), (JAL tglobaladdr:$dst)>;
455 def : Pat<(BPFcall imm:$dst), (JAL imm:$dst)>;
458 def : Pat<(extloadi8 ADDRri:$src), (i64 (LDB ADDRri:$src))>;
459 def : Pat<(extloadi16 ADDRri:$src), (i64 (LDH ADDRri:$src))>;
460 def : Pat<(extloadi32 ADDRri:$src), (i64 (LDW ADDRri:$src))>;
463 class XADD<bits<2> SizeOp, string OpcodeStr, PatFrag OpNode>
464 : InstBPF<(outs GPR:$dst), (ins MEMri:$addr, GPR:$val),
465 !strconcat(OpcodeStr, "\t$dst, $addr, $val"),
466 [(set GPR:$dst, (OpNode ADDRri:$addr, GPR:$val))]> {
472 let Inst{63-61} = mode;
473 let Inst{60-59} = size;
474 let Inst{51-48} = addr{19-16}; // base reg
475 let Inst{55-52} = src;
476 let Inst{47-32} = addr{15-0}; // offset
478 let mode = 6; // BPF_XADD
480 let BPFClass = 3; // BPF_STX
483 let Constraints = "$dst = $val" in {
484 def XADD32 : XADD<0, "xadd32", atomic_load_add_32>;
485 def XADD64 : XADD<3, "xadd64", atomic_load_add_64>;
486 // undefined def XADD16 : XADD<1, "xadd16", atomic_load_add_16>;
487 // undefined def XADD8 : XADD<2, "xadd8", atomic_load_add_8>;
490 // bswap16, bswap32, bswap64
491 class BSWAP<bits<32> SizeOp, string OpcodeStr, list<dag> Pattern>
492 : InstBPF<(outs GPR:$dst), (ins GPR:$src),
493 !strconcat(OpcodeStr, "\t$dst"),
500 let Inst{63-60} = op;
501 let Inst{59} = BPFSrc;
502 let Inst{51-48} = dst;
503 let Inst{31-0} = imm;
505 let op = 0xd; // BPF_END
506 let BPFSrc = 1; // BPF_TO_BE (TODO: use BPF_TO_LE for big-endian target)
507 let BPFClass = 4; // BPF_ALU
511 let Constraints = "$dst = $src" in {
512 def BSWAP16 : BSWAP<16, "bswap16", [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>;
513 def BSWAP32 : BSWAP<32, "bswap32", [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>;
514 def BSWAP64 : BSWAP<64, "bswap64", [(set GPR:$dst, (bswap GPR:$src))]>;
517 let Defs = [R0, R1, R2, R3, R4, R5], Uses = [R6], hasSideEffects = 1,
518 hasExtraDefRegAllocReq = 1, hasExtraSrcRegAllocReq = 1, mayLoad = 1 in {
519 class LOAD_ABS<bits<2> SizeOp, string OpcodeStr, Intrinsic OpNode>
520 : InstBPF<(outs), (ins GPR:$skb, i64imm:$imm),
521 !strconcat(OpcodeStr, "\tr0, $skb.data + $imm"),
522 [(set R0, (OpNode GPR:$skb, i64immSExt32:$imm))]> {
527 let Inst{63-61} = mode;
528 let Inst{60-59} = size;
529 let Inst{31-0} = imm;
531 let mode = 1; // BPF_ABS
533 let BPFClass = 0; // BPF_LD
536 class LOAD_IND<bits<2> SizeOp, string OpcodeStr, Intrinsic OpNode>
537 : InstBPF<(outs), (ins GPR:$skb, GPR:$val),
538 !strconcat(OpcodeStr, "\tr0, $skb.data + $val"),
539 [(set R0, (OpNode GPR:$skb, GPR:$val))]> {
544 let Inst{63-61} = mode;
545 let Inst{60-59} = size;
546 let Inst{55-52} = val;
548 let mode = 2; // BPF_IND
550 let BPFClass = 0; // BPF_LD
554 def LD_ABS_B : LOAD_ABS<2, "ldabs_b", int_bpf_load_byte>;
555 def LD_ABS_H : LOAD_ABS<1, "ldabs_h", int_bpf_load_half>;
556 def LD_ABS_W : LOAD_ABS<0, "ldabs_w", int_bpf_load_word>;
558 def LD_IND_B : LOAD_IND<2, "ldind_b", int_bpf_load_byte>;
559 def LD_IND_H : LOAD_IND<1, "ldind_h", int_bpf_load_half>;
560 def LD_IND_W : LOAD_IND<0, "ldind_w", int_bpf_load_word>;