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++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// 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 "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Assembly/Parser.h"
#include "llvm/ADT/StringExtras.h"
// Global variables exported from the lexer...
extern int llvmAsmlineno;
extern std::string &llvmAsmTextin;
// functions exported from the lexer
void set_scan_file(FILE * F);
void set_scan_string (const char * str);
// Globals exported by the parser...
extern char* llvmAsmtext;
extern int llvmAsmleng;
namespace llvm {
// Globals exported by the parser...
extern std::string CurFilename;
class Module;
Module *RunVMAsmParser(const std::string &Filename, FILE *F);
// Parse a string directly
Module *RunVMAsmParser(const char * AsmString, Module * M);
// 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 std::string &message,
int LineNo = -1) {
if (LineNo == -1) LineNo = llvmAsmlineno;
// TODO: column number in exception
throw ParseException(CurFilename, message, LineNo);
}
/// InlineAsmDescriptor - This is a simple class that holds info about inline
/// asm blocks, for use by ValID.
struct InlineAsmDescriptor {
std::string AsmString, Constraints;
bool HasSideEffects;
InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE)
: AsmString(as), Constraints(c), HasSideEffects(HSE) {}
};
// 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.
//
struct ValID {
enum {
NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
} 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
Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
InlineAsmDescriptor *IAD;
};
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(double Val) {
ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
}
static ValID createNull() {
ValID D; D.Type = ConstNullVal; return D;
}
static ValID createUndef() {
ValID D; D.Type = ConstUndefVal; return D;
}
static ValID createZeroInit() {
ValID D; D.Type = ConstZeroVal; return D;
}
static ValID create(Constant *Val) {
ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D;
}
static ValID createInlineAsm(const std::string &AsmString,
const std::string &Constraints,
bool HasSideEffects) {
ValID D;
D.Type = InlineAsmVal;
D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects);
return D;
}
inline void destroy() const {
if (Type == NameVal)
free(Name); // Free this strdup'd memory.
else if (Type == InlineAsmVal)
delete IAD;
}
inline ValID copy() const {
if (Type != NameVal) return *this;
ValID Result = *this;
Result.Name = strdup(Name);
return Result;
}
inline std::string getName() const {
switch (Type) {
case NumberVal : return std::string("#") + itostr(Num);
case NameVal : return Name;
case ConstFPVal : return ftostr(ConstPoolFP);
case ConstNullVal : return "null";
case ConstUndefVal : return "undef";
case ConstZeroVal : return "zeroinitializer";
case ConstUIntVal :
case ConstSIntVal : return std::string("%") + itostr(ConstPool64);
case ConstantVal:
if (ConstantValue == ConstantBool::True) return "true";
if (ConstantValue == ConstantBool::False) return "false";
return "<constant expression>";
default:
assert(0 && "Unknown value!");
abort();
return "";
}
}
bool operator<(const ValID &V) const {
if (Type != V.Type) return Type < V.Type;
switch (Type) {
case NumberVal: return Num < V.Num;
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;
case ConstUndefVal: return false;
case ConstZeroVal: return false;
case ConstantVal: return ConstantValue < V.ConstantValue;
default: assert(0 && "Unknown value type!"); return false;
}
}
};
} // End llvm namespace
#endif
|
