blob: 6b4f64a0e96e169e41c3138c939a589f91198f60 (
plain) (
blame)
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
|
//===-- 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_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 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_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>;
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_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;
}
|
