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
|
//===-- MCAsmParser.cpp - Abstract Asm Parser Interface -------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#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/Debug.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
using namespace llvm;
MCAsmParser::MCAsmParser() : ShowParsedOperands(0) {}
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(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);
}
void MCParsedAsmOperand::dump() const {
// Cannot completely remove virtual function even in release mode.
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dbgs() << " " << *this;
#endif
}
|
