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
|
//===-- 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/ConstPoolVals.h"
#include "llvm/iOther.h"
#include "llvm/Method.h"
#include "llvm/Type.h"
#include "llvm/Assembly/Parser.h"
#include "llvm/Tools/CommandLine.h"
#include "llvm/Tools/StringExtras.h"
class Module;
// Global variables exported from the lexer...
extern FILE *llvmAsmin;
extern int llvmAsmlineno;
// Globals exported by the parser...
extern const ToolCommandLine *CurOptions;
Module *RunVMAsmParser(const ToolCommandLine &Opts, FILE *F);
// 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) {
// TODO: column number in exception
throw ParseException(*CurOptions, message, llvmAsmlineno);
}
// 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 {
int Type; // 0 = number, 1 = name, 2 = const pool,
// 3 = unsigned const pool, 4 = const string
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.
};
static ValID create(int Num) {
ValID D; D.Type = 0; D.Num = Num; return D;
}
static ValID create(char *Name) {
ValID D; D.Type = 1; D.Name = Name; return D;
}
static ValID create(int64_t Val) {
ValID D; D.Type = 2; D.ConstPool64 = Val; return D;
}
static ValID create(uint64_t Val) {
ValID D; D.Type = 3; D.UConstPool64 = Val; return D;
}
static ValID create_conststr(char *Name) {
ValID D; D.Type = 4; D.Name = Name; return D;
}
inline void destroy() {
if (Type == 1 || Type == 4) free(Name); // Free this strdup'd memory...
}
inline ValID copy() const {
if (Type != 1 && Type != 4) return *this;
ValID Result = *this;
Result.Name = strdup(Name);
return Result;
}
inline string getName() const {
switch (Type) {
case 0: return string("#") + itostr(Num);
case 1: return Name;
case 4: return string("\"") + Name + string("\"");
default: return string("%") + itostr(ConstPool64);
}
}
};
template<class SuperType>
class PlaceholderDef : public SuperType {
ValID D;
// TODO: Placeholder def should hold Line #/Column # of definition in case
// there is an error resolving the defintition!
public:
PlaceholderDef(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {}
ValID &getDef() { return D; }
};
struct InstPlaceHolderHelper : public Instruction {
InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {}
virtual Instruction *clone() const { abort(); }
inline virtual void dropAllReferences() {}
virtual string getOpcode() const { return "placeholder"; }
// No "operands"...
virtual Value *getOperand(unsigned i) { return 0; }
virtual const Value *getOperand(unsigned i) const { return 0; }
virtual bool setOperand(unsigned i, Value *Val) { return false; }
virtual unsigned getNumOperands() const { return 0; }
};
struct BBPlaceHolderHelper : public BasicBlock {
BBPlaceHolderHelper(const Type *Ty) : BasicBlock() {
assert(Ty->isLabelType());
}
};
struct MethPlaceHolderHelper : public Method {
MethPlaceHolderHelper(const Type *Ty)
: Method((const MethodType*)Ty) {
assert(Ty->isMethodType() && "Method placeholders must be method types!");
}
};
typedef PlaceholderDef<InstPlaceHolderHelper> DefPlaceHolder;
typedef PlaceholderDef<BBPlaceHolderHelper> BBPlaceHolder;
typedef PlaceholderDef<MethPlaceHolderHelper> MethPlaceHolder;
//typedef PlaceholderDef<ModulePlaceHolderHelper> ModulePlaceHolder;
static inline ValID &getValIDFromPlaceHolder(Value *Def) {
switch (Def->getType()->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Def)->getDef();
case Type::MethodTyID: return ((MethPlaceHolder*)Def)->getDef();
//case Type::ModuleTyID: return ((ModulePlaceHolder*)Def)->getDef();
default: return ((DefPlaceHolder*)Def)->getDef();
}
}
#endif
|
