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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
//===-- ParserInternals.h - Definitions internal to the parser ---*- C++ -*--=//
//
// This header file defines the various variables that are shared among the
// different components of the parser...
//
//===----------------------------------------------------------------------===//
#ifndef PARSER_INTERNALS_H
#define PARSER_INTERNALS_H
#include <stdio.h>
#define __STDC_LIMIT_MACROS
#include "llvm/InstrTypes.h"
#include "llvm/BasicBlock.h"
#include "llvm/ConstantVals.h"
#include "llvm/iOther.h"
#include "llvm/Method.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Assembly/Parser.h"
#include "Support/StringExtras.h"
class Module;
// Global variables exported from the lexer...
extern FILE *llvmAsmin;
extern int llvmAsmlineno;
// Globals exported by the parser...
extern string CurFilename;
Module *RunVMAsmParser(const string &Filename, FILE *F);
// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
// appropriate character. If AllowNull is set to false, a \00 value will cause
// an exception to be thrown.
//
// If AllowNull is set to true, the return value of the function points to the
// last character of the string in memory.
//
char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
// ThrowException - Wrapper around the ParseException class that automatically
// fills in file line number and column number and options info.
//
// This also helps me because I keep typing 'throw new ParseException' instead
// of just 'throw ParseException'... sigh...
//
static inline void ThrowException(const string &message,
int LineNo = -1) {
if (LineNo == -1) LineNo = llvmAsmlineno;
// TODO: column number in exception
throw ParseException(CurFilename, message, LineNo);
}
// ValID - Represents a reference of a definition of some sort. This may either
// be a numeric reference or a symbolic (%var) reference. This is just a
// discriminated union.
//
// Note that I can't implement this class in a straight forward manner with
// constructors and stuff because it goes in a union, and GCC doesn't like
// putting classes with ctor's in unions. :(
//
struct ValID {
enum {
NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstStringVal,
ConstFPVal, ConstNullVal
} Type;
union {
int Num; // If it's a numeric reference
char *Name; // If it's a named reference. Memory must be free'd.
int64_t ConstPool64; // Constant pool reference. This is the value
uint64_t UConstPool64;// Unsigned constant pool reference.
double ConstPoolFP; // Floating point constant pool reference
};
static ValID create(int Num) {
ValID D; D.Type = NumberVal; D.Num = Num; return D;
}
static ValID create(char *Name) {
ValID D; D.Type = NameVal; D.Name = Name; return D;
}
static ValID create(int64_t Val) {
ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D;
}
static ValID create(uint64_t Val) {
ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D;
}
static ValID create_conststr(char *Name) {
ValID D; D.Type = ConstStringVal; D.Name = Name; return D;
}
static ValID create(double Val) {
ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
}
static ValID createNull() {
ValID D; D.Type = ConstNullVal; return D;
}
inline void destroy() const {
if (Type == NameVal || Type == ConstStringVal)
free(Name); // Free this strdup'd memory...
}
inline ValID copy() const {
if (Type != NameVal && Type != ConstStringVal) return *this;
ValID Result = *this;
Result.Name = strdup(Name);
return Result;
}
inline string getName() const {
switch (Type) {
case NumberVal : return string("#") + itostr(Num);
case NameVal : return Name;
case ConstStringVal: return string("\"") + Name + string("\"");
case ConstFPVal : return ftostr(ConstPoolFP);
case ConstNullVal : return "null";
case ConstUIntVal :
case ConstSIntVal : return string("%") + itostr(ConstPool64);
default:
assert(0 && "Unknown value!");
abort();
}
}
bool operator<(const ValID &V) const {
if (Type != V.Type) return Type < V.Type;
switch (Type) {
case NumberVal: return Num < V.Num;
case ConstStringVal:
case NameVal: return strcmp(Name, V.Name) < 0;
case ConstSIntVal: return ConstPool64 < V.ConstPool64;
case ConstUIntVal: return UConstPool64 < V.UConstPool64;
case ConstFPVal: return ConstPoolFP < V.ConstPoolFP;
case ConstNullVal: return false;
default: assert(0 && "Unknown value type!"); return false;
}
}
};
template<class SuperType>
class PlaceholderValue : public SuperType {
ValID D;
int LineNum;
public:
PlaceholderValue(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {
LineNum = llvmAsmlineno;
}
ValID &getDef() { return D; }
int getLineNum() const { return LineNum; }
};
struct InstPlaceHolderHelper : public Instruction {
InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {}
virtual Instruction *clone() const { abort(); }
virtual const char *getOpcodeName() const { return "placeholder"; }
};
struct BBPlaceHolderHelper : public BasicBlock {
BBPlaceHolderHelper(const Type *Ty) : BasicBlock() {
assert(Ty->isLabelType());
}
};
struct MethPlaceHolderHelper : public Method {
MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty),
true) {}
};
typedef PlaceholderValue<InstPlaceHolderHelper> ValuePlaceHolder;
typedef PlaceholderValue<BBPlaceHolderHelper> BBPlaceHolder;
static inline ValID &getValIDFromPlaceHolder(const Value *Val) {
const Type *Ty = Val->getType();
if (isa<PointerType>(Ty) &&
isa<MethodType>(cast<PointerType>(Ty)->getValueType()))
Ty = cast<PointerType>(Ty)->getValueType();
switch (Ty->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getDef();
default: return ((ValuePlaceHolder*)Val)->getDef();
}
}
static inline int getLineNumFromPlaceHolder(const Value *Val) {
const Type *Ty = Val->getType();
if (isa<PointerType>(Ty) &&
isa<MethodType>(cast<PointerType>(Ty)->getValueType()))
Ty = cast<PointerType>(Ty)->getValueType();
switch (Ty->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getLineNum();
default: return ((ValuePlaceHolder*)Val)->getLineNum();
}
}
#endif
|
