1 //===-- BPFAsmParser.cpp - Parse BPF assembly to MCInst instructions --===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "MCTargetDesc/BPFMCTargetDesc.h"
10 #include "TargetInfo/BPFTargetInfo.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include "llvm/MC/MCContext.h"
14 #include "llvm/MC/MCExpr.h"
15 #include "llvm/MC/MCInst.h"
16 #include "llvm/MC/MCInstrInfo.h"
17 #include "llvm/MC/MCParser/MCAsmLexer.h"
18 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
19 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
20 #include "llvm/MC/MCRegisterInfo.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/MC/MCSubtargetInfo.h"
23 #include "llvm/MC/TargetRegistry.h"
24 #include "llvm/Support/Casting.h"
25
26 using namespace llvm;
27
28 namespace {
29 struct BPFOperand;
30
31 class BPFAsmParser : public MCTargetAsmParser {
32
getLoc() const33 SMLoc getLoc() const { return getParser().getTok().getLoc(); }
34
35 bool PreMatchCheck(OperandVector &Operands);
36
37 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
38 OperandVector &Operands, MCStreamer &Out,
39 uint64_t &ErrorInfo,
40 bool MatchingInlineAsm) override;
41
42 bool parseRegister(MCRegister &Reo, SMLoc &StartLoc, SMLoc &EndLoc) override;
43 ParseStatus tryParseRegister(MCRegister &Reg, SMLoc &StartLoc,
44 SMLoc &EndLoc) override;
45
46 bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
47 SMLoc NameLoc, OperandVector &Operands) override;
48
49 // "=" is used as assignment operator for assembly statment, so can't be used
50 // for symbol assignment.
equalIsAsmAssignment()51 bool equalIsAsmAssignment() override { return false; }
52 // "*" is used for dereferencing memory that it will be the start of
53 // statement.
starIsStartOfStatement()54 bool starIsStartOfStatement() override { return true; }
55
56 #define GET_ASSEMBLER_HEADER
57 #include "BPFGenAsmMatcher.inc"
58
59 ParseStatus parseImmediate(OperandVector &Operands);
60 ParseStatus parseRegister(OperandVector &Operands);
61 ParseStatus parseOperandAsOperator(OperandVector &Operands);
62
63 public:
64 enum BPFMatchResultTy {
65 Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
66 #define GET_OPERAND_DIAGNOSTIC_TYPES
67 #include "BPFGenAsmMatcher.inc"
68 #undef GET_OPERAND_DIAGNOSTIC_TYPES
69 };
70
BPFAsmParser(const MCSubtargetInfo & STI,MCAsmParser & Parser,const MCInstrInfo & MII,const MCTargetOptions & Options)71 BPFAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
72 const MCInstrInfo &MII, const MCTargetOptions &Options)
73 : MCTargetAsmParser(Options, STI, MII) {
74 setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
75 }
76 };
77
78 /// BPFOperand - Instances of this class represent a parsed machine
79 /// instruction
80 struct BPFOperand : public MCParsedAsmOperand {
81
82 enum KindTy {
83 Token,
84 Register,
85 Immediate,
86 } Kind;
87
88 struct RegOp {
89 unsigned RegNum;
90 };
91
92 struct ImmOp {
93 const MCExpr *Val;
94 };
95
96 SMLoc StartLoc, EndLoc;
97 union {
98 StringRef Tok;
99 RegOp Reg;
100 ImmOp Imm;
101 };
102
BPFOperand__anonedec09900111::BPFOperand103 BPFOperand(KindTy K) : Kind(K) {}
104
105 public:
BPFOperand__anonedec09900111::BPFOperand106 BPFOperand(const BPFOperand &o) : MCParsedAsmOperand() {
107 Kind = o.Kind;
108 StartLoc = o.StartLoc;
109 EndLoc = o.EndLoc;
110
111 switch (Kind) {
112 case Register:
113 Reg = o.Reg;
114 break;
115 case Immediate:
116 Imm = o.Imm;
117 break;
118 case Token:
119 Tok = o.Tok;
120 break;
121 }
122 }
123
isToken__anonedec09900111::BPFOperand124 bool isToken() const override { return Kind == Token; }
isReg__anonedec09900111::BPFOperand125 bool isReg() const override { return Kind == Register; }
isImm__anonedec09900111::BPFOperand126 bool isImm() const override { return Kind == Immediate; }
isMem__anonedec09900111::BPFOperand127 bool isMem() const override { return false; }
128
isConstantImm__anonedec09900111::BPFOperand129 bool isConstantImm() const {
130 return isImm() && isa<MCConstantExpr>(getImm());
131 }
132
getConstantImm__anonedec09900111::BPFOperand133 int64_t getConstantImm() const {
134 const MCExpr *Val = getImm();
135 return static_cast<const MCConstantExpr *>(Val)->getValue();
136 }
137
isSImm16__anonedec09900111::BPFOperand138 bool isSImm16() const {
139 return (isConstantImm() && isInt<16>(getConstantImm()));
140 }
141
isSymbolRef__anonedec09900111::BPFOperand142 bool isSymbolRef() const { return isImm() && isa<MCSymbolRefExpr>(getImm()); }
143
isBrTarget__anonedec09900111::BPFOperand144 bool isBrTarget() const { return isSymbolRef() || isSImm16(); }
145
146 /// getStartLoc - Gets location of the first token of this operand
getStartLoc__anonedec09900111::BPFOperand147 SMLoc getStartLoc() const override { return StartLoc; }
148 /// getEndLoc - Gets location of the last token of this operand
getEndLoc__anonedec09900111::BPFOperand149 SMLoc getEndLoc() const override { return EndLoc; }
150
getReg__anonedec09900111::BPFOperand151 MCRegister getReg() const override {
152 assert(Kind == Register && "Invalid type access!");
153 return Reg.RegNum;
154 }
155
getImm__anonedec09900111::BPFOperand156 const MCExpr *getImm() const {
157 assert(Kind == Immediate && "Invalid type access!");
158 return Imm.Val;
159 }
160
getToken__anonedec09900111::BPFOperand161 StringRef getToken() const {
162 assert(Kind == Token && "Invalid type access!");
163 return Tok;
164 }
165
print__anonedec09900111::BPFOperand166 void print(raw_ostream &OS) const override {
167 switch (Kind) {
168 case Immediate:
169 OS << *getImm();
170 break;
171 case Register:
172 OS << "<register x";
173 OS << getReg() << ">";
174 break;
175 case Token:
176 OS << "'" << getToken() << "'";
177 break;
178 }
179 }
180
addExpr__anonedec09900111::BPFOperand181 void addExpr(MCInst &Inst, const MCExpr *Expr) const {
182 assert(Expr && "Expr shouldn't be null!");
183
184 if (auto *CE = dyn_cast<MCConstantExpr>(Expr))
185 Inst.addOperand(MCOperand::createImm(CE->getValue()));
186 else
187 Inst.addOperand(MCOperand::createExpr(Expr));
188 }
189
190 // Used by the TableGen Code
addRegOperands__anonedec09900111::BPFOperand191 void addRegOperands(MCInst &Inst, unsigned N) const {
192 assert(N == 1 && "Invalid number of operands!");
193 Inst.addOperand(MCOperand::createReg(getReg()));
194 }
195
addImmOperands__anonedec09900111::BPFOperand196 void addImmOperands(MCInst &Inst, unsigned N) const {
197 assert(N == 1 && "Invalid number of operands!");
198 addExpr(Inst, getImm());
199 }
200
createToken__anonedec09900111::BPFOperand201 static std::unique_ptr<BPFOperand> createToken(StringRef Str, SMLoc S) {
202 auto Op = std::make_unique<BPFOperand>(Token);
203 Op->Tok = Str;
204 Op->StartLoc = S;
205 Op->EndLoc = S;
206 return Op;
207 }
208
createReg__anonedec09900111::BPFOperand209 static std::unique_ptr<BPFOperand> createReg(unsigned RegNo, SMLoc S,
210 SMLoc E) {
211 auto Op = std::make_unique<BPFOperand>(Register);
212 Op->Reg.RegNum = RegNo;
213 Op->StartLoc = S;
214 Op->EndLoc = E;
215 return Op;
216 }
217
createImm__anonedec09900111::BPFOperand218 static std::unique_ptr<BPFOperand> createImm(const MCExpr *Val, SMLoc S,
219 SMLoc E) {
220 auto Op = std::make_unique<BPFOperand>(Immediate);
221 Op->Imm.Val = Val;
222 Op->StartLoc = S;
223 Op->EndLoc = E;
224 return Op;
225 }
226
227 // Identifiers that can be used at the start of a statment.
isValidIdAtStart__anonedec09900111::BPFOperand228 static bool isValidIdAtStart(StringRef Name) {
229 return StringSwitch<bool>(Name.lower())
230 .Case("if", true)
231 .Case("call", true)
232 .Case("callx", true)
233 .Case("goto", true)
234 .Case("gotol", true)
235 .Case("may_goto", true)
236 .Case("*", true)
237 .Case("exit", true)
238 .Case("lock", true)
239 .Case("ld_pseudo", true)
240 .Default(false);
241 }
242
243 // Identifiers that can be used in the middle of a statment.
isValidIdInMiddle__anonedec09900111::BPFOperand244 static bool isValidIdInMiddle(StringRef Name) {
245 return StringSwitch<bool>(Name.lower())
246 .Case("u64", true)
247 .Case("u32", true)
248 .Case("u16", true)
249 .Case("u8", true)
250 .Case("s32", true)
251 .Case("s16", true)
252 .Case("s8", true)
253 .Case("be64", true)
254 .Case("be32", true)
255 .Case("be16", true)
256 .Case("le64", true)
257 .Case("le32", true)
258 .Case("le16", true)
259 .Case("bswap16", true)
260 .Case("bswap32", true)
261 .Case("bswap64", true)
262 .Case("goto", true)
263 .Case("gotol", true)
264 .Case("ll", true)
265 .Case("skb", true)
266 .Case("s", true)
267 .Case("atomic_fetch_add", true)
268 .Case("atomic_fetch_and", true)
269 .Case("atomic_fetch_or", true)
270 .Case("atomic_fetch_xor", true)
271 .Case("xchg_64", true)
272 .Case("xchg32_32", true)
273 .Case("cmpxchg_64", true)
274 .Case("cmpxchg32_32", true)
275 .Case("addr_space_cast", true)
276 .Default(false);
277 }
278 };
279 } // end anonymous namespace.
280
281 #define GET_REGISTER_MATCHER
282 #define GET_MATCHER_IMPLEMENTATION
283 #include "BPFGenAsmMatcher.inc"
284
PreMatchCheck(OperandVector & Operands)285 bool BPFAsmParser::PreMatchCheck(OperandVector &Operands) {
286
287 if (Operands.size() == 4) {
288 // check "reg1 = -reg2" and "reg1 = be16/be32/be64/le16/le32/le64 reg2",
289 // reg1 must be the same as reg2
290 BPFOperand &Op0 = (BPFOperand &)*Operands[0];
291 BPFOperand &Op1 = (BPFOperand &)*Operands[1];
292 BPFOperand &Op2 = (BPFOperand &)*Operands[2];
293 BPFOperand &Op3 = (BPFOperand &)*Operands[3];
294 if (Op0.isReg() && Op1.isToken() && Op2.isToken() && Op3.isReg()
295 && Op1.getToken() == "="
296 && (Op2.getToken() == "-" || Op2.getToken() == "be16"
297 || Op2.getToken() == "be32" || Op2.getToken() == "be64"
298 || Op2.getToken() == "le16" || Op2.getToken() == "le32"
299 || Op2.getToken() == "le64")
300 && Op0.getReg() != Op3.getReg())
301 return true;
302 }
303
304 return false;
305 }
306
MatchAndEmitInstruction(SMLoc IDLoc,unsigned & Opcode,OperandVector & Operands,MCStreamer & Out,uint64_t & ErrorInfo,bool MatchingInlineAsm)307 bool BPFAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
308 OperandVector &Operands,
309 MCStreamer &Out, uint64_t &ErrorInfo,
310 bool MatchingInlineAsm) {
311 MCInst Inst;
312 SMLoc ErrorLoc;
313
314 if (PreMatchCheck(Operands))
315 return Error(IDLoc, "additional inst constraint not met");
316
317 switch (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm)) {
318 default:
319 break;
320 case Match_Success:
321 Inst.setLoc(IDLoc);
322 Out.emitInstruction(Inst, getSTI());
323 return false;
324 case Match_MissingFeature:
325 return Error(IDLoc, "instruction use requires an option to be enabled");
326 case Match_MnemonicFail:
327 return Error(IDLoc, "unrecognized instruction mnemonic");
328 case Match_InvalidOperand:
329 ErrorLoc = IDLoc;
330
331 if (ErrorInfo != ~0U) {
332 if (ErrorInfo >= Operands.size())
333 return Error(ErrorLoc, "too few operands for instruction");
334
335 ErrorLoc = ((BPFOperand &)*Operands[ErrorInfo]).getStartLoc();
336
337 if (ErrorLoc == SMLoc())
338 ErrorLoc = IDLoc;
339 }
340
341 return Error(ErrorLoc, "invalid operand for instruction");
342 case Match_InvalidBrTarget:
343 return Error(Operands[ErrorInfo]->getStartLoc(),
344 "operand is not an identifier or 16-bit signed integer");
345 case Match_InvalidSImm16:
346 return Error(Operands[ErrorInfo]->getStartLoc(),
347 "operand is not a 16-bit signed integer");
348 }
349
350 llvm_unreachable("Unknown match type detected!");
351 }
352
parseRegister(MCRegister & Reg,SMLoc & StartLoc,SMLoc & EndLoc)353 bool BPFAsmParser::parseRegister(MCRegister &Reg, SMLoc &StartLoc,
354 SMLoc &EndLoc) {
355 if (!tryParseRegister(Reg, StartLoc, EndLoc).isSuccess())
356 return Error(StartLoc, "invalid register name");
357 return false;
358 }
359
tryParseRegister(MCRegister & Reg,SMLoc & StartLoc,SMLoc & EndLoc)360 ParseStatus BPFAsmParser::tryParseRegister(MCRegister &Reg, SMLoc &StartLoc,
361 SMLoc &EndLoc) {
362 const AsmToken &Tok = getParser().getTok();
363 StartLoc = Tok.getLoc();
364 EndLoc = Tok.getEndLoc();
365 Reg = BPF::NoRegister;
366 StringRef Name = getLexer().getTok().getIdentifier();
367
368 if (!MatchRegisterName(Name)) {
369 getParser().Lex(); // Eat identifier token.
370 return ParseStatus::Success;
371 }
372
373 return ParseStatus::NoMatch;
374 }
375
parseOperandAsOperator(OperandVector & Operands)376 ParseStatus BPFAsmParser::parseOperandAsOperator(OperandVector &Operands) {
377 SMLoc S = getLoc();
378
379 if (getLexer().getKind() == AsmToken::Identifier) {
380 StringRef Name = getLexer().getTok().getIdentifier();
381
382 if (BPFOperand::isValidIdInMiddle(Name)) {
383 getLexer().Lex();
384 Operands.push_back(BPFOperand::createToken(Name, S));
385 return ParseStatus::Success;
386 }
387
388 return ParseStatus::NoMatch;
389 }
390
391 switch (getLexer().getKind()) {
392 case AsmToken::Minus:
393 case AsmToken::Plus: {
394 if (getLexer().peekTok().is(AsmToken::Integer))
395 return ParseStatus::NoMatch;
396 [[fallthrough]];
397 }
398
399 case AsmToken::Equal:
400 case AsmToken::Greater:
401 case AsmToken::Less:
402 case AsmToken::Pipe:
403 case AsmToken::Star:
404 case AsmToken::LParen:
405 case AsmToken::RParen:
406 case AsmToken::LBrac:
407 case AsmToken::RBrac:
408 case AsmToken::Slash:
409 case AsmToken::Amp:
410 case AsmToken::Percent:
411 case AsmToken::Caret: {
412 StringRef Name = getLexer().getTok().getString();
413 getLexer().Lex();
414 Operands.push_back(BPFOperand::createToken(Name, S));
415
416 return ParseStatus::Success;
417 }
418
419 case AsmToken::EqualEqual:
420 case AsmToken::ExclaimEqual:
421 case AsmToken::GreaterEqual:
422 case AsmToken::GreaterGreater:
423 case AsmToken::LessEqual:
424 case AsmToken::LessLess: {
425 Operands.push_back(BPFOperand::createToken(
426 getLexer().getTok().getString().substr(0, 1), S));
427 Operands.push_back(BPFOperand::createToken(
428 getLexer().getTok().getString().substr(1, 1), S));
429 getLexer().Lex();
430
431 return ParseStatus::Success;
432 }
433
434 default:
435 break;
436 }
437
438 return ParseStatus::NoMatch;
439 }
440
parseRegister(OperandVector & Operands)441 ParseStatus BPFAsmParser::parseRegister(OperandVector &Operands) {
442 SMLoc S = getLoc();
443 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
444
445 switch (getLexer().getKind()) {
446 default:
447 return ParseStatus::NoMatch;
448 case AsmToken::Identifier:
449 StringRef Name = getLexer().getTok().getIdentifier();
450 unsigned RegNo = MatchRegisterName(Name);
451
452 if (RegNo == 0)
453 return ParseStatus::NoMatch;
454
455 getLexer().Lex();
456 Operands.push_back(BPFOperand::createReg(RegNo, S, E));
457 }
458 return ParseStatus::Success;
459 }
460
parseImmediate(OperandVector & Operands)461 ParseStatus BPFAsmParser::parseImmediate(OperandVector &Operands) {
462 switch (getLexer().getKind()) {
463 default:
464 return ParseStatus::NoMatch;
465 case AsmToken::LParen:
466 case AsmToken::Minus:
467 case AsmToken::Plus:
468 case AsmToken::Integer:
469 case AsmToken::String:
470 case AsmToken::Identifier:
471 break;
472 }
473
474 const MCExpr *IdVal;
475 SMLoc S = getLoc();
476
477 if (getParser().parseExpression(IdVal))
478 return ParseStatus::Failure;
479
480 SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
481 Operands.push_back(BPFOperand::createImm(IdVal, S, E));
482
483 return ParseStatus::Success;
484 }
485
486 /// ParseInstruction - Parse an BPF instruction which is in BPF verifier
487 /// format.
ParseInstruction(ParseInstructionInfo & Info,StringRef Name,SMLoc NameLoc,OperandVector & Operands)488 bool BPFAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
489 SMLoc NameLoc, OperandVector &Operands) {
490 // The first operand could be either register or actually an operator.
491 unsigned RegNo = MatchRegisterName(Name);
492
493 if (RegNo != 0) {
494 SMLoc E = SMLoc::getFromPointer(NameLoc.getPointer() - 1);
495 Operands.push_back(BPFOperand::createReg(RegNo, NameLoc, E));
496 } else if (BPFOperand::isValidIdAtStart (Name))
497 Operands.push_back(BPFOperand::createToken(Name, NameLoc));
498 else
499 return Error(NameLoc, "invalid register/token name");
500
501 while (!getLexer().is(AsmToken::EndOfStatement)) {
502 // Attempt to parse token as operator
503 if (parseOperandAsOperator(Operands).isSuccess())
504 continue;
505
506 // Attempt to parse token as register
507 if (parseRegister(Operands).isSuccess())
508 continue;
509
510 if (getLexer().is(AsmToken::Comma)) {
511 getLexer().Lex();
512 continue;
513 }
514
515 // Attempt to parse token as an immediate
516 if (!parseImmediate(Operands).isSuccess()) {
517 SMLoc Loc = getLexer().getLoc();
518 return Error(Loc, "unexpected token");
519 }
520 }
521
522 if (getLexer().isNot(AsmToken::EndOfStatement)) {
523 SMLoc Loc = getLexer().getLoc();
524
525 getParser().eatToEndOfStatement();
526
527 return Error(Loc, "unexpected token");
528 }
529
530 // Consume the EndOfStatement.
531 getParser().Lex();
532 return false;
533 }
534
LLVMInitializeBPFAsmParser()535 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFAsmParser() {
536 RegisterMCAsmParser<BPFAsmParser> X(getTheBPFTarget());
537 RegisterMCAsmParser<BPFAsmParser> Y(getTheBPFleTarget());
538 RegisterMCAsmParser<BPFAsmParser> Z(getTheBPFbeTarget());
539 }
540