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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
//===-- MCAsmParser.cpp - Abstract Asm Parser Interface -------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCParser/MCAsmParser.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
#include "llvm/MC/MCParser/MCTargetAsmParser.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
using namespace llvm;
cl::opt<unsigned> AsmMacroMaxNestingDepth(
"asm-macro-max-nesting-depth", cl::init(20), cl::Hidden,
cl::desc("The maximum nesting depth allowed for assembly macros."));
MCAsmParser::MCAsmParser() {}
MCAsmParser::~MCAsmParser() = default;
void MCAsmParser::setTargetParser(MCTargetAsmParser &P) {
assert(!TargetParser && "Target parser is already initialized!");
TargetParser = &P;
TargetParser->Initialize(*this);
}
const AsmToken &MCAsmParser::getTok() const {
return getLexer().getTok();
}
bool MCAsmParser::parseTokenLoc(SMLoc &Loc) {
Loc = getTok().getLoc();
return false;
}
bool MCAsmParser::parseEOL() {
if (getTok().getKind() != AsmToken::EndOfStatement)
return Error(getTok().getLoc(), "expected newline");
Lex();
return false;
}
bool MCAsmParser::parseEOL(const Twine &Msg) {
if (getTok().getKind() != AsmToken::EndOfStatement)
return Error(getTok().getLoc(), Msg);
Lex();
return false;
}
bool MCAsmParser::parseToken(AsmToken::TokenKind T, const Twine &Msg) {
if (T == AsmToken::EndOfStatement)
return parseEOL(Msg);
if (getTok().getKind() != T)
return Error(getTok().getLoc(), Msg);
Lex();
return false;
}
bool MCAsmParser::parseIntToken(int64_t &V, const Twine &Msg) {
if (getTok().getKind() != AsmToken::Integer)
return TokError(Msg);
V = getTok().getIntVal();
Lex();
return false;
}
bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T) {
bool Present = (getTok().getKind() == T);
if (Present)
parseToken(T);
return Present;
}
bool MCAsmParser::check(bool P, const Twine &Msg) {
return check(P, getTok().getLoc(), Msg);
}
bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {
if (P)
return Error(Loc, Msg);
return false;
}
bool MCAsmParser::TokError(const Twine &Msg, SMRange Range) {
return Error(getLexer().getLoc(), Msg, Range);
}
bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
MCPendingError PErr;
PErr.Loc = L;
Msg.toVector(PErr.Msg);
PErr.Range = Range;
PendingErrors.push_back(PErr);
// If we threw this parsing error after a lexing error, this should
// supercede the lexing error and so we remove it from the Lexer
// before it can propagate
if (getTok().is(AsmToken::Error))
getLexer().Lex();
return true;
}
bool MCAsmParser::addErrorSuffix(const Twine &Suffix) {
// Make sure lexing errors have propagated to the parser.
if (getTok().is(AsmToken::Error))
Lex();
for (auto &PErr : PendingErrors)
Suffix.toVector(PErr.Msg);
return true;
}
bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
if (parseOptionalToken(AsmToken::EndOfStatement))
return false;
while (true) {
if (parseOne())
return true;
if (parseOptionalToken(AsmToken::EndOfStatement))
return false;
if (hasComma && parseToken(AsmToken::Comma))
return true;
}
return false;
}
bool MCAsmParser::parseExpression(const MCExpr *&Res) {
SMLoc L;
return parseExpression(Res, L);
}
bool MCAsmParser::parseGNUAttribute(SMLoc L, int64_t &Tag,
int64_t &IntegerValue) {
// Parse a .gnu_attribute with numerical tag and value.
StringRef S(L.getPointer());
SMLoc TagLoc;
TagLoc = getTok().getLoc();
const AsmToken &Tok = getTok();
if (Tok.isNot(AsmToken::Integer))
return false;
Tag = Tok.getIntVal();
Lex(); // Eat the Tag
Lex(); // Eat the comma
if (Tok.isNot(AsmToken::Integer))
return false;
IntegerValue = Tok.getIntVal();
Lex(); // Eat the IntegerValue
return true;
}
void MCParsedAsmOperand::dump() const {
// Cannot completely remove virtual function even in release mode.
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dbgs() << " " << *this;
#endif
}
|
