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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
//===- AsmParser.cpp - Parser for Assembly Files --------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class implements the parser for assembly files.
//
//===----------------------------------------------------------------------===//
#include "AsmParser.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
bool AsmParser::Error(SMLoc L, const char *Msg) {
Lexer.PrintMessage(L, Msg);
return true;
}
bool AsmParser::TokError(const char *Msg) {
Lexer.PrintMessage(Lexer.getLoc(), Msg);
return true;
}
bool AsmParser::Run() {
// Prime the lexer.
Lexer.Lex();
while (Lexer.isNot(asmtok::Eof))
if (ParseStatement())
return true;
return false;
}
/// EatToEndOfStatement - Throw away the rest of the line for testing purposes.
void AsmParser::EatToEndOfStatement() {
while (Lexer.isNot(asmtok::EndOfStatement) &&
Lexer.isNot(asmtok::Eof))
Lexer.Lex();
// Eat EOL.
if (Lexer.is(asmtok::EndOfStatement))
Lexer.Lex();
}
struct AsmParser::X86Operand {
enum {
Register,
Immediate
} Kind;
union {
struct {
unsigned RegNo;
} Reg;
struct {
// FIXME: Should be a general expression.
int64_t Val;
} Imm;
};
static X86Operand CreateReg(unsigned RegNo) {
X86Operand Res;
Res.Kind = Register;
Res.Reg.RegNo = RegNo;
return Res;
}
static X86Operand CreateImm(int64_t Val) {
X86Operand Res;
Res.Kind = Immediate;
Res.Imm.Val = Val;
return Res;
}
};
bool AsmParser::ParseX86Operand(X86Operand &Op) {
switch (Lexer.getKind()) {
default:
return TokError("unknown token at start of instruction operand");
case asmtok::Register:
// FIXME: Decode reg #.
Op = X86Operand::CreateReg(0);
Lexer.Lex(); // Eat register.
return false;
case asmtok::Dollar:
// $42 -> immediate.
Lexer.Lex();
// FIXME: Parse an arbitrary expression here, like $(4+5)
if (Lexer.isNot(asmtok::IntVal))
return TokError("expected integer constant");
Op = X86Operand::CreateReg(Lexer.getCurIntVal());
Lexer.Lex(); // Eat register.
return false;
case asmtok::Identifier:
// This is a label, this should be parsed as part of an expression, to
// handle things like LFOO+4
Op = X86Operand::CreateImm(0); // FIXME.
Lexer.Lex(); // Eat identifier.
return false;
//case asmtok::Star:
// * %eax
// * <memaddress>
// Note that these are both "dereferenced".
}
}
/// ParseStatement:
/// ::= EndOfStatement
/// ::= Label* Directive ...Operands... EndOfStatement
/// ::= Label* Identifier OperandList* EndOfStatement
bool AsmParser::ParseStatement() {
switch (Lexer.getKind()) {
default:
return TokError("unexpected token at start of statement");
case asmtok::EndOfStatement:
Lexer.Lex();
return false;
case asmtok::Identifier:
break;
// TODO: Recurse on local labels etc.
}
// If we have an identifier, handle it as the key symbol.
SMLoc IDLoc = Lexer.getLoc();
std::string IDVal = Lexer.getCurStrVal();
// Consume the identifier, see what is after it.
if (Lexer.Lex() == asmtok::Colon) {
// identifier ':' -> Label.
Lexer.Lex();
return ParseStatement();
}
// Otherwise, we have a normal instruction or directive.
if (IDVal[0] == '.') {
Lexer.PrintMessage(IDLoc, "warning: ignoring directive for now");
EatToEndOfStatement();
return false;
}
// If it's an instruction, parse an operand list.
std::vector<X86Operand> Operands;
// Read the first operand, if present. Note that we require a newline at the
// end of file, so we don't have to worry about Eof here.
if (Lexer.isNot(asmtok::EndOfStatement)) {
X86Operand Op;
if (ParseX86Operand(Op))
return true;
Operands.push_back(Op);
}
while (Lexer.is(asmtok::Comma)) {
Lexer.Lex(); // Eat the comma.
// Parse and remember the operand.
X86Operand Op;
if (ParseX86Operand(Op))
return true;
Operands.push_back(Op);
}
if (Lexer.isNot(asmtok::EndOfStatement))
return TokError("unexpected token in operand list");
// Eat the end of statement marker.
Lexer.Lex();
// Instruction is good, process it.
outs() << "Found instruction: " << IDVal << " with " << Operands.size()
<< " operands.\n";
// Skip to end of line for now.
return false;
}
|
