1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Subtarget Enumeration Source Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifdef GET_SUBTARGETINFO_ENUM
10#undef GET_SUBTARGETINFO_ENUM
11
12namespace llvm {
13
14namespace BPF {
15
16enum {
17 ALU32 = 0,
18 DummyFeature = 1,
19 DwarfRIS = 2,
20 FuncTable = 3,
21 MisalignedMemAccess = 4,
22 NumSubtargetFeatures = 5
23};
24
25} // namespace BPF
26
27} // namespace llvm
28
29#endif // GET_SUBTARGETINFO_ENUM
30
31#ifdef GET_SUBTARGETINFO_MACRO
32
33GET_SUBTARGETINFO_MACRO(AllowsMisalignedMemAccess, false, allowsMisalignedMemAccess)
34GET_SUBTARGETINFO_MACRO(HasAlu32, false, hasAlu32)
35GET_SUBTARGETINFO_MACRO(HasFuncTable, false, hasFuncTable)
36GET_SUBTARGETINFO_MACRO(UseDwarfRIS, false, useDwarfRIS)
37GET_SUBTARGETINFO_MACRO(isDummyMode, false, isDummyMode)
38
39#undef GET_SUBTARGETINFO_MACRO
40#endif // GET_SUBTARGETINFO_MACRO
41
42#ifdef GET_SUBTARGETINFO_MC_DESC
43#undef GET_SUBTARGETINFO_MC_DESC
44
45namespace llvm {
46
47// Sorted (by key) array of values for CPU features.
48extern const llvm::SubtargetFeatureKVStorage< 5, 220> BPFFeatureKVStorage = {
49 {
50 { sizeof(SubtargetFeatureKV) * 5 + 1, sizeof(SubtargetFeatureKV) * 5 + 30, BPF::MisalignedMemAccess, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } } },
51 { sizeof(SubtargetFeatureKV) * 4 + 62, sizeof(SubtargetFeatureKV) * 4 + 68, BPF::ALU32, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } } },
52 { sizeof(SubtargetFeatureKV) * 3 + 94, sizeof(SubtargetFeatureKV) * 3 + 100, BPF::DummyFeature, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } } },
53 { sizeof(SubtargetFeatureKV) * 2 + 115, sizeof(SubtargetFeatureKV) * 2 + 124, BPF::DwarfRIS, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } } },
54 { sizeof(SubtargetFeatureKV) * 1 + 177, sizeof(SubtargetFeatureKV) * 1 + 188, BPF::FuncTable, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } } },
55 },
56 "\000allows-misaligned-mem-access\000Allows misaligned memory access\000"
57 "alu32\000Enable ALU32 instructions\000dummy\000unused feature\000dwarfr"
58 "is\000Disable MCAsmInfo DwarfUsesRelocationsAcrossSections\000func-tabl"
59 "e\000Call functions through a table\000"};
60
61#ifdef DBGFIELD
62#error "<target>GenSubtargetInfo.inc requires a DBGFIELD macro"
63#endif
64#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
65#define DBGFIELD(x) x,
66#define DBGVAL_OR_NULLPTR(x) x
67#else
68#define DBGFIELD(x)
69#define DBGVAL_OR_NULLPTR(x) nullptr
70#endif
71
72// ===============================================================
73// Data tables for the new per-operand machine model.
74
75static_assert(0 <= UINT8_MAX, "NumWriteProcResEntries does not fit in uint8_t");
76static_assert(0 <= UINT8_MAX, "NumWriteLatencyEntries does not fit in uint8_t");
77
78// {ProcResourceIdx, ReleaseAtCycle, AcquireAtCycle}
79extern const llvm::MCWriteProcResEntry BPFWriteProcResTable[] = {
80 { 0, 0, 0 }, // Invalid
81}; // BPFWriteProcResTable
82
83// {Cycles, WriteResourceID}
84extern const llvm::MCWriteLatencyEntry BPFWriteLatencyTable[] = {
85 { 0, 0}, // Invalid
86}; // BPFWriteLatencyTable
87
88// {UseIdx, WriteResourceID, Cycles}
89extern const llvm::MCReadAdvanceEntry BPFReadAdvanceTable[] = {
90 {0, 0, 0}, // Invalid
91}; // BPFReadAdvanceTable
92
93#ifdef __GNUC__
94#pragma GCC diagnostic push
95#pragma GCC diagnostic ignored "-Woverlength-strings"
96#endif
97static constexpr char BPFSchedClassNamesStorage[] =
98 "\0"
99 "InvalidSchedClass\0"
100 ;
101#ifdef __GNUC__
102#pragma GCC diagnostic pop
103#endif
104
105static constexpr llvm::StringTable
106BPFSchedClassNames = BPFSchedClassNamesStorage;
107
108extern const llvm::MCSchedModel BPFSchedModels[] = {
109{ // NoSchedModel
110 MCSchedModel::DefaultIssueWidth,
111 MCSchedModel::DefaultMicroOpBufferSize,
112 MCSchedModel::DefaultLoopMicroOpBufferSize,
113 MCSchedModel::DefaultLoadLatency,
114 MCSchedModel::DefaultHighLatency,
115 MCSchedModel::DefaultMispredictPenalty,
116 false, // PostRAScheduler
117 false, // CompleteModel
118 false, // EnableIntervals
119 0, // Processor ID
120 nullptr, nullptr, 0, 0, // No instruction-level machine model.
121 DBGVAL_OR_NULLPTR(&BPFSchedClassNames), // SchedClassNames
122 nullptr, // No Itinerary
123 nullptr // No extra processor descriptor
124 },
125};
126
127#undef DBGFIELD
128
129#undef DBGVAL_OR_NULLPTR
130
131static constexpr size_t BPFCPUAliasArraySize = sizeof(std::array<SubtargetSubTypeAliasKV, 0>);
132// Sorted (by key) array of values for CPU subtype.
133extern const llvm::SubtargetSubTypeKVStorage< 7, 0, 31> BPFSubTypeKVStorage = {
134 {
135 { sizeof(SubtargetSubTypeKV) * 7 + BPFCPUAliasArraySize + 1, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
136 { sizeof(SubtargetSubTypeKV) * 6 + BPFCPUAliasArraySize + 9, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
137 { sizeof(SubtargetSubTypeKV) * 5 + BPFCPUAliasArraySize + 15, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
138 { sizeof(SubtargetSubTypeKV) * 4 + BPFCPUAliasArraySize + 18, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
139 { sizeof(SubtargetSubTypeKV) * 3 + BPFCPUAliasArraySize + 21, { { { 0x1ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
140 { sizeof(SubtargetSubTypeKV) * 2 + BPFCPUAliasArraySize + 24, { { { 0x1ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
141 { sizeof(SubtargetSubTypeKV) * 1 + BPFCPUAliasArraySize + 27, { { { 0x1ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, { { { 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, 0x0ULL, } } }, 0 },
142 },
143 { {
144 } },
145 "\000generic\000probe\000v1\000v2\000v3\000v4\000v5\000"};
146
147namespace BPF_MC {
148
149unsigned resolveVariantSchedClassImpl(unsigned SchedClass,
150 const MCInst *MI, const MCInstrInfo *MCII, const MCSubtargetInfo &STI, unsigned CPUID) {
151 // Don't know how to resolve this scheduling class.
152 return 0;
153}
154ArrayRef<unsigned> getVariantSchedClassTargets(unsigned SchedClass,
155 unsigned CPUID) {
156 return {};
157}
158
159} // namespace BPF_MC
160struct BPFGenMCSubtargetInfo : public MCSubtargetInfo {
161 BPFGenMCSubtargetInfo(const Triple &TT,
162 StringRef CPU, StringRef TuneCPU, StringRef FS,
163 StringTable PN,
164 ArrayRef<SubtargetFeatureKV> PF,
165 ArrayRef<SubtargetSubTypeKV> PD,
166 ArrayRef<SubtargetSubTypeAliasKV> PA,
167 const MCSchedModel *PSM,
168 const MCWriteProcResEntry *WPR,
169 const MCWriteLatencyEntry *WL,
170 const MCReadAdvanceEntry *RA, const InstrStage *IS,
171 const unsigned *OC, const unsigned *FP) :
172 MCSubtargetInfo(TT, CPU, TuneCPU, FS, PN, PF, PD, PA, PSM,
173 WPR, WL, RA, IS, OC, FP) { }
174
175 explicit BPFGenMCSubtargetInfo(const MCSubtargetInfo &STI)
176 : MCSubtargetInfo(STI) {}
177
178 std::unique_ptr<MCSubtargetInfo> clone() const final {
179 return std::make_unique<BPFGenMCSubtargetInfo>(*this);
180 }
181
182 unsigned resolveVariantSchedClass(unsigned SchedClass,
183 const MCInst *MI, const MCInstrInfo *MCII,
184 unsigned CPUID) const final {
185 return BPF_MC::resolveVariantSchedClassImpl(SchedClass, MI, MCII, *this, CPUID);
186 }
187};
188namespace BPF_MC {
189
190std::unique_ptr<MCSubtargetInfo> cloneSubtargetInfo(const MCSubtargetInfo &STI) {
191 return std::make_unique<BPFGenMCSubtargetInfo>(STI);
192}
193
194} // namespace BPF_MC
195
196static inline MCSubtargetInfo *createBPFMCSubtargetInfoImpl(const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS) {
197 return new BPFGenMCSubtargetInfo(TT, CPU, TuneCPU, FS, StringTable(BPFSubTypeKVStorage.Strings), BPFFeatureKVStorage.Features, BPFSubTypeKVStorage.SubTypes, ArrayRef(BPFSubTypeKVStorage.Aliases).take_front(0), BPFSchedModels,
198 BPFWriteProcResTable, BPFWriteLatencyTable, BPFReadAdvanceTable,
199 nullptr, nullptr, nullptr);
200}
201
202
203} // namespace llvm
204
205#endif // GET_SUBTARGETINFO_MC_DESC
206
207#ifdef GET_SUBTARGETINFO_TARGET_DESC
208#undef GET_SUBTARGETINFO_TARGET_DESC
209
210#include "llvm/ADT/BitmaskEnum.h"
211#include "llvm/Support/Debug.h"
212#include "llvm/Support/raw_ostream.h"
213
214// ParseSubtargetFeatures - Parses features string setting specified
215// subtarget options.
216void llvm::BPFSubtarget::ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS) {
217 LLVM_DEBUG(dbgs() << "\nFeatures:" << FS);
218 LLVM_DEBUG(dbgs() << "\nCPU:" << CPU);
219 LLVM_DEBUG(dbgs() << "\nTuneCPU:" << TuneCPU << "\n\n");
220 InitMCProcessorInfo(CPU, TuneCPU, FS);
221 const FeatureBitset &Bits = getFeatureBits();
222 if (Bits[BPF::ALU32]) HasAlu32 = true;
223 if (Bits[BPF::DummyFeature]) isDummyMode = true;
224 if (Bits[BPF::DwarfRIS]) UseDwarfRIS = true;
225 if (Bits[BPF::FuncTable]) HasFuncTable = true;
226 if (Bits[BPF::MisalignedMemAccess]) AllowsMisalignedMemAccess = true;
227}
228
229#endif // GET_SUBTARGETINFO_TARGET_DESC
230
231#ifdef GET_SUBTARGETINFO_HEADER
232#undef GET_SUBTARGETINFO_HEADER
233
234namespace llvm {
235
236class DFAPacketizer;
237namespace BPF_MC {
238
239unsigned resolveVariantSchedClassImpl(unsigned SchedClass, const MCInst *MI, const MCInstrInfo *MCII, const MCSubtargetInfo &STI, unsigned CPUID);
240std::unique_ptr<MCSubtargetInfo> cloneSubtargetInfo(const MCSubtargetInfo &STI);
241ArrayRef<unsigned> getVariantSchedClassTargets(unsigned SchedClass, unsigned CPUID);
242
243} // namespace BPF_MC
244struct BPFGenSubtargetInfo : public TargetSubtargetInfo {
245 explicit BPFGenSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS);
246public:
247 std::unique_ptr<MCSubtargetInfo> clone() const final;
248 unsigned resolveSchedClass(unsigned SchedClass, const MachineInstr *DefMI, const TargetSchedModel *SchedModel) const final;
249 unsigned resolveVariantSchedClass(unsigned SchedClass, const MCInst *MI, const MCInstrInfo *MCII, unsigned CPUID) const final;
250 DFAPacketizer *createDFAPacketizer(const InstrItineraryData *IID) const;
251 const FeatureBitset &getInlineIgnoreFeatures() const override;
252 const FeatureBitset &getInlineInverseFeatures() const override;
253 const FeatureBitset &getInlineMustMatchFeatures() const override;
254};
255
256} // namespace llvm
257
258#endif // GET_SUBTARGETINFO_HEADER
259
260#ifdef GET_SUBTARGETINFO_CTOR
261#undef GET_SUBTARGETINFO_CTOR
262
263#include "llvm/CodeGen/TargetSchedule.h"
264
265namespace llvm {
266
267extern const llvm::StringRef BPFNames[];
268extern const llvm::SubtargetFeatureKVStorage<5, 220> BPFFeatureKVStorage;
269extern const llvm::SubtargetSubTypeKVStorage<7, 0, 31> BPFSubTypeKVStorage;
270extern const llvm::MCSchedModel BPFSchedModels[];
271extern const llvm::MCWriteProcResEntry BPFWriteProcResTable[];
272extern const llvm::MCWriteLatencyEntry BPFWriteLatencyTable[];
273extern const llvm::MCReadAdvanceEntry BPFReadAdvanceTable[];
274BPFGenSubtargetInfo::BPFGenSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS)
275 : TargetSubtargetInfo(TT, CPU, TuneCPU, FS, StringTable(BPFSubTypeKVStorage.Strings), ArrayRef(BPFFeatureKVStorage.Features), ArrayRef(BPFSubTypeKVStorage.SubTypes), ArrayRef(BPFSubTypeKVStorage.Aliases).take_front(0), BPFSchedModels,
276 BPFWriteProcResTable, BPFWriteLatencyTable, BPFReadAdvanceTable,
277 nullptr, nullptr, nullptr) {}
278
279unsigned BPFGenSubtargetInfo
280::resolveSchedClass(unsigned SchedClass, const MachineInstr *MI, const TargetSchedModel *SchedModel) const {
281 report_fatal_error("Expected a variant SchedClass");
282} // BPFGenSubtargetInfo::resolveSchedClass
283
284unsigned BPFGenSubtargetInfo
285::resolveVariantSchedClass(unsigned SchedClass, const MCInst *MI, const MCInstrInfo *MCII, unsigned CPUID) const {
286 return BPF_MC::resolveVariantSchedClassImpl(SchedClass, MI, MCII, *this, CPUID);
287} // BPFGenSubtargetInfo::resolveVariantSchedClass
288
289std::unique_ptr<MCSubtargetInfo> BPFGenSubtargetInfo::clone() const {
290 return BPF_MC::cloneSubtargetInfo(*this);
291} // BPFGenSubtargetInfo::clone
292
293const FeatureBitset &BPFGenSubtargetInfo::getInlineIgnoreFeatures() const {
294 static constexpr FeatureBitset Features = {
295 };
296 return Features;
297}
298
299const FeatureBitset &BPFGenSubtargetInfo::getInlineInverseFeatures() const {
300 static constexpr FeatureBitset Features = {
301 };
302 return Features;
303}
304
305const FeatureBitset &BPFGenSubtargetInfo::getInlineMustMatchFeatures() const {
306 static constexpr FeatureBitset Features = {
307 };
308 return Features;
309}
310
311
312} // namespace llvm
313
314#endif // GET_SUBTARGETINFO_CTOR
315
316#ifdef GET_STIPREDICATE_DECLS_FOR_MC_ANALYSIS
317#undef GET_STIPREDICATE_DECLS_FOR_MC_ANALYSIS
318
319
320#endif // GET_STIPREDICATE_DECLS_FOR_MC_ANALYSIS
321
322#ifdef GET_STIPREDICATE_DEFS_FOR_MC_ANALYSIS
323#undef GET_STIPREDICATE_DEFS_FOR_MC_ANALYSIS
324
325
326#endif // GET_STIPREDICATE_DEFS_FOR_MC_ANALYSIS
327
328