1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//===-- BPFInstrFormats.td - BPF Instruction Formats -------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class BPFOpClass<bits<3> val> {
bits<3> Value = val;
}
def BPF_LD : BPFOpClass<0x0>;
def BPF_LDX : BPFOpClass<0x1>;
def BPF_ST : BPFOpClass<0x2>;
def BPF_STX : BPFOpClass<0x3>;
def BPF_ALU : BPFOpClass<0x4>;
def BPF_JMP : BPFOpClass<0x5>;
def BPF_JMP32 : BPFOpClass<0x6>;
def BPF_ALU64 : BPFOpClass<0x7>;
class BPFSrcType<bits<1> val> {
bits<1> Value = val;
}
def BPF_K : BPFSrcType<0x0>;
def BPF_X : BPFSrcType<0x1>;
class BPFArithOp<bits<4> val> {
bits<4> Value = val;
}
def BPF_ADD : BPFArithOp<0x0>;
def BPF_SUB : BPFArithOp<0x1>;
def BPF_MUL : BPFArithOp<0x2>;
def BPF_DIV : BPFArithOp<0x3>;
def BPF_OR : BPFArithOp<0x4>;
def BPF_AND : BPFArithOp<0x5>;
def BPF_LSH : BPFArithOp<0x6>;
def BPF_RSH : BPFArithOp<0x7>;
def BPF_NEG : BPFArithOp<0x8>;
def BPF_MOD : BPFArithOp<0x9>;
def BPF_XOR : BPFArithOp<0xa>;
def BPF_MOV : BPFArithOp<0xb>;
def BPF_ARSH : BPFArithOp<0xc>;
def BPF_END : BPFArithOp<0xd>;
def BPF_XCHG : BPFArithOp<0xe>;
def BPF_CMPXCHG : BPFArithOp<0xf>;
class BPFAtomicOp<bits<5> val> {
bits<5> Value = val;
}
def BPF_LOAD_ACQ : BPFAtomicOp<0x10>;
def BPF_STORE_REL : BPFAtomicOp<0x11>;
class BPFEndDir<bits<1> val> {
bits<1> Value = val;
}
def BPF_TO_LE : BPFSrcType<0x0>;
def BPF_TO_BE : BPFSrcType<0x1>;
class BPFJumpOp<bits<4> val> {
bits<4> Value = val;
}
def BPF_JA : BPFJumpOp<0x0>;
def BPF_JEQ : BPFJumpOp<0x1>;
def BPF_JGT : BPFJumpOp<0x2>;
def BPF_JGE : BPFJumpOp<0x3>;
def BPF_JSET : BPFJumpOp<0x4>;
def BPF_JNE : BPFJumpOp<0x5>;
def BPF_JSGT : BPFJumpOp<0x6>;
def BPF_JSGE : BPFJumpOp<0x7>;
def BPF_CALL : BPFJumpOp<0x8>;
def BPF_EXIT : BPFJumpOp<0x9>;
def BPF_JLT : BPFJumpOp<0xa>;
def BPF_JLE : BPFJumpOp<0xb>;
def BPF_JSLT : BPFJumpOp<0xc>;
def BPF_JSLE : BPFJumpOp<0xd>;
def BPF_JCOND : BPFJumpOp<0xe>;
class BPFWidthModifer<bits<2> val> {
bits<2> Value = val;
}
def BPF_W : BPFWidthModifer<0x0>;
def BPF_H : BPFWidthModifer<0x1>;
def BPF_B : BPFWidthModifer<0x2>;
def BPF_DW : BPFWidthModifer<0x3>;
class BPFModeModifer<bits<3> val> {
bits<3> Value = val;
}
def BPF_IMM : BPFModeModifer<0x0>;
def BPF_ABS : BPFModeModifer<0x1>;
def BPF_IND : BPFModeModifer<0x2>;
def BPF_MEM : BPFModeModifer<0x3>;
def BPF_MEMSX : BPFModeModifer<0x4>;
def BPF_ATOMIC : BPFModeModifer<0x6>;
class BPFAtomicFlag<bits<4> val> {
bits<4> Value = val;
}
def BPF_FETCH : BPFAtomicFlag<0x1>;
class InstBPF<dag outs, dag ins, string asmstr, list<dag> pattern>
: Instruction {
field bits<64> Inst;
field bits<64> SoftFail = 0;
let Size = 8;
let Namespace = "BPF";
let DecoderNamespace = "BPF";
BPFOpClass BPFClass;
let Inst{58-56} = BPFClass.Value;
dag OutOperandList = outs;
dag InOperandList = ins;
let AsmString = asmstr;
let Pattern = pattern;
}
// Pseudo instructions
class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern>
: InstBPF<outs, ins, asmstr, pattern> {
let Inst{63-0} = 0;
let isPseudo = 1;
}
|
