1//===-- LLParser.cpp - Parser Class ---------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the parser class for .ll files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "LLParser.h"
15#include "llvm/AutoUpgrade.h"
16#include "llvm/CallingConv.h"
17#include "llvm/Constants.h"
18#include "llvm/DerivedTypes.h"
19#include "llvm/InlineAsm.h"
20#include "llvm/Instructions.h"
| 1//===-- LLParser.cpp - Parser Class ---------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the parser class for .ll files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "LLParser.h"
15#include "llvm/AutoUpgrade.h"
16#include "llvm/CallingConv.h"
17#include "llvm/Constants.h"
18#include "llvm/DerivedTypes.h"
19#include "llvm/InlineAsm.h"
20#include "llvm/Instructions.h"
|
21#include "llvm/LLVMContext.h"
22#include "llvm/Metadata.h"
| |
23#include "llvm/Module.h"
24#include "llvm/Operator.h"
25#include "llvm/ValueSymbolTable.h"
26#include "llvm/ADT/SmallPtrSet.h"
27#include "llvm/ADT/StringExtras.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/raw_ostream.h"
30using namespace llvm;
31
32/// Run: module ::= toplevelentity*
33bool LLParser::Run() {
34 // Prime the lexer.
35 Lex.Lex();
36
37 return ParseTopLevelEntities() ||
38 ValidateEndOfModule();
39}
40
41/// ValidateEndOfModule - Do final validity and sanity checks at the end of the
42/// module.
43bool LLParser::ValidateEndOfModule() {
44 // Update auto-upgraded malloc calls to "malloc".
45 // FIXME: Remove in LLVM 3.0.
46 if (MallocF) {
47 MallocF->setName("malloc");
48 // If setName() does not set the name to "malloc", then there is already a
49 // declaration of "malloc". In that case, iterate over all calls to MallocF
50 // and get them to call the declared "malloc" instead.
51 if (MallocF->getName() != "malloc") {
52 Constant *RealMallocF = M->getFunction("malloc");
53 if (RealMallocF->getType() != MallocF->getType())
54 RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType());
55 MallocF->replaceAllUsesWith(RealMallocF);
56 MallocF->eraseFromParent();
57 MallocF = NULL;
58 }
59 }
60
61
62 // If there are entries in ForwardRefBlockAddresses at this point, they are
63 // references after the function was defined. Resolve those now.
64 while (!ForwardRefBlockAddresses.empty()) {
65 // Okay, we are referencing an already-parsed function, resolve them now.
66 Function *TheFn = 0;
67 const ValID &Fn = ForwardRefBlockAddresses.begin()->first;
68 if (Fn.Kind == ValID::t_GlobalName)
69 TheFn = M->getFunction(Fn.StrVal);
70 else if (Fn.UIntVal < NumberedVals.size())
71 TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]);
72
73 if (TheFn == 0)
74 return Error(Fn.Loc, "unknown function referenced by blockaddress");
75
76 // Resolve all these references.
77 if (ResolveForwardRefBlockAddresses(TheFn,
78 ForwardRefBlockAddresses.begin()->second,
79 0))
80 return true;
81
82 ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin());
83 }
84
85
86 if (!ForwardRefTypes.empty())
87 return Error(ForwardRefTypes.begin()->second.second,
88 "use of undefined type named '" +
89 ForwardRefTypes.begin()->first + "'");
90 if (!ForwardRefTypeIDs.empty())
91 return Error(ForwardRefTypeIDs.begin()->second.second,
92 "use of undefined type '%" +
93 utostr(ForwardRefTypeIDs.begin()->first) + "'");
94
95 if (!ForwardRefVals.empty())
96 return Error(ForwardRefVals.begin()->second.second,
97 "use of undefined value '@" + ForwardRefVals.begin()->first +
98 "'");
99
100 if (!ForwardRefValIDs.empty())
101 return Error(ForwardRefValIDs.begin()->second.second,
102 "use of undefined value '@" +
103 utostr(ForwardRefValIDs.begin()->first) + "'");
104
105 if (!ForwardRefMDNodes.empty())
106 return Error(ForwardRefMDNodes.begin()->second.second,
107 "use of undefined metadata '!" +
108 utostr(ForwardRefMDNodes.begin()->first) + "'");
109
110
111 // Look for intrinsic functions and CallInst that need to be upgraded
112 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
113 UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
114
115 // Check debug info intrinsics.
116 CheckDebugInfoIntrinsics(M);
117 return false;
118}
119
120bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn,
121 std::vector<std::pair<ValID, GlobalValue*> > &Refs,
122 PerFunctionState *PFS) {
123 // Loop over all the references, resolving them.
124 for (unsigned i = 0, e = Refs.size(); i != e; ++i) {
125 BasicBlock *Res;
126 if (PFS) {
127 if (Refs[i].first.Kind == ValID::t_LocalName)
128 Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
129 else
130 Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc);
131 } else if (Refs[i].first.Kind == ValID::t_LocalID) {
132 return Error(Refs[i].first.Loc,
133 "cannot take address of numeric label after the function is defined");
134 } else {
135 Res = dyn_cast_or_null<BasicBlock>(
136 TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal));
137 }
138
139 if (Res == 0)
140 return Error(Refs[i].first.Loc,
141 "referenced value is not a basic block");
142
143 // Get the BlockAddress for this and update references to use it.
144 BlockAddress *BA = BlockAddress::get(TheFn, Res);
145 Refs[i].second->replaceAllUsesWith(BA);
146 Refs[i].second->eraseFromParent();
147 }
148 return false;
149}
150
151
152//===----------------------------------------------------------------------===//
153// Top-Level Entities
154//===----------------------------------------------------------------------===//
155
156bool LLParser::ParseTopLevelEntities() {
157 while (1) {
158 switch (Lex.getKind()) {
159 default: return TokError("expected top-level entity");
160 case lltok::Eof: return false;
161 //case lltok::kw_define:
162 case lltok::kw_declare: if (ParseDeclare()) return true; break;
163 case lltok::kw_define: if (ParseDefine()) return true; break;
164 case lltok::kw_module: if (ParseModuleAsm()) return true; break;
165 case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
166 case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
167 case lltok::kw_type: if (ParseUnnamedType()) return true; break;
168 case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
169 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0
170 case lltok::LocalVar: if (ParseNamedType()) return true; break;
171 case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break;
172 case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break;
| 21#include "llvm/Module.h"
22#include "llvm/Operator.h"
23#include "llvm/ValueSymbolTable.h"
24#include "llvm/ADT/SmallPtrSet.h"
25#include "llvm/ADT/StringExtras.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/raw_ostream.h"
28using namespace llvm;
29
30/// Run: module ::= toplevelentity*
31bool LLParser::Run() {
32 // Prime the lexer.
33 Lex.Lex();
34
35 return ParseTopLevelEntities() ||
36 ValidateEndOfModule();
37}
38
39/// ValidateEndOfModule - Do final validity and sanity checks at the end of the
40/// module.
41bool LLParser::ValidateEndOfModule() {
42 // Update auto-upgraded malloc calls to "malloc".
43 // FIXME: Remove in LLVM 3.0.
44 if (MallocF) {
45 MallocF->setName("malloc");
46 // If setName() does not set the name to "malloc", then there is already a
47 // declaration of "malloc". In that case, iterate over all calls to MallocF
48 // and get them to call the declared "malloc" instead.
49 if (MallocF->getName() != "malloc") {
50 Constant *RealMallocF = M->getFunction("malloc");
51 if (RealMallocF->getType() != MallocF->getType())
52 RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType());
53 MallocF->replaceAllUsesWith(RealMallocF);
54 MallocF->eraseFromParent();
55 MallocF = NULL;
56 }
57 }
58
59
60 // If there are entries in ForwardRefBlockAddresses at this point, they are
61 // references after the function was defined. Resolve those now.
62 while (!ForwardRefBlockAddresses.empty()) {
63 // Okay, we are referencing an already-parsed function, resolve them now.
64 Function *TheFn = 0;
65 const ValID &Fn = ForwardRefBlockAddresses.begin()->first;
66 if (Fn.Kind == ValID::t_GlobalName)
67 TheFn = M->getFunction(Fn.StrVal);
68 else if (Fn.UIntVal < NumberedVals.size())
69 TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]);
70
71 if (TheFn == 0)
72 return Error(Fn.Loc, "unknown function referenced by blockaddress");
73
74 // Resolve all these references.
75 if (ResolveForwardRefBlockAddresses(TheFn,
76 ForwardRefBlockAddresses.begin()->second,
77 0))
78 return true;
79
80 ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin());
81 }
82
83
84 if (!ForwardRefTypes.empty())
85 return Error(ForwardRefTypes.begin()->second.second,
86 "use of undefined type named '" +
87 ForwardRefTypes.begin()->first + "'");
88 if (!ForwardRefTypeIDs.empty())
89 return Error(ForwardRefTypeIDs.begin()->second.second,
90 "use of undefined type '%" +
91 utostr(ForwardRefTypeIDs.begin()->first) + "'");
92
93 if (!ForwardRefVals.empty())
94 return Error(ForwardRefVals.begin()->second.second,
95 "use of undefined value '@" + ForwardRefVals.begin()->first +
96 "'");
97
98 if (!ForwardRefValIDs.empty())
99 return Error(ForwardRefValIDs.begin()->second.second,
100 "use of undefined value '@" +
101 utostr(ForwardRefValIDs.begin()->first) + "'");
102
103 if (!ForwardRefMDNodes.empty())
104 return Error(ForwardRefMDNodes.begin()->second.second,
105 "use of undefined metadata '!" +
106 utostr(ForwardRefMDNodes.begin()->first) + "'");
107
108
109 // Look for intrinsic functions and CallInst that need to be upgraded
110 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
111 UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
112
113 // Check debug info intrinsics.
114 CheckDebugInfoIntrinsics(M);
115 return false;
116}
117
118bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn,
119 std::vector<std::pair<ValID, GlobalValue*> > &Refs,
120 PerFunctionState *PFS) {
121 // Loop over all the references, resolving them.
122 for (unsigned i = 0, e = Refs.size(); i != e; ++i) {
123 BasicBlock *Res;
124 if (PFS) {
125 if (Refs[i].first.Kind == ValID::t_LocalName)
126 Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
127 else
128 Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc);
129 } else if (Refs[i].first.Kind == ValID::t_LocalID) {
130 return Error(Refs[i].first.Loc,
131 "cannot take address of numeric label after the function is defined");
132 } else {
133 Res = dyn_cast_or_null<BasicBlock>(
134 TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal));
135 }
136
137 if (Res == 0)
138 return Error(Refs[i].first.Loc,
139 "referenced value is not a basic block");
140
141 // Get the BlockAddress for this and update references to use it.
142 BlockAddress *BA = BlockAddress::get(TheFn, Res);
143 Refs[i].second->replaceAllUsesWith(BA);
144 Refs[i].second->eraseFromParent();
145 }
146 return false;
147}
148
149
150//===----------------------------------------------------------------------===//
151// Top-Level Entities
152//===----------------------------------------------------------------------===//
153
154bool LLParser::ParseTopLevelEntities() {
155 while (1) {
156 switch (Lex.getKind()) {
157 default: return TokError("expected top-level entity");
158 case lltok::Eof: return false;
159 //case lltok::kw_define:
160 case lltok::kw_declare: if (ParseDeclare()) return true; break;
161 case lltok::kw_define: if (ParseDefine()) return true; break;
162 case lltok::kw_module: if (ParseModuleAsm()) return true; break;
163 case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
164 case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
165 case lltok::kw_type: if (ParseUnnamedType()) return true; break;
166 case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
167 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0
168 case lltok::LocalVar: if (ParseNamedType()) return true; break;
169 case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break;
170 case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break;
|
173 case lltok::Metadata: if (ParseStandaloneMetadata()) return true; break;
174 case lltok::NamedOrCustomMD: if (ParseNamedMetadata()) return true; break;
| 171 case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break;
172 case lltok::MetadataVar: if (ParseNamedMetadata()) return true; break;
|
175
176 // The Global variable production with no name can have many different
177 // optional leading prefixes, the production is:
178 // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
179 // OptionalAddrSpace ('constant'|'global') ...
180 case lltok::kw_private : // OptionalLinkage
181 case lltok::kw_linker_private: // OptionalLinkage
182 case lltok::kw_internal: // OptionalLinkage
183 case lltok::kw_weak: // OptionalLinkage
184 case lltok::kw_weak_odr: // OptionalLinkage
185 case lltok::kw_linkonce: // OptionalLinkage
186 case lltok::kw_linkonce_odr: // OptionalLinkage
187 case lltok::kw_appending: // OptionalLinkage
188 case lltok::kw_dllexport: // OptionalLinkage
189 case lltok::kw_common: // OptionalLinkage
190 case lltok::kw_dllimport: // OptionalLinkage
191 case lltok::kw_extern_weak: // OptionalLinkage
192 case lltok::kw_external: { // OptionalLinkage
193 unsigned Linkage, Visibility;
194 if (ParseOptionalLinkage(Linkage) ||
195 ParseOptionalVisibility(Visibility) ||
196 ParseGlobal("", SMLoc(), Linkage, true, Visibility))
197 return true;
198 break;
199 }
200 case lltok::kw_default: // OptionalVisibility
201 case lltok::kw_hidden: // OptionalVisibility
202 case lltok::kw_protected: { // OptionalVisibility
203 unsigned Visibility;
204 if (ParseOptionalVisibility(Visibility) ||
205 ParseGlobal("", SMLoc(), 0, false, Visibility))
206 return true;
207 break;
208 }
209
210 case lltok::kw_thread_local: // OptionalThreadLocal
211 case lltok::kw_addrspace: // OptionalAddrSpace
212 case lltok::kw_constant: // GlobalType
213 case lltok::kw_global: // GlobalType
214 if (ParseGlobal("", SMLoc(), 0, false, 0)) return true;
215 break;
216 }
217 }
218}
219
220
221/// toplevelentity
222/// ::= 'module' 'asm' STRINGCONSTANT
223bool LLParser::ParseModuleAsm() {
224 assert(Lex.getKind() == lltok::kw_module);
225 Lex.Lex();
226
227 std::string AsmStr;
228 if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
229 ParseStringConstant(AsmStr)) return true;
230
231 const std::string &AsmSoFar = M->getModuleInlineAsm();
232 if (AsmSoFar.empty())
233 M->setModuleInlineAsm(AsmStr);
234 else
235 M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr);
236 return false;
237}
238
239/// toplevelentity
240/// ::= 'target' 'triple' '=' STRINGCONSTANT
241/// ::= 'target' 'datalayout' '=' STRINGCONSTANT
242bool LLParser::ParseTargetDefinition() {
243 assert(Lex.getKind() == lltok::kw_target);
244 std::string Str;
245 switch (Lex.Lex()) {
246 default: return TokError("unknown target property");
247 case lltok::kw_triple:
248 Lex.Lex();
249 if (ParseToken(lltok::equal, "expected '=' after target triple") ||
250 ParseStringConstant(Str))
251 return true;
252 M->setTargetTriple(Str);
253 return false;
254 case lltok::kw_datalayout:
255 Lex.Lex();
256 if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
257 ParseStringConstant(Str))
258 return true;
259 M->setDataLayout(Str);
260 return false;
261 }
262}
263
264/// toplevelentity
265/// ::= 'deplibs' '=' '[' ']'
266/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
267bool LLParser::ParseDepLibs() {
268 assert(Lex.getKind() == lltok::kw_deplibs);
269 Lex.Lex();
270 if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
271 ParseToken(lltok::lsquare, "expected '=' after deplibs"))
272 return true;
273
274 if (EatIfPresent(lltok::rsquare))
275 return false;
276
277 std::string Str;
278 if (ParseStringConstant(Str)) return true;
279 M->addLibrary(Str);
280
281 while (EatIfPresent(lltok::comma)) {
282 if (ParseStringConstant(Str)) return true;
283 M->addLibrary(Str);
284 }
285
286 return ParseToken(lltok::rsquare, "expected ']' at end of list");
287}
288
289/// ParseUnnamedType:
290/// ::= 'type' type
291/// ::= LocalVarID '=' 'type' type
292bool LLParser::ParseUnnamedType() {
293 unsigned TypeID = NumberedTypes.size();
294
295 // Handle the LocalVarID form.
296 if (Lex.getKind() == lltok::LocalVarID) {
297 if (Lex.getUIntVal() != TypeID)
298 return Error(Lex.getLoc(), "type expected to be numbered '%" +
299 utostr(TypeID) + "'");
300 Lex.Lex(); // eat LocalVarID;
301
302 if (ParseToken(lltok::equal, "expected '=' after name"))
303 return true;
304 }
305
306 assert(Lex.getKind() == lltok::kw_type);
307 LocTy TypeLoc = Lex.getLoc();
308 Lex.Lex(); // eat kw_type
309
310 PATypeHolder Ty(Type::getVoidTy(Context));
311 if (ParseType(Ty)) return true;
312
313 // See if this type was previously referenced.
314 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
315 FI = ForwardRefTypeIDs.find(TypeID);
316 if (FI != ForwardRefTypeIDs.end()) {
317 if (FI->second.first.get() == Ty)
318 return Error(TypeLoc, "self referential type is invalid");
319
320 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
321 Ty = FI->second.first.get();
322 ForwardRefTypeIDs.erase(FI);
323 }
324
325 NumberedTypes.push_back(Ty);
326
327 return false;
328}
329
330/// toplevelentity
331/// ::= LocalVar '=' 'type' type
332bool LLParser::ParseNamedType() {
333 std::string Name = Lex.getStrVal();
334 LocTy NameLoc = Lex.getLoc();
335 Lex.Lex(); // eat LocalVar.
336
337 PATypeHolder Ty(Type::getVoidTy(Context));
338
339 if (ParseToken(lltok::equal, "expected '=' after name") ||
340 ParseToken(lltok::kw_type, "expected 'type' after name") ||
341 ParseType(Ty))
342 return true;
343
344 // Set the type name, checking for conflicts as we do so.
345 bool AlreadyExists = M->addTypeName(Name, Ty);
346 if (!AlreadyExists) return false;
347
348 // See if this type is a forward reference. We need to eagerly resolve
349 // types to allow recursive type redefinitions below.
350 std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator
351 FI = ForwardRefTypes.find(Name);
352 if (FI != ForwardRefTypes.end()) {
353 if (FI->second.first.get() == Ty)
354 return Error(NameLoc, "self referential type is invalid");
355
356 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
357 Ty = FI->second.first.get();
358 ForwardRefTypes.erase(FI);
359 }
360
361 // Inserting a name that is already defined, get the existing name.
362 const Type *Existing = M->getTypeByName(Name);
363 assert(Existing && "Conflict but no matching type?!");
364
365 // Otherwise, this is an attempt to redefine a type. That's okay if
366 // the redefinition is identical to the original.
367 // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0
368 if (Existing == Ty) return false;
369
370 // Any other kind of (non-equivalent) redefinition is an error.
371 return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" +
372 Ty->getDescription() + "'");
373}
374
375
376/// toplevelentity
377/// ::= 'declare' FunctionHeader
378bool LLParser::ParseDeclare() {
379 assert(Lex.getKind() == lltok::kw_declare);
380 Lex.Lex();
381
382 Function *F;
383 return ParseFunctionHeader(F, false);
384}
385
386/// toplevelentity
387/// ::= 'define' FunctionHeader '{' ...
388bool LLParser::ParseDefine() {
389 assert(Lex.getKind() == lltok::kw_define);
390 Lex.Lex();
391
392 Function *F;
393 return ParseFunctionHeader(F, true) ||
394 ParseFunctionBody(*F);
395}
396
397/// ParseGlobalType
398/// ::= 'constant'
399/// ::= 'global'
400bool LLParser::ParseGlobalType(bool &IsConstant) {
401 if (Lex.getKind() == lltok::kw_constant)
402 IsConstant = true;
403 else if (Lex.getKind() == lltok::kw_global)
404 IsConstant = false;
405 else {
406 IsConstant = false;
407 return TokError("expected 'global' or 'constant'");
408 }
409 Lex.Lex();
410 return false;
411}
412
413/// ParseUnnamedGlobal:
414/// OptionalVisibility ALIAS ...
415/// OptionalLinkage OptionalVisibility ... -> global variable
416/// GlobalID '=' OptionalVisibility ALIAS ...
417/// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable
418bool LLParser::ParseUnnamedGlobal() {
419 unsigned VarID = NumberedVals.size();
420 std::string Name;
421 LocTy NameLoc = Lex.getLoc();
422
423 // Handle the GlobalID form.
424 if (Lex.getKind() == lltok::GlobalID) {
425 if (Lex.getUIntVal() != VarID)
426 return Error(Lex.getLoc(), "variable expected to be numbered '%" +
427 utostr(VarID) + "'");
428 Lex.Lex(); // eat GlobalID;
429
430 if (ParseToken(lltok::equal, "expected '=' after name"))
431 return true;
432 }
433
434 bool HasLinkage;
435 unsigned Linkage, Visibility;
436 if (ParseOptionalLinkage(Linkage, HasLinkage) ||
437 ParseOptionalVisibility(Visibility))
438 return true;
439
440 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
441 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
442 return ParseAlias(Name, NameLoc, Visibility);
443}
444
445/// ParseNamedGlobal:
446/// GlobalVar '=' OptionalVisibility ALIAS ...
447/// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable
448bool LLParser::ParseNamedGlobal() {
449 assert(Lex.getKind() == lltok::GlobalVar);
450 LocTy NameLoc = Lex.getLoc();
451 std::string Name = Lex.getStrVal();
452 Lex.Lex();
453
454 bool HasLinkage;
455 unsigned Linkage, Visibility;
456 if (ParseToken(lltok::equal, "expected '=' in global variable") ||
457 ParseOptionalLinkage(Linkage, HasLinkage) ||
458 ParseOptionalVisibility(Visibility))
459 return true;
460
461 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
462 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
463 return ParseAlias(Name, NameLoc, Visibility);
464}
465
466// MDString:
467// ::= '!' STRINGCONSTANT
| 173
174 // The Global variable production with no name can have many different
175 // optional leading prefixes, the production is:
176 // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
177 // OptionalAddrSpace ('constant'|'global') ...
178 case lltok::kw_private : // OptionalLinkage
179 case lltok::kw_linker_private: // OptionalLinkage
180 case lltok::kw_internal: // OptionalLinkage
181 case lltok::kw_weak: // OptionalLinkage
182 case lltok::kw_weak_odr: // OptionalLinkage
183 case lltok::kw_linkonce: // OptionalLinkage
184 case lltok::kw_linkonce_odr: // OptionalLinkage
185 case lltok::kw_appending: // OptionalLinkage
186 case lltok::kw_dllexport: // OptionalLinkage
187 case lltok::kw_common: // OptionalLinkage
188 case lltok::kw_dllimport: // OptionalLinkage
189 case lltok::kw_extern_weak: // OptionalLinkage
190 case lltok::kw_external: { // OptionalLinkage
191 unsigned Linkage, Visibility;
192 if (ParseOptionalLinkage(Linkage) ||
193 ParseOptionalVisibility(Visibility) ||
194 ParseGlobal("", SMLoc(), Linkage, true, Visibility))
195 return true;
196 break;
197 }
198 case lltok::kw_default: // OptionalVisibility
199 case lltok::kw_hidden: // OptionalVisibility
200 case lltok::kw_protected: { // OptionalVisibility
201 unsigned Visibility;
202 if (ParseOptionalVisibility(Visibility) ||
203 ParseGlobal("", SMLoc(), 0, false, Visibility))
204 return true;
205 break;
206 }
207
208 case lltok::kw_thread_local: // OptionalThreadLocal
209 case lltok::kw_addrspace: // OptionalAddrSpace
210 case lltok::kw_constant: // GlobalType
211 case lltok::kw_global: // GlobalType
212 if (ParseGlobal("", SMLoc(), 0, false, 0)) return true;
213 break;
214 }
215 }
216}
217
218
219/// toplevelentity
220/// ::= 'module' 'asm' STRINGCONSTANT
221bool LLParser::ParseModuleAsm() {
222 assert(Lex.getKind() == lltok::kw_module);
223 Lex.Lex();
224
225 std::string AsmStr;
226 if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
227 ParseStringConstant(AsmStr)) return true;
228
229 const std::string &AsmSoFar = M->getModuleInlineAsm();
230 if (AsmSoFar.empty())
231 M->setModuleInlineAsm(AsmStr);
232 else
233 M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr);
234 return false;
235}
236
237/// toplevelentity
238/// ::= 'target' 'triple' '=' STRINGCONSTANT
239/// ::= 'target' 'datalayout' '=' STRINGCONSTANT
240bool LLParser::ParseTargetDefinition() {
241 assert(Lex.getKind() == lltok::kw_target);
242 std::string Str;
243 switch (Lex.Lex()) {
244 default: return TokError("unknown target property");
245 case lltok::kw_triple:
246 Lex.Lex();
247 if (ParseToken(lltok::equal, "expected '=' after target triple") ||
248 ParseStringConstant(Str))
249 return true;
250 M->setTargetTriple(Str);
251 return false;
252 case lltok::kw_datalayout:
253 Lex.Lex();
254 if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
255 ParseStringConstant(Str))
256 return true;
257 M->setDataLayout(Str);
258 return false;
259 }
260}
261
262/// toplevelentity
263/// ::= 'deplibs' '=' '[' ']'
264/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
265bool LLParser::ParseDepLibs() {
266 assert(Lex.getKind() == lltok::kw_deplibs);
267 Lex.Lex();
268 if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
269 ParseToken(lltok::lsquare, "expected '=' after deplibs"))
270 return true;
271
272 if (EatIfPresent(lltok::rsquare))
273 return false;
274
275 std::string Str;
276 if (ParseStringConstant(Str)) return true;
277 M->addLibrary(Str);
278
279 while (EatIfPresent(lltok::comma)) {
280 if (ParseStringConstant(Str)) return true;
281 M->addLibrary(Str);
282 }
283
284 return ParseToken(lltok::rsquare, "expected ']' at end of list");
285}
286
287/// ParseUnnamedType:
288/// ::= 'type' type
289/// ::= LocalVarID '=' 'type' type
290bool LLParser::ParseUnnamedType() {
291 unsigned TypeID = NumberedTypes.size();
292
293 // Handle the LocalVarID form.
294 if (Lex.getKind() == lltok::LocalVarID) {
295 if (Lex.getUIntVal() != TypeID)
296 return Error(Lex.getLoc(), "type expected to be numbered '%" +
297 utostr(TypeID) + "'");
298 Lex.Lex(); // eat LocalVarID;
299
300 if (ParseToken(lltok::equal, "expected '=' after name"))
301 return true;
302 }
303
304 assert(Lex.getKind() == lltok::kw_type);
305 LocTy TypeLoc = Lex.getLoc();
306 Lex.Lex(); // eat kw_type
307
308 PATypeHolder Ty(Type::getVoidTy(Context));
309 if (ParseType(Ty)) return true;
310
311 // See if this type was previously referenced.
312 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
313 FI = ForwardRefTypeIDs.find(TypeID);
314 if (FI != ForwardRefTypeIDs.end()) {
315 if (FI->second.first.get() == Ty)
316 return Error(TypeLoc, "self referential type is invalid");
317
318 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
319 Ty = FI->second.first.get();
320 ForwardRefTypeIDs.erase(FI);
321 }
322
323 NumberedTypes.push_back(Ty);
324
325 return false;
326}
327
328/// toplevelentity
329/// ::= LocalVar '=' 'type' type
330bool LLParser::ParseNamedType() {
331 std::string Name = Lex.getStrVal();
332 LocTy NameLoc = Lex.getLoc();
333 Lex.Lex(); // eat LocalVar.
334
335 PATypeHolder Ty(Type::getVoidTy(Context));
336
337 if (ParseToken(lltok::equal, "expected '=' after name") ||
338 ParseToken(lltok::kw_type, "expected 'type' after name") ||
339 ParseType(Ty))
340 return true;
341
342 // Set the type name, checking for conflicts as we do so.
343 bool AlreadyExists = M->addTypeName(Name, Ty);
344 if (!AlreadyExists) return false;
345
346 // See if this type is a forward reference. We need to eagerly resolve
347 // types to allow recursive type redefinitions below.
348 std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator
349 FI = ForwardRefTypes.find(Name);
350 if (FI != ForwardRefTypes.end()) {
351 if (FI->second.first.get() == Ty)
352 return Error(NameLoc, "self referential type is invalid");
353
354 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
355 Ty = FI->second.first.get();
356 ForwardRefTypes.erase(FI);
357 }
358
359 // Inserting a name that is already defined, get the existing name.
360 const Type *Existing = M->getTypeByName(Name);
361 assert(Existing && "Conflict but no matching type?!");
362
363 // Otherwise, this is an attempt to redefine a type. That's okay if
364 // the redefinition is identical to the original.
365 // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0
366 if (Existing == Ty) return false;
367
368 // Any other kind of (non-equivalent) redefinition is an error.
369 return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" +
370 Ty->getDescription() + "'");
371}
372
373
374/// toplevelentity
375/// ::= 'declare' FunctionHeader
376bool LLParser::ParseDeclare() {
377 assert(Lex.getKind() == lltok::kw_declare);
378 Lex.Lex();
379
380 Function *F;
381 return ParseFunctionHeader(F, false);
382}
383
384/// toplevelentity
385/// ::= 'define' FunctionHeader '{' ...
386bool LLParser::ParseDefine() {
387 assert(Lex.getKind() == lltok::kw_define);
388 Lex.Lex();
389
390 Function *F;
391 return ParseFunctionHeader(F, true) ||
392 ParseFunctionBody(*F);
393}
394
395/// ParseGlobalType
396/// ::= 'constant'
397/// ::= 'global'
398bool LLParser::ParseGlobalType(bool &IsConstant) {
399 if (Lex.getKind() == lltok::kw_constant)
400 IsConstant = true;
401 else if (Lex.getKind() == lltok::kw_global)
402 IsConstant = false;
403 else {
404 IsConstant = false;
405 return TokError("expected 'global' or 'constant'");
406 }
407 Lex.Lex();
408 return false;
409}
410
411/// ParseUnnamedGlobal:
412/// OptionalVisibility ALIAS ...
413/// OptionalLinkage OptionalVisibility ... -> global variable
414/// GlobalID '=' OptionalVisibility ALIAS ...
415/// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable
416bool LLParser::ParseUnnamedGlobal() {
417 unsigned VarID = NumberedVals.size();
418 std::string Name;
419 LocTy NameLoc = Lex.getLoc();
420
421 // Handle the GlobalID form.
422 if (Lex.getKind() == lltok::GlobalID) {
423 if (Lex.getUIntVal() != VarID)
424 return Error(Lex.getLoc(), "variable expected to be numbered '%" +
425 utostr(VarID) + "'");
426 Lex.Lex(); // eat GlobalID;
427
428 if (ParseToken(lltok::equal, "expected '=' after name"))
429 return true;
430 }
431
432 bool HasLinkage;
433 unsigned Linkage, Visibility;
434 if (ParseOptionalLinkage(Linkage, HasLinkage) ||
435 ParseOptionalVisibility(Visibility))
436 return true;
437
438 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
439 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
440 return ParseAlias(Name, NameLoc, Visibility);
441}
442
443/// ParseNamedGlobal:
444/// GlobalVar '=' OptionalVisibility ALIAS ...
445/// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable
446bool LLParser::ParseNamedGlobal() {
447 assert(Lex.getKind() == lltok::GlobalVar);
448 LocTy NameLoc = Lex.getLoc();
449 std::string Name = Lex.getStrVal();
450 Lex.Lex();
451
452 bool HasLinkage;
453 unsigned Linkage, Visibility;
454 if (ParseToken(lltok::equal, "expected '=' in global variable") ||
455 ParseOptionalLinkage(Linkage, HasLinkage) ||
456 ParseOptionalVisibility(Visibility))
457 return true;
458
459 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
460 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
461 return ParseAlias(Name, NameLoc, Visibility);
462}
463
464// MDString:
465// ::= '!' STRINGCONSTANT
|
468bool LLParser::ParseMDString(MetadataBase *&MDS) {
| 466bool LLParser::ParseMDString(MDString *&Result) {
|
469 std::string Str;
470 if (ParseStringConstant(Str)) return true;
| 467 std::string Str;
468 if (ParseStringConstant(Str)) return true;
|
471 MDS = MDString::get(Context, Str);
| 469 Result = MDString::get(Context, Str);
|
472 return false;
473}
474
475// MDNode:
476// ::= '!' MDNodeNumber
| 470 return false;
471}
472
473// MDNode:
474// ::= '!' MDNodeNumber
|
477bool LLParser::ParseMDNode(MetadataBase *&Node) {
| 475bool LLParser::ParseMDNodeID(MDNode *&Result) {
|
478 // !{ ..., !42, ... }
479 unsigned MID = 0;
| 476 // !{ ..., !42, ... }
477 unsigned MID = 0;
|
480 if (ParseUInt32(MID)) return true;
| 478 if (ParseUInt32(MID)) return true;
|
481
482 // Check existing MDNode.
| 479
480 // Check existing MDNode.
|
483 std::map<unsigned, WeakVH>::iterator I = MetadataCache.find(MID);
484 if (I != MetadataCache.end()) {
485 Node = cast<MetadataBase>(I->second);
| 481 if (MID < NumberedMetadata.size() && NumberedMetadata[MID] != 0) {
482 Result = NumberedMetadata[MID];
|
486 return false;
487 }
488
| 483 return false;
484 }
485
|
489 // Check known forward references.
490 std::map<unsigned, std::pair<WeakVH, LocTy> >::iterator
491 FI = ForwardRefMDNodes.find(MID);
492 if (FI != ForwardRefMDNodes.end()) {
493 Node = cast<MetadataBase>(FI->second.first);
494 return false;
495 }
| 486 // Create MDNode forward reference.
|
496
| 487
|
497 // Create MDNode forward reference
498 SmallVector<Value *, 1> Elts;
| 488 // FIXME: This is not unique enough!
|
499 std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID);
| 489 std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID);
|
500 Elts.push_back(MDString::get(Context, FwdRefName));
501 MDNode *FwdNode = MDNode::get(Context, Elts.data(), Elts.size());
| 490 Value *V = MDString::get(Context, FwdRefName);
491 MDNode *FwdNode = MDNode::get(Context, &V, 1);
|
502 ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc());
| 492 ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc());
|
503 Node = FwdNode;
| 493
494 if (NumberedMetadata.size() <= MID)
495 NumberedMetadata.resize(MID+1);
496 NumberedMetadata[MID] = FwdNode;
497 Result = FwdNode;
|
504 return false;
505}
506
| 498 return false;
499}
500
|
507///ParseNamedMetadata:
| 501/// ParseNamedMetadata:
|
508/// !foo = !{ !1, !2 }
509bool LLParser::ParseNamedMetadata() {
| 502/// !foo = !{ !1, !2 }
503bool LLParser::ParseNamedMetadata() {
|
510 assert(Lex.getKind() == lltok::NamedOrCustomMD);
511 Lex.Lex();
| 504 assert(Lex.getKind() == lltok::MetadataVar);
|
512 std::string Name = Lex.getStrVal();
| 505 std::string Name = Lex.getStrVal();
|
| 506 Lex.Lex();
|
513
| 507
|
514 if (ParseToken(lltok::equal, "expected '=' here"))
| 508 if (ParseToken(lltok::equal, "expected '=' here") ||
509 ParseToken(lltok::exclaim, "Expected '!' here") ||
510 ParseToken(lltok::lbrace, "Expected '{' here"))
|
515 return true;
516
| 511 return true;
512
|
517 if (Lex.getKind() != lltok::Metadata)
518 return TokError("Expected '!' here");
519 Lex.Lex();
520
521 if (Lex.getKind() != lltok::lbrace)
522 return TokError("Expected '{' here");
523 Lex.Lex();
| |
524 SmallVector<MetadataBase *, 8> Elts;
525 do {
| 513 SmallVector<MetadataBase *, 8> Elts;
514 do {
|
526 if (Lex.getKind() != lltok::Metadata)
527 return TokError("Expected '!' here");
528 Lex.Lex();
529 MetadataBase *N = 0;
530 if (ParseMDNode(N)) return true;
| 515 if (ParseToken(lltok::exclaim, "Expected '!' here"))
516 return true;
517
518 // FIXME: This rejects MDStrings. Are they legal in an named MDNode or not?
519 MDNode *N = 0;
520 if (ParseMDNodeID(N)) return true;
|
531 Elts.push_back(N);
532 } while (EatIfPresent(lltok::comma));
533
534 if (ParseToken(lltok::rbrace, "expected end of metadata node"))
535 return true;
536
537 NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M);
538 return false;
539}
540
541/// ParseStandaloneMetadata:
542/// !42 = !{...}
543bool LLParser::ParseStandaloneMetadata() {
| 521 Elts.push_back(N);
522 } while (EatIfPresent(lltok::comma));
523
524 if (ParseToken(lltok::rbrace, "expected end of metadata node"))
525 return true;
526
527 NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M);
528 return false;
529}
530
531/// ParseStandaloneMetadata:
532/// !42 = !{...}
533bool LLParser::ParseStandaloneMetadata() {
|
544 assert(Lex.getKind() == lltok::Metadata);
| 534 assert(Lex.getKind() == lltok::exclaim);
|
545 Lex.Lex();
546 unsigned MetadataID = 0;
| 535 Lex.Lex();
536 unsigned MetadataID = 0;
|
547 if (ParseUInt32(MetadataID))
548 return true;
549 if (MetadataCache.find(MetadataID) != MetadataCache.end())
550 return TokError("Metadata id is already used");
551 if (ParseToken(lltok::equal, "expected '=' here"))
552 return true;
| |
553
554 LocTy TyLoc;
555 PATypeHolder Ty(Type::getVoidTy(Context));
| 537
538 LocTy TyLoc;
539 PATypeHolder Ty(Type::getVoidTy(Context));
|
556 if (ParseType(Ty, TyLoc))
557 return true;
558
559 if (Lex.getKind() != lltok::Metadata)
560 return TokError("Expected metadata here");
561
562 Lex.Lex();
563 if (Lex.getKind() != lltok::lbrace)
564 return TokError("Expected '{' here");
565
| |
566 SmallVector<Value *, 16> Elts;
| 540 SmallVector<Value *, 16> Elts;
|
567 if (ParseMDNodeVector(Elts)
568 || ParseToken(lltok::rbrace, "expected end of metadata node"))
| 541 if (ParseUInt32(MetadataID) ||
542 ParseToken(lltok::equal, "expected '=' here") ||
543 ParseType(Ty, TyLoc) ||
544 ParseToken(lltok::exclaim, "Expected '!' here") ||
545 ParseToken(lltok::lbrace, "Expected '{' here") ||
546 ParseMDNodeVector(Elts) ||
547 ParseToken(lltok::rbrace, "expected end of metadata node"))
|
569 return true;
570
571 MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size());
| 548 return true;
549
550 MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size());
|
572 MetadataCache[MetadataID] = Init;
573 std::map<unsigned, std::pair<WeakVH, LocTy> >::iterator
| 551
552 // See if this was forward referenced, if so, handle it.
553 std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> >::iterator
|
574 FI = ForwardRefMDNodes.find(MetadataID);
575 if (FI != ForwardRefMDNodes.end()) {
| 554 FI = ForwardRefMDNodes.find(MetadataID);
555 if (FI != ForwardRefMDNodes.end()) {
|
576 MDNode *FwdNode = cast<MDNode>(FI->second.first);
577 FwdNode->replaceAllUsesWith(Init);
| 556 FI->second.first->replaceAllUsesWith(Init);
|
578 ForwardRefMDNodes.erase(FI);
| 557 ForwardRefMDNodes.erase(FI);
|
579 }
| 558
559 assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
560 } else {
561 if (MetadataID >= NumberedMetadata.size())
562 NumberedMetadata.resize(MetadataID+1);
|
580
| 563
|
581 return false;
582}
583
584/// ParseInlineMetadata:
585/// !{type %instr}
586/// !{...} MDNode
587/// !"foo" MDString
588bool LLParser::ParseInlineMetadata(Value *&V, PerFunctionState &PFS) {
589 assert(Lex.getKind() == lltok::Metadata && "Only for Metadata");
590 V = 0;
591
592 Lex.Lex();
593 if (Lex.getKind() == lltok::lbrace) {
594 Lex.Lex();
595 if (ParseTypeAndValue(V, PFS) ||
596 ParseToken(lltok::rbrace, "expected end of metadata node"))
597 return true;
598
599 Value *Vals[] = { V };
600 V = MDNode::get(Context, Vals, 1);
601 return false;
| 564 if (NumberedMetadata[MetadataID] != 0)
565 return TokError("Metadata id is already used");
566 NumberedMetadata[MetadataID] = Init;
|
602 }
603
| 567 }
568
|
604 // Standalone metadata reference
605 // !{ ..., !42, ... }
606 if (!ParseMDNode((MetadataBase *&)V))
607 return false;
608
609 // MDString:
610 // '!' STRINGCONSTANT
611 if (ParseMDString((MetadataBase *&)V)) return true;
| |
612 return false;
613}
614
615/// ParseAlias:
616/// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee
617/// Aliasee
618/// ::= TypeAndValue
619/// ::= 'bitcast' '(' TypeAndValue 'to' Type ')'
620/// ::= 'getelementptr' 'inbounds'? '(' ... ')'
621///
622/// Everything through visibility has already been parsed.
623///
624bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc,
625 unsigned Visibility) {
626 assert(Lex.getKind() == lltok::kw_alias);
627 Lex.Lex();
628 unsigned Linkage;
629 LocTy LinkageLoc = Lex.getLoc();
630 if (ParseOptionalLinkage(Linkage))
631 return true;
632
633 if (Linkage != GlobalValue::ExternalLinkage &&
634 Linkage != GlobalValue::WeakAnyLinkage &&
635 Linkage != GlobalValue::WeakODRLinkage &&
636 Linkage != GlobalValue::InternalLinkage &&
637 Linkage != GlobalValue::PrivateLinkage &&
638 Linkage != GlobalValue::LinkerPrivateLinkage)
639 return Error(LinkageLoc, "invalid linkage type for alias");
640
641 Constant *Aliasee;
642 LocTy AliaseeLoc = Lex.getLoc();
643 if (Lex.getKind() != lltok::kw_bitcast &&
644 Lex.getKind() != lltok::kw_getelementptr) {
645 if (ParseGlobalTypeAndValue(Aliasee)) return true;
646 } else {
647 // The bitcast dest type is not present, it is implied by the dest type.
648 ValID ID;
649 if (ParseValID(ID)) return true;
650 if (ID.Kind != ValID::t_Constant)
651 return Error(AliaseeLoc, "invalid aliasee");
652 Aliasee = ID.ConstantVal;
653 }
654
655 if (!isa<PointerType>(Aliasee->getType()))
656 return Error(AliaseeLoc, "alias must have pointer type");
657
658 // Okay, create the alias but do not insert it into the module yet.
659 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(),
660 (GlobalValue::LinkageTypes)Linkage, Name,
661 Aliasee);
662 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
663
664 // See if this value already exists in the symbol table. If so, it is either
665 // a redefinition or a definition of a forward reference.
666 if (GlobalValue *Val = M->getNamedValue(Name)) {
667 // See if this was a redefinition. If so, there is no entry in
668 // ForwardRefVals.
669 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
670 I = ForwardRefVals.find(Name);
671 if (I == ForwardRefVals.end())
672 return Error(NameLoc, "redefinition of global named '@" + Name + "'");
673
674 // Otherwise, this was a definition of forward ref. Verify that types
675 // agree.
676 if (Val->getType() != GA->getType())
677 return Error(NameLoc,
678 "forward reference and definition of alias have different types");
679
680 // If they agree, just RAUW the old value with the alias and remove the
681 // forward ref info.
682 Val->replaceAllUsesWith(GA);
683 Val->eraseFromParent();
684 ForwardRefVals.erase(I);
685 }
686
687 // Insert into the module, we know its name won't collide now.
688 M->getAliasList().push_back(GA);
689 assert(GA->getNameStr() == Name && "Should not be a name conflict!");
690
691 return false;
692}
693
694/// ParseGlobal
695/// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal
696/// OptionalAddrSpace GlobalType Type Const
697/// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
698/// OptionalAddrSpace GlobalType Type Const
699///
700/// Everything through visibility has been parsed already.
701///
702bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
703 unsigned Linkage, bool HasLinkage,
704 unsigned Visibility) {
705 unsigned AddrSpace;
706 bool ThreadLocal, IsConstant;
707 LocTy TyLoc;
708
709 PATypeHolder Ty(Type::getVoidTy(Context));
710 if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) ||
711 ParseOptionalAddrSpace(AddrSpace) ||
712 ParseGlobalType(IsConstant) ||
713 ParseType(Ty, TyLoc))
714 return true;
715
716 // If the linkage is specified and is external, then no initializer is
717 // present.
718 Constant *Init = 0;
719 if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage &&
720 Linkage != GlobalValue::ExternalWeakLinkage &&
721 Linkage != GlobalValue::ExternalLinkage)) {
722 if (ParseGlobalValue(Ty, Init))
723 return true;
724 }
725
726 if (isa<FunctionType>(Ty) || Ty->isLabelTy())
727 return Error(TyLoc, "invalid type for global variable");
728
729 GlobalVariable *GV = 0;
730
731 // See if the global was forward referenced, if so, use the global.
732 if (!Name.empty()) {
733 if (GlobalValue *GVal = M->getNamedValue(Name)) {
734 if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
735 return Error(NameLoc, "redefinition of global '@" + Name + "'");
736 GV = cast<GlobalVariable>(GVal);
737 }
738 } else {
739 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
740 I = ForwardRefValIDs.find(NumberedVals.size());
741 if (I != ForwardRefValIDs.end()) {
742 GV = cast<GlobalVariable>(I->second.first);
743 ForwardRefValIDs.erase(I);
744 }
745 }
746
747 if (GV == 0) {
748 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0,
749 Name, 0, false, AddrSpace);
750 } else {
751 if (GV->getType()->getElementType() != Ty)
752 return Error(TyLoc,
753 "forward reference and definition of global have different types");
754
755 // Move the forward-reference to the correct spot in the module.
756 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
757 }
758
759 if (Name.empty())
760 NumberedVals.push_back(GV);
761
762 // Set the parsed properties on the global.
763 if (Init)
764 GV->setInitializer(Init);
765 GV->setConstant(IsConstant);
766 GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
767 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
768 GV->setThreadLocal(ThreadLocal);
769
770 // Parse attributes on the global.
771 while (Lex.getKind() == lltok::comma) {
772 Lex.Lex();
773
774 if (Lex.getKind() == lltok::kw_section) {
775 Lex.Lex();
776 GV->setSection(Lex.getStrVal());
777 if (ParseToken(lltok::StringConstant, "expected global section string"))
778 return true;
779 } else if (Lex.getKind() == lltok::kw_align) {
780 unsigned Alignment;
781 if (ParseOptionalAlignment(Alignment)) return true;
782 GV->setAlignment(Alignment);
783 } else {
784 TokError("unknown global variable property!");
785 }
786 }
787
788 return false;
789}
790
791
792//===----------------------------------------------------------------------===//
793// GlobalValue Reference/Resolution Routines.
794//===----------------------------------------------------------------------===//
795
796/// GetGlobalVal - Get a value with the specified name or ID, creating a
797/// forward reference record if needed. This can return null if the value
798/// exists but does not have the right type.
799GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty,
800 LocTy Loc) {
801 const PointerType *PTy = dyn_cast<PointerType>(Ty);
802 if (PTy == 0) {
803 Error(Loc, "global variable reference must have pointer type");
804 return 0;
805 }
806
807 // Look this name up in the normal function symbol table.
808 GlobalValue *Val =
809 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
810
811 // If this is a forward reference for the value, see if we already created a
812 // forward ref record.
813 if (Val == 0) {
814 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
815 I = ForwardRefVals.find(Name);
816 if (I != ForwardRefVals.end())
817 Val = I->second.first;
818 }
819
820 // If we have the value in the symbol table or fwd-ref table, return it.
821 if (Val) {
822 if (Val->getType() == Ty) return Val;
823 Error(Loc, "'@" + Name + "' defined with type '" +
824 Val->getType()->getDescription() + "'");
825 return 0;
826 }
827
828 // Otherwise, create a new forward reference for this value and remember it.
829 GlobalValue *FwdVal;
830 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
831 // Function types can return opaque but functions can't.
832 if (isa<OpaqueType>(FT->getReturnType())) {
833 Error(Loc, "function may not return opaque type");
834 return 0;
835 }
836
837 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
838 } else {
839 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
840 GlobalValue::ExternalWeakLinkage, 0, Name);
841 }
842
843 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
844 return FwdVal;
845}
846
847GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) {
848 const PointerType *PTy = dyn_cast<PointerType>(Ty);
849 if (PTy == 0) {
850 Error(Loc, "global variable reference must have pointer type");
851 return 0;
852 }
853
854 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
855
856 // If this is a forward reference for the value, see if we already created a
857 // forward ref record.
858 if (Val == 0) {
859 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
860 I = ForwardRefValIDs.find(ID);
861 if (I != ForwardRefValIDs.end())
862 Val = I->second.first;
863 }
864
865 // If we have the value in the symbol table or fwd-ref table, return it.
866 if (Val) {
867 if (Val->getType() == Ty) return Val;
868 Error(Loc, "'@" + utostr(ID) + "' defined with type '" +
869 Val->getType()->getDescription() + "'");
870 return 0;
871 }
872
873 // Otherwise, create a new forward reference for this value and remember it.
874 GlobalValue *FwdVal;
875 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
876 // Function types can return opaque but functions can't.
877 if (isa<OpaqueType>(FT->getReturnType())) {
878 Error(Loc, "function may not return opaque type");
879 return 0;
880 }
881 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
882 } else {
883 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
884 GlobalValue::ExternalWeakLinkage, 0, "");
885 }
886
887 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
888 return FwdVal;
889}
890
891
892//===----------------------------------------------------------------------===//
893// Helper Routines.
894//===----------------------------------------------------------------------===//
895
896/// ParseToken - If the current token has the specified kind, eat it and return
897/// success. Otherwise, emit the specified error and return failure.
898bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
899 if (Lex.getKind() != T)
900 return TokError(ErrMsg);
901 Lex.Lex();
902 return false;
903}
904
905/// ParseStringConstant
906/// ::= StringConstant
907bool LLParser::ParseStringConstant(std::string &Result) {
908 if (Lex.getKind() != lltok::StringConstant)
909 return TokError("expected string constant");
910 Result = Lex.getStrVal();
911 Lex.Lex();
912 return false;
913}
914
915/// ParseUInt32
916/// ::= uint32
917bool LLParser::ParseUInt32(unsigned &Val) {
918 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
919 return TokError("expected integer");
920 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
921 if (Val64 != unsigned(Val64))
922 return TokError("expected 32-bit integer (too large)");
923 Val = Val64;
924 Lex.Lex();
925 return false;
926}
927
928
929/// ParseOptionalAddrSpace
930/// := /*empty*/
931/// := 'addrspace' '(' uint32 ')'
932bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
933 AddrSpace = 0;
934 if (!EatIfPresent(lltok::kw_addrspace))
935 return false;
936 return ParseToken(lltok::lparen, "expected '(' in address space") ||
937 ParseUInt32(AddrSpace) ||
938 ParseToken(lltok::rparen, "expected ')' in address space");
939}
940
941/// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind
942/// indicates what kind of attribute list this is: 0: function arg, 1: result,
943/// 2: function attr.
944/// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0
945bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) {
946 Attrs = Attribute::None;
947 LocTy AttrLoc = Lex.getLoc();
948
949 while (1) {
950 switch (Lex.getKind()) {
951 case lltok::kw_sext:
952 case lltok::kw_zext:
953 // Treat these as signext/zeroext if they occur in the argument list after
954 // the value, as in "call i8 @foo(i8 10 sext)". If they occur before the
955 // value, as in "call i8 @foo(i8 sext (" then it is part of a constant
956 // expr.
957 // FIXME: REMOVE THIS IN LLVM 3.0
958 if (AttrKind == 3) {
959 if (Lex.getKind() == lltok::kw_sext)
960 Attrs |= Attribute::SExt;
961 else
962 Attrs |= Attribute::ZExt;
963 break;
964 }
965 // FALL THROUGH.
966 default: // End of attributes.
967 if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly))
968 return Error(AttrLoc, "invalid use of function-only attribute");
969
970 if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly))
971 return Error(AttrLoc, "invalid use of parameter-only attribute");
972
973 return false;
974 case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break;
975 case lltok::kw_signext: Attrs |= Attribute::SExt; break;
976 case lltok::kw_inreg: Attrs |= Attribute::InReg; break;
977 case lltok::kw_sret: Attrs |= Attribute::StructRet; break;
978 case lltok::kw_noalias: Attrs |= Attribute::NoAlias; break;
979 case lltok::kw_nocapture: Attrs |= Attribute::NoCapture; break;
980 case lltok::kw_byval: Attrs |= Attribute::ByVal; break;
981 case lltok::kw_nest: Attrs |= Attribute::Nest; break;
982
983 case lltok::kw_noreturn: Attrs |= Attribute::NoReturn; break;
984 case lltok::kw_nounwind: Attrs |= Attribute::NoUnwind; break;
985 case lltok::kw_noinline: Attrs |= Attribute::NoInline; break;
986 case lltok::kw_readnone: Attrs |= Attribute::ReadNone; break;
987 case lltok::kw_readonly: Attrs |= Attribute::ReadOnly; break;
988 case lltok::kw_inlinehint: Attrs |= Attribute::InlineHint; break;
989 case lltok::kw_alwaysinline: Attrs |= Attribute::AlwaysInline; break;
990 case lltok::kw_optsize: Attrs |= Attribute::OptimizeForSize; break;
991 case lltok::kw_ssp: Attrs |= Attribute::StackProtect; break;
992 case lltok::kw_sspreq: Attrs |= Attribute::StackProtectReq; break;
993 case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break;
994 case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break;
995 case lltok::kw_naked: Attrs |= Attribute::Naked; break;
996
997 case lltok::kw_align: {
998 unsigned Alignment;
999 if (ParseOptionalAlignment(Alignment))
1000 return true;
1001 Attrs |= Attribute::constructAlignmentFromInt(Alignment);
1002 continue;
1003 }
1004 }
1005 Lex.Lex();
1006 }
1007}
1008
1009/// ParseOptionalLinkage
1010/// ::= /*empty*/
1011/// ::= 'private'
1012/// ::= 'linker_private'
1013/// ::= 'internal'
1014/// ::= 'weak'
1015/// ::= 'weak_odr'
1016/// ::= 'linkonce'
1017/// ::= 'linkonce_odr'
1018/// ::= 'appending'
1019/// ::= 'dllexport'
1020/// ::= 'common'
1021/// ::= 'dllimport'
1022/// ::= 'extern_weak'
1023/// ::= 'external'
1024bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
1025 HasLinkage = false;
1026 switch (Lex.getKind()) {
1027 default: Res=GlobalValue::ExternalLinkage; return false;
1028 case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
1029 case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;
1030 case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
1031 case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
1032 case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;
1033 case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;
1034 case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;
1035 case lltok::kw_available_externally:
1036 Res = GlobalValue::AvailableExternallyLinkage;
1037 break;
1038 case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;
1039 case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break;
1040 case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
1041 case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break;
1042 case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;
1043 case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;
1044 }
1045 Lex.Lex();
1046 HasLinkage = true;
1047 return false;
1048}
1049
1050/// ParseOptionalVisibility
1051/// ::= /*empty*/
1052/// ::= 'default'
1053/// ::= 'hidden'
1054/// ::= 'protected'
1055///
1056bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1057 switch (Lex.getKind()) {
1058 default: Res = GlobalValue::DefaultVisibility; return false;
1059 case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break;
1060 case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break;
1061 case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
1062 }
1063 Lex.Lex();
1064 return false;
1065}
1066
1067/// ParseOptionalCallingConv
1068/// ::= /*empty*/
1069/// ::= 'ccc'
1070/// ::= 'fastcc'
1071/// ::= 'coldcc'
1072/// ::= 'x86_stdcallcc'
1073/// ::= 'x86_fastcallcc'
1074/// ::= 'arm_apcscc'
1075/// ::= 'arm_aapcscc'
1076/// ::= 'arm_aapcs_vfpcc'
1077/// ::= 'msp430_intrcc'
1078/// ::= 'cc' UINT
1079///
1080bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) {
1081 switch (Lex.getKind()) {
1082 default: CC = CallingConv::C; return false;
1083 case lltok::kw_ccc: CC = CallingConv::C; break;
1084 case lltok::kw_fastcc: CC = CallingConv::Fast; break;
1085 case lltok::kw_coldcc: CC = CallingConv::Cold; break;
1086 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break;
1087 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1088 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
1089 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
1090 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1091 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
1092 case lltok::kw_cc: {
1093 unsigned ArbitraryCC;
1094 Lex.Lex();
1095 if (ParseUInt32(ArbitraryCC)) {
1096 return true;
1097 } else
1098 CC = static_cast<CallingConv::ID>(ArbitraryCC);
1099 return false;
1100 }
1101 break;
1102 }
1103
1104 Lex.Lex();
1105 return false;
1106}
1107
| 569 return false;
570}
571
572/// ParseAlias:
573/// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee
574/// Aliasee
575/// ::= TypeAndValue
576/// ::= 'bitcast' '(' TypeAndValue 'to' Type ')'
577/// ::= 'getelementptr' 'inbounds'? '(' ... ')'
578///
579/// Everything through visibility has already been parsed.
580///
581bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc,
582 unsigned Visibility) {
583 assert(Lex.getKind() == lltok::kw_alias);
584 Lex.Lex();
585 unsigned Linkage;
586 LocTy LinkageLoc = Lex.getLoc();
587 if (ParseOptionalLinkage(Linkage))
588 return true;
589
590 if (Linkage != GlobalValue::ExternalLinkage &&
591 Linkage != GlobalValue::WeakAnyLinkage &&
592 Linkage != GlobalValue::WeakODRLinkage &&
593 Linkage != GlobalValue::InternalLinkage &&
594 Linkage != GlobalValue::PrivateLinkage &&
595 Linkage != GlobalValue::LinkerPrivateLinkage)
596 return Error(LinkageLoc, "invalid linkage type for alias");
597
598 Constant *Aliasee;
599 LocTy AliaseeLoc = Lex.getLoc();
600 if (Lex.getKind() != lltok::kw_bitcast &&
601 Lex.getKind() != lltok::kw_getelementptr) {
602 if (ParseGlobalTypeAndValue(Aliasee)) return true;
603 } else {
604 // The bitcast dest type is not present, it is implied by the dest type.
605 ValID ID;
606 if (ParseValID(ID)) return true;
607 if (ID.Kind != ValID::t_Constant)
608 return Error(AliaseeLoc, "invalid aliasee");
609 Aliasee = ID.ConstantVal;
610 }
611
612 if (!isa<PointerType>(Aliasee->getType()))
613 return Error(AliaseeLoc, "alias must have pointer type");
614
615 // Okay, create the alias but do not insert it into the module yet.
616 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(),
617 (GlobalValue::LinkageTypes)Linkage, Name,
618 Aliasee);
619 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
620
621 // See if this value already exists in the symbol table. If so, it is either
622 // a redefinition or a definition of a forward reference.
623 if (GlobalValue *Val = M->getNamedValue(Name)) {
624 // See if this was a redefinition. If so, there is no entry in
625 // ForwardRefVals.
626 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
627 I = ForwardRefVals.find(Name);
628 if (I == ForwardRefVals.end())
629 return Error(NameLoc, "redefinition of global named '@" + Name + "'");
630
631 // Otherwise, this was a definition of forward ref. Verify that types
632 // agree.
633 if (Val->getType() != GA->getType())
634 return Error(NameLoc,
635 "forward reference and definition of alias have different types");
636
637 // If they agree, just RAUW the old value with the alias and remove the
638 // forward ref info.
639 Val->replaceAllUsesWith(GA);
640 Val->eraseFromParent();
641 ForwardRefVals.erase(I);
642 }
643
644 // Insert into the module, we know its name won't collide now.
645 M->getAliasList().push_back(GA);
646 assert(GA->getNameStr() == Name && "Should not be a name conflict!");
647
648 return false;
649}
650
651/// ParseGlobal
652/// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal
653/// OptionalAddrSpace GlobalType Type Const
654/// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
655/// OptionalAddrSpace GlobalType Type Const
656///
657/// Everything through visibility has been parsed already.
658///
659bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
660 unsigned Linkage, bool HasLinkage,
661 unsigned Visibility) {
662 unsigned AddrSpace;
663 bool ThreadLocal, IsConstant;
664 LocTy TyLoc;
665
666 PATypeHolder Ty(Type::getVoidTy(Context));
667 if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) ||
668 ParseOptionalAddrSpace(AddrSpace) ||
669 ParseGlobalType(IsConstant) ||
670 ParseType(Ty, TyLoc))
671 return true;
672
673 // If the linkage is specified and is external, then no initializer is
674 // present.
675 Constant *Init = 0;
676 if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage &&
677 Linkage != GlobalValue::ExternalWeakLinkage &&
678 Linkage != GlobalValue::ExternalLinkage)) {
679 if (ParseGlobalValue(Ty, Init))
680 return true;
681 }
682
683 if (isa<FunctionType>(Ty) || Ty->isLabelTy())
684 return Error(TyLoc, "invalid type for global variable");
685
686 GlobalVariable *GV = 0;
687
688 // See if the global was forward referenced, if so, use the global.
689 if (!Name.empty()) {
690 if (GlobalValue *GVal = M->getNamedValue(Name)) {
691 if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
692 return Error(NameLoc, "redefinition of global '@" + Name + "'");
693 GV = cast<GlobalVariable>(GVal);
694 }
695 } else {
696 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
697 I = ForwardRefValIDs.find(NumberedVals.size());
698 if (I != ForwardRefValIDs.end()) {
699 GV = cast<GlobalVariable>(I->second.first);
700 ForwardRefValIDs.erase(I);
701 }
702 }
703
704 if (GV == 0) {
705 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0,
706 Name, 0, false, AddrSpace);
707 } else {
708 if (GV->getType()->getElementType() != Ty)
709 return Error(TyLoc,
710 "forward reference and definition of global have different types");
711
712 // Move the forward-reference to the correct spot in the module.
713 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
714 }
715
716 if (Name.empty())
717 NumberedVals.push_back(GV);
718
719 // Set the parsed properties on the global.
720 if (Init)
721 GV->setInitializer(Init);
722 GV->setConstant(IsConstant);
723 GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
724 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
725 GV->setThreadLocal(ThreadLocal);
726
727 // Parse attributes on the global.
728 while (Lex.getKind() == lltok::comma) {
729 Lex.Lex();
730
731 if (Lex.getKind() == lltok::kw_section) {
732 Lex.Lex();
733 GV->setSection(Lex.getStrVal());
734 if (ParseToken(lltok::StringConstant, "expected global section string"))
735 return true;
736 } else if (Lex.getKind() == lltok::kw_align) {
737 unsigned Alignment;
738 if (ParseOptionalAlignment(Alignment)) return true;
739 GV->setAlignment(Alignment);
740 } else {
741 TokError("unknown global variable property!");
742 }
743 }
744
745 return false;
746}
747
748
749//===----------------------------------------------------------------------===//
750// GlobalValue Reference/Resolution Routines.
751//===----------------------------------------------------------------------===//
752
753/// GetGlobalVal - Get a value with the specified name or ID, creating a
754/// forward reference record if needed. This can return null if the value
755/// exists but does not have the right type.
756GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty,
757 LocTy Loc) {
758 const PointerType *PTy = dyn_cast<PointerType>(Ty);
759 if (PTy == 0) {
760 Error(Loc, "global variable reference must have pointer type");
761 return 0;
762 }
763
764 // Look this name up in the normal function symbol table.
765 GlobalValue *Val =
766 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
767
768 // If this is a forward reference for the value, see if we already created a
769 // forward ref record.
770 if (Val == 0) {
771 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
772 I = ForwardRefVals.find(Name);
773 if (I != ForwardRefVals.end())
774 Val = I->second.first;
775 }
776
777 // If we have the value in the symbol table or fwd-ref table, return it.
778 if (Val) {
779 if (Val->getType() == Ty) return Val;
780 Error(Loc, "'@" + Name + "' defined with type '" +
781 Val->getType()->getDescription() + "'");
782 return 0;
783 }
784
785 // Otherwise, create a new forward reference for this value and remember it.
786 GlobalValue *FwdVal;
787 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
788 // Function types can return opaque but functions can't.
789 if (isa<OpaqueType>(FT->getReturnType())) {
790 Error(Loc, "function may not return opaque type");
791 return 0;
792 }
793
794 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
795 } else {
796 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
797 GlobalValue::ExternalWeakLinkage, 0, Name);
798 }
799
800 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
801 return FwdVal;
802}
803
804GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) {
805 const PointerType *PTy = dyn_cast<PointerType>(Ty);
806 if (PTy == 0) {
807 Error(Loc, "global variable reference must have pointer type");
808 return 0;
809 }
810
811 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
812
813 // If this is a forward reference for the value, see if we already created a
814 // forward ref record.
815 if (Val == 0) {
816 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
817 I = ForwardRefValIDs.find(ID);
818 if (I != ForwardRefValIDs.end())
819 Val = I->second.first;
820 }
821
822 // If we have the value in the symbol table or fwd-ref table, return it.
823 if (Val) {
824 if (Val->getType() == Ty) return Val;
825 Error(Loc, "'@" + utostr(ID) + "' defined with type '" +
826 Val->getType()->getDescription() + "'");
827 return 0;
828 }
829
830 // Otherwise, create a new forward reference for this value and remember it.
831 GlobalValue *FwdVal;
832 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
833 // Function types can return opaque but functions can't.
834 if (isa<OpaqueType>(FT->getReturnType())) {
835 Error(Loc, "function may not return opaque type");
836 return 0;
837 }
838 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
839 } else {
840 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
841 GlobalValue::ExternalWeakLinkage, 0, "");
842 }
843
844 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
845 return FwdVal;
846}
847
848
849//===----------------------------------------------------------------------===//
850// Helper Routines.
851//===----------------------------------------------------------------------===//
852
853/// ParseToken - If the current token has the specified kind, eat it and return
854/// success. Otherwise, emit the specified error and return failure.
855bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
856 if (Lex.getKind() != T)
857 return TokError(ErrMsg);
858 Lex.Lex();
859 return false;
860}
861
862/// ParseStringConstant
863/// ::= StringConstant
864bool LLParser::ParseStringConstant(std::string &Result) {
865 if (Lex.getKind() != lltok::StringConstant)
866 return TokError("expected string constant");
867 Result = Lex.getStrVal();
868 Lex.Lex();
869 return false;
870}
871
872/// ParseUInt32
873/// ::= uint32
874bool LLParser::ParseUInt32(unsigned &Val) {
875 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
876 return TokError("expected integer");
877 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
878 if (Val64 != unsigned(Val64))
879 return TokError("expected 32-bit integer (too large)");
880 Val = Val64;
881 Lex.Lex();
882 return false;
883}
884
885
886/// ParseOptionalAddrSpace
887/// := /*empty*/
888/// := 'addrspace' '(' uint32 ')'
889bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
890 AddrSpace = 0;
891 if (!EatIfPresent(lltok::kw_addrspace))
892 return false;
893 return ParseToken(lltok::lparen, "expected '(' in address space") ||
894 ParseUInt32(AddrSpace) ||
895 ParseToken(lltok::rparen, "expected ')' in address space");
896}
897
898/// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind
899/// indicates what kind of attribute list this is: 0: function arg, 1: result,
900/// 2: function attr.
901/// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0
902bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) {
903 Attrs = Attribute::None;
904 LocTy AttrLoc = Lex.getLoc();
905
906 while (1) {
907 switch (Lex.getKind()) {
908 case lltok::kw_sext:
909 case lltok::kw_zext:
910 // Treat these as signext/zeroext if they occur in the argument list after
911 // the value, as in "call i8 @foo(i8 10 sext)". If they occur before the
912 // value, as in "call i8 @foo(i8 sext (" then it is part of a constant
913 // expr.
914 // FIXME: REMOVE THIS IN LLVM 3.0
915 if (AttrKind == 3) {
916 if (Lex.getKind() == lltok::kw_sext)
917 Attrs |= Attribute::SExt;
918 else
919 Attrs |= Attribute::ZExt;
920 break;
921 }
922 // FALL THROUGH.
923 default: // End of attributes.
924 if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly))
925 return Error(AttrLoc, "invalid use of function-only attribute");
926
927 if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly))
928 return Error(AttrLoc, "invalid use of parameter-only attribute");
929
930 return false;
931 case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break;
932 case lltok::kw_signext: Attrs |= Attribute::SExt; break;
933 case lltok::kw_inreg: Attrs |= Attribute::InReg; break;
934 case lltok::kw_sret: Attrs |= Attribute::StructRet; break;
935 case lltok::kw_noalias: Attrs |= Attribute::NoAlias; break;
936 case lltok::kw_nocapture: Attrs |= Attribute::NoCapture; break;
937 case lltok::kw_byval: Attrs |= Attribute::ByVal; break;
938 case lltok::kw_nest: Attrs |= Attribute::Nest; break;
939
940 case lltok::kw_noreturn: Attrs |= Attribute::NoReturn; break;
941 case lltok::kw_nounwind: Attrs |= Attribute::NoUnwind; break;
942 case lltok::kw_noinline: Attrs |= Attribute::NoInline; break;
943 case lltok::kw_readnone: Attrs |= Attribute::ReadNone; break;
944 case lltok::kw_readonly: Attrs |= Attribute::ReadOnly; break;
945 case lltok::kw_inlinehint: Attrs |= Attribute::InlineHint; break;
946 case lltok::kw_alwaysinline: Attrs |= Attribute::AlwaysInline; break;
947 case lltok::kw_optsize: Attrs |= Attribute::OptimizeForSize; break;
948 case lltok::kw_ssp: Attrs |= Attribute::StackProtect; break;
949 case lltok::kw_sspreq: Attrs |= Attribute::StackProtectReq; break;
950 case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break;
951 case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break;
952 case lltok::kw_naked: Attrs |= Attribute::Naked; break;
953
954 case lltok::kw_align: {
955 unsigned Alignment;
956 if (ParseOptionalAlignment(Alignment))
957 return true;
958 Attrs |= Attribute::constructAlignmentFromInt(Alignment);
959 continue;
960 }
961 }
962 Lex.Lex();
963 }
964}
965
966/// ParseOptionalLinkage
967/// ::= /*empty*/
968/// ::= 'private'
969/// ::= 'linker_private'
970/// ::= 'internal'
971/// ::= 'weak'
972/// ::= 'weak_odr'
973/// ::= 'linkonce'
974/// ::= 'linkonce_odr'
975/// ::= 'appending'
976/// ::= 'dllexport'
977/// ::= 'common'
978/// ::= 'dllimport'
979/// ::= 'extern_weak'
980/// ::= 'external'
981bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
982 HasLinkage = false;
983 switch (Lex.getKind()) {
984 default: Res=GlobalValue::ExternalLinkage; return false;
985 case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
986 case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;
987 case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
988 case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
989 case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;
990 case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;
991 case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;
992 case lltok::kw_available_externally:
993 Res = GlobalValue::AvailableExternallyLinkage;
994 break;
995 case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;
996 case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break;
997 case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
998 case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break;
999 case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;
1000 case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;
1001 }
1002 Lex.Lex();
1003 HasLinkage = true;
1004 return false;
1005}
1006
1007/// ParseOptionalVisibility
1008/// ::= /*empty*/
1009/// ::= 'default'
1010/// ::= 'hidden'
1011/// ::= 'protected'
1012///
1013bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1014 switch (Lex.getKind()) {
1015 default: Res = GlobalValue::DefaultVisibility; return false;
1016 case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break;
1017 case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break;
1018 case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
1019 }
1020 Lex.Lex();
1021 return false;
1022}
1023
1024/// ParseOptionalCallingConv
1025/// ::= /*empty*/
1026/// ::= 'ccc'
1027/// ::= 'fastcc'
1028/// ::= 'coldcc'
1029/// ::= 'x86_stdcallcc'
1030/// ::= 'x86_fastcallcc'
1031/// ::= 'arm_apcscc'
1032/// ::= 'arm_aapcscc'
1033/// ::= 'arm_aapcs_vfpcc'
1034/// ::= 'msp430_intrcc'
1035/// ::= 'cc' UINT
1036///
1037bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) {
1038 switch (Lex.getKind()) {
1039 default: CC = CallingConv::C; return false;
1040 case lltok::kw_ccc: CC = CallingConv::C; break;
1041 case lltok::kw_fastcc: CC = CallingConv::Fast; break;
1042 case lltok::kw_coldcc: CC = CallingConv::Cold; break;
1043 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break;
1044 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1045 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
1046 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
1047 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1048 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
1049 case lltok::kw_cc: {
1050 unsigned ArbitraryCC;
1051 Lex.Lex();
1052 if (ParseUInt32(ArbitraryCC)) {
1053 return true;
1054 } else
1055 CC = static_cast<CallingConv::ID>(ArbitraryCC);
1056 return false;
1057 }
1058 break;
1059 }
1060
1061 Lex.Lex();
1062 return false;
1063}
1064
|
1108/// ParseOptionalCustomMetadata
1109/// ::= /* empty */
1110/// ::= !dbg !42
1111bool LLParser::ParseOptionalCustomMetadata() {
1112 if (Lex.getKind() != lltok::NamedOrCustomMD)
1113 return false;
| 1065/// ParseInstructionMetadata
1066/// ::= !dbg !42 (',' !dbg !57)*
1067bool LLParser::
1068ParseInstructionMetadata(SmallVectorImpl<std::pair<unsigned,
1069 MDNode *> > &Result){
1070 do {
1071 if (Lex.getKind() != lltok::MetadataVar)
1072 return TokError("expected metadata after comma");
|
1114
| 1073
|
1115 std::string Name = Lex.getStrVal();
1116 Lex.Lex();
| 1074 std::string Name = Lex.getStrVal();
1075 Lex.Lex();
|
1117
| 1076
|
1118 if (Lex.getKind() != lltok::Metadata)
1119 return TokError("Expected '!' here");
1120 Lex.Lex();
| 1077 MDNode *Node;
1078 if (ParseToken(lltok::exclaim, "expected '!' here") ||
1079 ParseMDNodeID(Node))
1080 return true;
|
1121
| 1081
|
1122 MetadataBase *Node;
1123 if (ParseMDNode(Node)) return true;
| 1082 unsigned MDK = M->getMDKindID(Name.c_str());
1083 Result.push_back(std::make_pair(MDK, Node));
|
1124
| 1084
|
1125 MetadataContext &TheMetadata = M->getContext().getMetadata();
1126 unsigned MDK = TheMetadata.getMDKind(Name.c_str());
1127 if (!MDK)
1128 MDK = TheMetadata.registerMDKind(Name.c_str());
1129 MDsOnInst.push_back(std::make_pair(MDK, cast<MDNode>(Node)));
1130
| 1085 // If this is the end of the list, we're done.
1086 } while (EatIfPresent(lltok::comma));
|
1131 return false;
1132}
1133
1134/// ParseOptionalAlignment
1135/// ::= /* empty */
1136/// ::= 'align' 4
1137bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1138 Alignment = 0;
1139 if (!EatIfPresent(lltok::kw_align))
1140 return false;
1141 LocTy AlignLoc = Lex.getLoc();
1142 if (ParseUInt32(Alignment)) return true;
1143 if (!isPowerOf2_32(Alignment))
1144 return Error(AlignLoc, "alignment is not a power of two");
1145 return false;
1146}
1147
| 1087 return false;
1088}
1089
1090/// ParseOptionalAlignment
1091/// ::= /* empty */
1092/// ::= 'align' 4
1093bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1094 Alignment = 0;
1095 if (!EatIfPresent(lltok::kw_align))
1096 return false;
1097 LocTy AlignLoc = Lex.getLoc();
1098 if (ParseUInt32(Alignment)) return true;
1099 if (!isPowerOf2_32(Alignment))
1100 return Error(AlignLoc, "alignment is not a power of two");
1101 return false;
1102}
1103
|
1148/// ParseOptionalInfo
1149/// ::= OptionalInfo (',' OptionalInfo)+
1150bool LLParser::ParseOptionalInfo(unsigned &Alignment) {
1151
1152 // FIXME: Handle customized metadata info attached with an instruction.
1153 do {
1154 if (Lex.getKind() == lltok::NamedOrCustomMD) {
1155 if (ParseOptionalCustomMetadata()) return true;
1156 } else if (Lex.getKind() == lltok::kw_align) {
| 1104/// ParseOptionalCommaAlign
1105/// ::=
1106/// ::= ',' align 4
1107///
1108/// This returns with AteExtraComma set to true if it ate an excess comma at the
1109/// end.
1110bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
1111 bool &AteExtraComma) {
1112 AteExtraComma = false;
1113 while (EatIfPresent(lltok::comma)) {
1114 // Metadata at the end is an early exit.
1115 if (Lex.getKind() == lltok::MetadataVar) {
1116 AteExtraComma = true;
1117 return false;
1118 }
1119
1120 if (Lex.getKind() == lltok::kw_align) {
|
1157 if (ParseOptionalAlignment(Alignment)) return true;
1158 } else
1159 return true;
| 1121 if (ParseOptionalAlignment(Alignment)) return true;
1122 } else
1123 return true;
|
1160 } while (EatIfPresent(lltok::comma));
| 1124 }
|
1161
1162 return false;
1163}
1164
1165
| 1125
1126 return false;
1127}
1128
1129
|
| 1130/// ParseIndexList - This parses the index list for an insert/extractvalue
1131/// instruction. This sets AteExtraComma in the case where we eat an extra
1132/// comma at the end of the line and find that it is followed by metadata.
1133/// Clients that don't allow metadata can call the version of this function that
1134/// only takes one argument.
1135///
|
1166/// ParseIndexList
1167/// ::= (',' uint32)+
| 1136/// ParseIndexList
1137/// ::= (',' uint32)+
|
1168bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
| 1138///
1139bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices,
1140 bool &AteExtraComma) {
1141 AteExtraComma = false;
1142
|
1169 if (Lex.getKind() != lltok::comma)
1170 return TokError("expected ',' as start of index list");
1171
1172 while (EatIfPresent(lltok::comma)) {
| 1143 if (Lex.getKind() != lltok::comma)
1144 return TokError("expected ',' as start of index list");
1145
1146 while (EatIfPresent(lltok::comma)) {
|
1173 if (Lex.getKind() == lltok::NamedOrCustomMD)
1174 break;
| 1147 if (Lex.getKind() == lltok::MetadataVar) {
1148 AteExtraComma = true;
1149 return false;
1150 }
|
1175 unsigned Idx;
1176 if (ParseUInt32(Idx)) return true;
1177 Indices.push_back(Idx);
1178 }
1179
1180 return false;
1181}
1182
1183//===----------------------------------------------------------------------===//
1184// Type Parsing.
1185//===----------------------------------------------------------------------===//
1186
1187/// ParseType - Parse and resolve a full type.
1188bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) {
1189 LocTy TypeLoc = Lex.getLoc();
1190 if (ParseTypeRec(Result)) return true;
1191
1192 // Verify no unresolved uprefs.
1193 if (!UpRefs.empty())
1194 return Error(UpRefs.back().Loc, "invalid unresolved type up reference");
1195
1196 if (!AllowVoid && Result.get()->isVoidTy())
1197 return Error(TypeLoc, "void type only allowed for function results");
1198
1199 return false;
1200}
1201
1202/// HandleUpRefs - Every time we finish a new layer of types, this function is
1203/// called. It loops through the UpRefs vector, which is a list of the
1204/// currently active types. For each type, if the up-reference is contained in
1205/// the newly completed type, we decrement the level count. When the level
1206/// count reaches zero, the up-referenced type is the type that is passed in:
1207/// thus we can complete the cycle.
1208///
1209PATypeHolder LLParser::HandleUpRefs(const Type *ty) {
1210 // If Ty isn't abstract, or if there are no up-references in it, then there is
1211 // nothing to resolve here.
1212 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1213
1214 PATypeHolder Ty(ty);
1215#if 0
| 1151 unsigned Idx;
1152 if (ParseUInt32(Idx)) return true;
1153 Indices.push_back(Idx);
1154 }
1155
1156 return false;
1157}
1158
1159//===----------------------------------------------------------------------===//
1160// Type Parsing.
1161//===----------------------------------------------------------------------===//
1162
1163/// ParseType - Parse and resolve a full type.
1164bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) {
1165 LocTy TypeLoc = Lex.getLoc();
1166 if (ParseTypeRec(Result)) return true;
1167
1168 // Verify no unresolved uprefs.
1169 if (!UpRefs.empty())
1170 return Error(UpRefs.back().Loc, "invalid unresolved type up reference");
1171
1172 if (!AllowVoid && Result.get()->isVoidTy())
1173 return Error(TypeLoc, "void type only allowed for function results");
1174
1175 return false;
1176}
1177
1178/// HandleUpRefs - Every time we finish a new layer of types, this function is
1179/// called. It loops through the UpRefs vector, which is a list of the
1180/// currently active types. For each type, if the up-reference is contained in
1181/// the newly completed type, we decrement the level count. When the level
1182/// count reaches zero, the up-referenced type is the type that is passed in:
1183/// thus we can complete the cycle.
1184///
1185PATypeHolder LLParser::HandleUpRefs(const Type *ty) {
1186 // If Ty isn't abstract, or if there are no up-references in it, then there is
1187 // nothing to resolve here.
1188 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1189
1190 PATypeHolder Ty(ty);
1191#if 0
|
1216 errs() << "Type '" << Ty->getDescription()
| 1192 dbgs() << "Type '" << Ty->getDescription()
|
1217 << "' newly formed. Resolving upreferences.\n"
1218 << UpRefs.size() << " upreferences active!\n";
1219#endif
1220
1221 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1222 // to zero), we resolve them all together before we resolve them to Ty. At
1223 // the end of the loop, if there is anything to resolve to Ty, it will be in
1224 // this variable.
1225 OpaqueType *TypeToResolve = 0;
1226
1227 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1228 // Determine if 'Ty' directly contains this up-references 'LastContainedTy'.
1229 bool ContainsType =
1230 std::find(Ty->subtype_begin(), Ty->subtype_end(),
1231 UpRefs[i].LastContainedTy) != Ty->subtype_end();
1232
1233#if 0
| 1193 << "' newly formed. Resolving upreferences.\n"
1194 << UpRefs.size() << " upreferences active!\n";
1195#endif
1196
1197 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1198 // to zero), we resolve them all together before we resolve them to Ty. At
1199 // the end of the loop, if there is anything to resolve to Ty, it will be in
1200 // this variable.
1201 OpaqueType *TypeToResolve = 0;
1202
1203 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1204 // Determine if 'Ty' directly contains this up-references 'LastContainedTy'.
1205 bool ContainsType =
1206 std::find(Ty->subtype_begin(), Ty->subtype_end(),
1207 UpRefs[i].LastContainedTy) != Ty->subtype_end();
1208
1209#if 0
|
1234 errs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
| 1210 dbgs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
|
1235 << UpRefs[i].LastContainedTy->getDescription() << ") = "
1236 << (ContainsType ? "true" : "false")
1237 << " level=" << UpRefs[i].NestingLevel << "\n";
1238#endif
1239 if (!ContainsType)
1240 continue;
1241
1242 // Decrement level of upreference
1243 unsigned Level = --UpRefs[i].NestingLevel;
1244 UpRefs[i].LastContainedTy = Ty;
1245
1246 // If the Up-reference has a non-zero level, it shouldn't be resolved yet.
1247 if (Level != 0)
1248 continue;
1249
1250#if 0
| 1211 << UpRefs[i].LastContainedTy->getDescription() << ") = "
1212 << (ContainsType ? "true" : "false")
1213 << " level=" << UpRefs[i].NestingLevel << "\n";
1214#endif
1215 if (!ContainsType)
1216 continue;
1217
1218 // Decrement level of upreference
1219 unsigned Level = --UpRefs[i].NestingLevel;
1220 UpRefs[i].LastContainedTy = Ty;
1221
1222 // If the Up-reference has a non-zero level, it shouldn't be resolved yet.
1223 if (Level != 0)
1224 continue;
1225
1226#if 0
|
1251 errs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n";
| 1227 dbgs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n";
|
1252#endif
1253 if (!TypeToResolve)
1254 TypeToResolve = UpRefs[i].UpRefTy;
1255 else
1256 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1257 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list.
1258 --i; // Do not skip the next element.
1259 }
1260
1261 if (TypeToResolve)
1262 TypeToResolve->refineAbstractTypeTo(Ty);
1263
1264 return Ty;
1265}
1266
1267
1268/// ParseTypeRec - The recursive function used to process the internal
1269/// implementation details of types.
1270bool LLParser::ParseTypeRec(PATypeHolder &Result) {
1271 switch (Lex.getKind()) {
1272 default:
1273 return TokError("expected type");
1274 case lltok::Type:
1275 // TypeRec ::= 'float' | 'void' (etc)
1276 Result = Lex.getTyVal();
1277 Lex.Lex();
1278 break;
1279 case lltok::kw_opaque:
1280 // TypeRec ::= 'opaque'
1281 Result = OpaqueType::get(Context);
1282 Lex.Lex();
1283 break;
1284 case lltok::lbrace:
1285 // TypeRec ::= '{' ... '}'
1286 if (ParseStructType(Result, false))
1287 return true;
1288 break;
1289 case lltok::lsquare:
1290 // TypeRec ::= '[' ... ']'
1291 Lex.Lex(); // eat the lsquare.
1292 if (ParseArrayVectorType(Result, false))
1293 return true;
1294 break;
1295 case lltok::less: // Either vector or packed struct.
1296 // TypeRec ::= '<' ... '>'
1297 Lex.Lex();
1298 if (Lex.getKind() == lltok::lbrace) {
1299 if (ParseStructType(Result, true) ||
1300 ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1301 return true;
1302 } else if (ParseArrayVectorType(Result, true))
1303 return true;
1304 break;
1305 case lltok::LocalVar:
1306 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0
1307 // TypeRec ::= %foo
1308 if (const Type *T = M->getTypeByName(Lex.getStrVal())) {
1309 Result = T;
1310 } else {
1311 Result = OpaqueType::get(Context);
1312 ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(),
1313 std::make_pair(Result,
1314 Lex.getLoc())));
1315 M->addTypeName(Lex.getStrVal(), Result.get());
1316 }
1317 Lex.Lex();
1318 break;
1319
1320 case lltok::LocalVarID:
1321 // TypeRec ::= %4
1322 if (Lex.getUIntVal() < NumberedTypes.size())
1323 Result = NumberedTypes[Lex.getUIntVal()];
1324 else {
1325 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
1326 I = ForwardRefTypeIDs.find(Lex.getUIntVal());
1327 if (I != ForwardRefTypeIDs.end())
1328 Result = I->second.first;
1329 else {
1330 Result = OpaqueType::get(Context);
1331 ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(),
1332 std::make_pair(Result,
1333 Lex.getLoc())));
1334 }
1335 }
1336 Lex.Lex();
1337 break;
1338 case lltok::backslash: {
1339 // TypeRec ::= '\' 4
1340 Lex.Lex();
1341 unsigned Val;
1342 if (ParseUInt32(Val)) return true;
1343 OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder.
1344 UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT));
1345 Result = OT;
1346 break;
1347 }
1348 }
1349
1350 // Parse the type suffixes.
1351 while (1) {
1352 switch (Lex.getKind()) {
1353 // End of type.
1354 default: return false;
1355
1356 // TypeRec ::= TypeRec '*'
1357 case lltok::star:
1358 if (Result.get()->isLabelTy())
1359 return TokError("basic block pointers are invalid");
1360 if (Result.get()->isVoidTy())
1361 return TokError("pointers to void are invalid; use i8* instead");
1362 if (!PointerType::isValidElementType(Result.get()))
1363 return TokError("pointer to this type is invalid");
1364 Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
1365 Lex.Lex();
1366 break;
1367
1368 // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*'
1369 case lltok::kw_addrspace: {
1370 if (Result.get()->isLabelTy())
1371 return TokError("basic block pointers are invalid");
1372 if (Result.get()->isVoidTy())
1373 return TokError("pointers to void are invalid; use i8* instead");
1374 if (!PointerType::isValidElementType(Result.get()))
1375 return TokError("pointer to this type is invalid");
1376 unsigned AddrSpace;
1377 if (ParseOptionalAddrSpace(AddrSpace) ||
1378 ParseToken(lltok::star, "expected '*' in address space"))
1379 return true;
1380
1381 Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace));
1382 break;
1383 }
1384
1385 /// Types '(' ArgTypeListI ')' OptFuncAttrs
1386 case lltok::lparen:
1387 if (ParseFunctionType(Result))
1388 return true;
1389 break;
1390 }
1391 }
1392}
1393
1394/// ParseParameterList
1395/// ::= '(' ')'
1396/// ::= '(' Arg (',' Arg)* ')'
1397/// Arg
1398/// ::= Type OptionalAttributes Value OptionalAttributes
1399bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1400 PerFunctionState &PFS) {
1401 if (ParseToken(lltok::lparen, "expected '(' in call"))
1402 return true;
1403
1404 while (Lex.getKind() != lltok::rparen) {
1405 // If this isn't the first argument, we need a comma.
1406 if (!ArgList.empty() &&
1407 ParseToken(lltok::comma, "expected ',' in argument list"))
1408 return true;
1409
1410 // Parse the argument.
1411 LocTy ArgLoc;
1412 PATypeHolder ArgTy(Type::getVoidTy(Context));
1413 unsigned ArgAttrs1 = Attribute::None;
1414 unsigned ArgAttrs2 = Attribute::None;
1415 Value *V;
1416 if (ParseType(ArgTy, ArgLoc))
1417 return true;
1418
| 1228#endif
1229 if (!TypeToResolve)
1230 TypeToResolve = UpRefs[i].UpRefTy;
1231 else
1232 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1233 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list.
1234 --i; // Do not skip the next element.
1235 }
1236
1237 if (TypeToResolve)
1238 TypeToResolve->refineAbstractTypeTo(Ty);
1239
1240 return Ty;
1241}
1242
1243
1244/// ParseTypeRec - The recursive function used to process the internal
1245/// implementation details of types.
1246bool LLParser::ParseTypeRec(PATypeHolder &Result) {
1247 switch (Lex.getKind()) {
1248 default:
1249 return TokError("expected type");
1250 case lltok::Type:
1251 // TypeRec ::= 'float' | 'void' (etc)
1252 Result = Lex.getTyVal();
1253 Lex.Lex();
1254 break;
1255 case lltok::kw_opaque:
1256 // TypeRec ::= 'opaque'
1257 Result = OpaqueType::get(Context);
1258 Lex.Lex();
1259 break;
1260 case lltok::lbrace:
1261 // TypeRec ::= '{' ... '}'
1262 if (ParseStructType(Result, false))
1263 return true;
1264 break;
1265 case lltok::lsquare:
1266 // TypeRec ::= '[' ... ']'
1267 Lex.Lex(); // eat the lsquare.
1268 if (ParseArrayVectorType(Result, false))
1269 return true;
1270 break;
1271 case lltok::less: // Either vector or packed struct.
1272 // TypeRec ::= '<' ... '>'
1273 Lex.Lex();
1274 if (Lex.getKind() == lltok::lbrace) {
1275 if (ParseStructType(Result, true) ||
1276 ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1277 return true;
1278 } else if (ParseArrayVectorType(Result, true))
1279 return true;
1280 break;
1281 case lltok::LocalVar:
1282 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0
1283 // TypeRec ::= %foo
1284 if (const Type *T = M->getTypeByName(Lex.getStrVal())) {
1285 Result = T;
1286 } else {
1287 Result = OpaqueType::get(Context);
1288 ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(),
1289 std::make_pair(Result,
1290 Lex.getLoc())));
1291 M->addTypeName(Lex.getStrVal(), Result.get());
1292 }
1293 Lex.Lex();
1294 break;
1295
1296 case lltok::LocalVarID:
1297 // TypeRec ::= %4
1298 if (Lex.getUIntVal() < NumberedTypes.size())
1299 Result = NumberedTypes[Lex.getUIntVal()];
1300 else {
1301 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
1302 I = ForwardRefTypeIDs.find(Lex.getUIntVal());
1303 if (I != ForwardRefTypeIDs.end())
1304 Result = I->second.first;
1305 else {
1306 Result = OpaqueType::get(Context);
1307 ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(),
1308 std::make_pair(Result,
1309 Lex.getLoc())));
1310 }
1311 }
1312 Lex.Lex();
1313 break;
1314 case lltok::backslash: {
1315 // TypeRec ::= '\' 4
1316 Lex.Lex();
1317 unsigned Val;
1318 if (ParseUInt32(Val)) return true;
1319 OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder.
1320 UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT));
1321 Result = OT;
1322 break;
1323 }
1324 }
1325
1326 // Parse the type suffixes.
1327 while (1) {
1328 switch (Lex.getKind()) {
1329 // End of type.
1330 default: return false;
1331
1332 // TypeRec ::= TypeRec '*'
1333 case lltok::star:
1334 if (Result.get()->isLabelTy())
1335 return TokError("basic block pointers are invalid");
1336 if (Result.get()->isVoidTy())
1337 return TokError("pointers to void are invalid; use i8* instead");
1338 if (!PointerType::isValidElementType(Result.get()))
1339 return TokError("pointer to this type is invalid");
1340 Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
1341 Lex.Lex();
1342 break;
1343
1344 // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*'
1345 case lltok::kw_addrspace: {
1346 if (Result.get()->isLabelTy())
1347 return TokError("basic block pointers are invalid");
1348 if (Result.get()->isVoidTy())
1349 return TokError("pointers to void are invalid; use i8* instead");
1350 if (!PointerType::isValidElementType(Result.get()))
1351 return TokError("pointer to this type is invalid");
1352 unsigned AddrSpace;
1353 if (ParseOptionalAddrSpace(AddrSpace) ||
1354 ParseToken(lltok::star, "expected '*' in address space"))
1355 return true;
1356
1357 Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace));
1358 break;
1359 }
1360
1361 /// Types '(' ArgTypeListI ')' OptFuncAttrs
1362 case lltok::lparen:
1363 if (ParseFunctionType(Result))
1364 return true;
1365 break;
1366 }
1367 }
1368}
1369
1370/// ParseParameterList
1371/// ::= '(' ')'
1372/// ::= '(' Arg (',' Arg)* ')'
1373/// Arg
1374/// ::= Type OptionalAttributes Value OptionalAttributes
1375bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1376 PerFunctionState &PFS) {
1377 if (ParseToken(lltok::lparen, "expected '(' in call"))
1378 return true;
1379
1380 while (Lex.getKind() != lltok::rparen) {
1381 // If this isn't the first argument, we need a comma.
1382 if (!ArgList.empty() &&
1383 ParseToken(lltok::comma, "expected ',' in argument list"))
1384 return true;
1385
1386 // Parse the argument.
1387 LocTy ArgLoc;
1388 PATypeHolder ArgTy(Type::getVoidTy(Context));
1389 unsigned ArgAttrs1 = Attribute::None;
1390 unsigned ArgAttrs2 = Attribute::None;
1391 Value *V;
1392 if (ParseType(ArgTy, ArgLoc))
1393 return true;
1394
|
1419 if (Lex.getKind() == lltok::Metadata) {
1420 if (ParseInlineMetadata(V, PFS))
1421 return true;
1422 } else {
1423 if (ParseOptionalAttrs(ArgAttrs1, 0) ||
1424 ParseValue(ArgTy, V, PFS) ||
1425 // FIXME: Should not allow attributes after the argument, remove this
1426 // in LLVM 3.0.
1427 ParseOptionalAttrs(ArgAttrs2, 3))
1428 return true;
1429 }
| 1395 // Otherwise, handle normal operands.
1396 if (ParseOptionalAttrs(ArgAttrs1, 0) ||
1397 ParseValue(ArgTy, V, PFS) ||
1398 // FIXME: Should not allow attributes after the argument, remove this
1399 // in LLVM 3.0.
1400 ParseOptionalAttrs(ArgAttrs2, 3))
1401 return true;
|
1430 ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2));
1431 }
1432
1433 Lex.Lex(); // Lex the ')'.
1434 return false;
1435}
1436
1437
1438
1439/// ParseArgumentList - Parse the argument list for a function type or function
1440/// prototype. If 'inType' is true then we are parsing a FunctionType.
1441/// ::= '(' ArgTypeListI ')'
1442/// ArgTypeListI
1443/// ::= /*empty*/
1444/// ::= '...'
1445/// ::= ArgTypeList ',' '...'
1446/// ::= ArgType (',' ArgType)*
1447///
1448bool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList,
1449 bool &isVarArg, bool inType) {
1450 isVarArg = false;
1451 assert(Lex.getKind() == lltok::lparen);
1452 Lex.Lex(); // eat the (.
1453
1454 if (Lex.getKind() == lltok::rparen) {
1455 // empty
1456 } else if (Lex.getKind() == lltok::dotdotdot) {
1457 isVarArg = true;
1458 Lex.Lex();
1459 } else {
1460 LocTy TypeLoc = Lex.getLoc();
1461 PATypeHolder ArgTy(Type::getVoidTy(Context));
1462 unsigned Attrs;
1463 std::string Name;
1464
1465 // If we're parsing a type, use ParseTypeRec, because we allow recursive
1466 // types (such as a function returning a pointer to itself). If parsing a
1467 // function prototype, we require fully resolved types.
1468 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1469 ParseOptionalAttrs(Attrs, 0)) return true;
1470
1471 if (ArgTy->isVoidTy())
1472 return Error(TypeLoc, "argument can not have void type");
1473
1474 if (Lex.getKind() == lltok::LocalVar ||
1475 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1476 Name = Lex.getStrVal();
1477 Lex.Lex();
1478 }
1479
1480 if (!FunctionType::isValidArgumentType(ArgTy))
1481 return Error(TypeLoc, "invalid type for function argument");
1482
1483 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1484
1485 while (EatIfPresent(lltok::comma)) {
1486 // Handle ... at end of arg list.
1487 if (EatIfPresent(lltok::dotdotdot)) {
1488 isVarArg = true;
1489 break;
1490 }
1491
1492 // Otherwise must be an argument type.
1493 TypeLoc = Lex.getLoc();
1494 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1495 ParseOptionalAttrs(Attrs, 0)) return true;
1496
1497 if (ArgTy->isVoidTy())
1498 return Error(TypeLoc, "argument can not have void type");
1499
1500 if (Lex.getKind() == lltok::LocalVar ||
1501 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1502 Name = Lex.getStrVal();
1503 Lex.Lex();
1504 } else {
1505 Name = "";
1506 }
1507
1508 if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy))
1509 return Error(TypeLoc, "invalid type for function argument");
1510
1511 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1512 }
1513 }
1514
1515 return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1516}
1517
1518/// ParseFunctionType
1519/// ::= Type ArgumentList OptionalAttrs
1520bool LLParser::ParseFunctionType(PATypeHolder &Result) {
1521 assert(Lex.getKind() == lltok::lparen);
1522
1523 if (!FunctionType::isValidReturnType(Result))
1524 return TokError("invalid function return type");
1525
1526 std::vector<ArgInfo> ArgList;
1527 bool isVarArg;
1528 unsigned Attrs;
1529 if (ParseArgumentList(ArgList, isVarArg, true) ||
1530 // FIXME: Allow, but ignore attributes on function types!
1531 // FIXME: Remove in LLVM 3.0
1532 ParseOptionalAttrs(Attrs, 2))
1533 return true;
1534
1535 // Reject names on the arguments lists.
1536 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
1537 if (!ArgList[i].Name.empty())
1538 return Error(ArgList[i].Loc, "argument name invalid in function type");
1539 if (!ArgList[i].Attrs != 0) {
1540 // Allow but ignore attributes on function types; this permits
1541 // auto-upgrade.
1542 // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0
1543 }
1544 }
1545
1546 std::vector<const Type*> ArgListTy;
1547 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
1548 ArgListTy.push_back(ArgList[i].Type);
1549
1550 Result = HandleUpRefs(FunctionType::get(Result.get(),
1551 ArgListTy, isVarArg));
1552 return false;
1553}
1554
1555/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere.
1556/// TypeRec
1557/// ::= '{' '}'
1558/// ::= '{' TypeRec (',' TypeRec)* '}'
1559/// ::= '<' '{' '}' '>'
1560/// ::= '<' '{' TypeRec (',' TypeRec)* '}' '>'
1561bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
1562 assert(Lex.getKind() == lltok::lbrace);
1563 Lex.Lex(); // Consume the '{'
1564
1565 if (EatIfPresent(lltok::rbrace)) {
1566 Result = StructType::get(Context, Packed);
1567 return false;
1568 }
1569
1570 std::vector<PATypeHolder> ParamsList;
1571 LocTy EltTyLoc = Lex.getLoc();
1572 if (ParseTypeRec(Result)) return true;
1573 ParamsList.push_back(Result);
1574
1575 if (Result->isVoidTy())
1576 return Error(EltTyLoc, "struct element can not have void type");
1577 if (!StructType::isValidElementType(Result))
1578 return Error(EltTyLoc, "invalid element type for struct");
1579
1580 while (EatIfPresent(lltok::comma)) {
1581 EltTyLoc = Lex.getLoc();
1582 if (ParseTypeRec(Result)) return true;
1583
1584 if (Result->isVoidTy())
1585 return Error(EltTyLoc, "struct element can not have void type");
1586 if (!StructType::isValidElementType(Result))
1587 return Error(EltTyLoc, "invalid element type for struct");
1588
1589 ParamsList.push_back(Result);
1590 }
1591
1592 if (ParseToken(lltok::rbrace, "expected '}' at end of struct"))
1593 return true;
1594
1595 std::vector<const Type*> ParamsListTy;
1596 for (unsigned i = 0, e = ParamsList.size(); i != e; ++i)
1597 ParamsListTy.push_back(ParamsList[i].get());
1598 Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed));
1599 return false;
1600}
1601
1602/// ParseArrayVectorType - Parse an array or vector type, assuming the first
1603/// token has already been consumed.
1604/// TypeRec
1605/// ::= '[' APSINTVAL 'x' Types ']'
1606/// ::= '<' APSINTVAL 'x' Types '>'
1607bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) {
1608 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
1609 Lex.getAPSIntVal().getBitWidth() > 64)
1610 return TokError("expected number in address space");
1611
1612 LocTy SizeLoc = Lex.getLoc();
1613 uint64_t Size = Lex.getAPSIntVal().getZExtValue();
1614 Lex.Lex();
1615
1616 if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
1617 return true;
1618
1619 LocTy TypeLoc = Lex.getLoc();
1620 PATypeHolder EltTy(Type::getVoidTy(Context));
1621 if (ParseTypeRec(EltTy)) return true;
1622
1623 if (EltTy->isVoidTy())
1624 return Error(TypeLoc, "array and vector element type cannot be void");
1625
1626 if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
1627 "expected end of sequential type"))
1628 return true;
1629
1630 if (isVector) {
1631 if (Size == 0)
1632 return Error(SizeLoc, "zero element vector is illegal");
1633 if ((unsigned)Size != Size)
1634 return Error(SizeLoc, "size too large for vector");
1635 if (!VectorType::isValidElementType(EltTy))
1636 return Error(TypeLoc, "vector element type must be fp or integer");
1637 Result = VectorType::get(EltTy, unsigned(Size));
1638 } else {
1639 if (!ArrayType::isValidElementType(EltTy))
1640 return Error(TypeLoc, "invalid array element type");
1641 Result = HandleUpRefs(ArrayType::get(EltTy, Size));
1642 }
1643 return false;
1644}
1645
1646//===----------------------------------------------------------------------===//
1647// Function Semantic Analysis.
1648//===----------------------------------------------------------------------===//
1649
1650LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
1651 int functionNumber)
1652 : P(p), F(f), FunctionNumber(functionNumber) {
1653
1654 // Insert unnamed arguments into the NumberedVals list.
1655 for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
1656 AI != E; ++AI)
1657 if (!AI->hasName())
1658 NumberedVals.push_back(AI);
1659}
1660
1661LLParser::PerFunctionState::~PerFunctionState() {
1662 // If there were any forward referenced non-basicblock values, delete them.
1663 for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
1664 I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
1665 if (!isa<BasicBlock>(I->second.first)) {
1666 I->second.first->replaceAllUsesWith(
1667 UndefValue::get(I->second.first->getType()));
1668 delete I->second.first;
1669 I->second.first = 0;
1670 }
1671
1672 for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1673 I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
1674 if (!isa<BasicBlock>(I->second.first)) {
1675 I->second.first->replaceAllUsesWith(
1676 UndefValue::get(I->second.first->getType()));
1677 delete I->second.first;
1678 I->second.first = 0;
1679 }
1680}
1681
1682bool LLParser::PerFunctionState::FinishFunction() {
1683 // Check to see if someone took the address of labels in this block.
1684 if (!P.ForwardRefBlockAddresses.empty()) {
1685 ValID FunctionID;
1686 if (!F.getName().empty()) {
1687 FunctionID.Kind = ValID::t_GlobalName;
1688 FunctionID.StrVal = F.getName();
1689 } else {
1690 FunctionID.Kind = ValID::t_GlobalID;
1691 FunctionID.UIntVal = FunctionNumber;
1692 }
1693
1694 std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator
1695 FRBAI = P.ForwardRefBlockAddresses.find(FunctionID);
1696 if (FRBAI != P.ForwardRefBlockAddresses.end()) {
1697 // Resolve all these references.
1698 if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this))
1699 return true;
1700
1701 P.ForwardRefBlockAddresses.erase(FRBAI);
1702 }
1703 }
1704
1705 if (!ForwardRefVals.empty())
1706 return P.Error(ForwardRefVals.begin()->second.second,
1707 "use of undefined value '%" + ForwardRefVals.begin()->first +
1708 "'");
1709 if (!ForwardRefValIDs.empty())
1710 return P.Error(ForwardRefValIDs.begin()->second.second,
1711 "use of undefined value '%" +
1712 utostr(ForwardRefValIDs.begin()->first) + "'");
1713 return false;
1714}
1715
1716
1717/// GetVal - Get a value with the specified name or ID, creating a
1718/// forward reference record if needed. This can return null if the value
1719/// exists but does not have the right type.
1720Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
1721 const Type *Ty, LocTy Loc) {
1722 // Look this name up in the normal function symbol table.
1723 Value *Val = F.getValueSymbolTable().lookup(Name);
1724
1725 // If this is a forward reference for the value, see if we already created a
1726 // forward ref record.
1727 if (Val == 0) {
1728 std::map<std::string, std::pair<Value*, LocTy> >::iterator
1729 I = ForwardRefVals.find(Name);
1730 if (I != ForwardRefVals.end())
1731 Val = I->second.first;
1732 }
1733
1734 // If we have the value in the symbol table or fwd-ref table, return it.
1735 if (Val) {
1736 if (Val->getType() == Ty) return Val;
1737 if (Ty->isLabelTy())
1738 P.Error(Loc, "'%" + Name + "' is not a basic block");
1739 else
1740 P.Error(Loc, "'%" + Name + "' defined with type '" +
1741 Val->getType()->getDescription() + "'");
1742 return 0;
1743 }
1744
1745 // Don't make placeholders with invalid type.
1746 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1747 Ty != Type::getLabelTy(F.getContext())) {
1748 P.Error(Loc, "invalid use of a non-first-class type");
1749 return 0;
1750 }
1751
1752 // Otherwise, create a new forward reference for this value and remember it.
1753 Value *FwdVal;
1754 if (Ty->isLabelTy())
1755 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
1756 else
1757 FwdVal = new Argument(Ty, Name);
1758
1759 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1760 return FwdVal;
1761}
1762
1763Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty,
1764 LocTy Loc) {
1765 // Look this name up in the normal function symbol table.
1766 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
1767
1768 // If this is a forward reference for the value, see if we already created a
1769 // forward ref record.
1770 if (Val == 0) {
1771 std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1772 I = ForwardRefValIDs.find(ID);
1773 if (I != ForwardRefValIDs.end())
1774 Val = I->second.first;
1775 }
1776
1777 // If we have the value in the symbol table or fwd-ref table, return it.
1778 if (Val) {
1779 if (Val->getType() == Ty) return Val;
1780 if (Ty->isLabelTy())
1781 P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block");
1782 else
1783 P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" +
1784 Val->getType()->getDescription() + "'");
1785 return 0;
1786 }
1787
1788 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1789 Ty != Type::getLabelTy(F.getContext())) {
1790 P.Error(Loc, "invalid use of a non-first-class type");
1791 return 0;
1792 }
1793
1794 // Otherwise, create a new forward reference for this value and remember it.
1795 Value *FwdVal;
1796 if (Ty->isLabelTy())
1797 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
1798 else
1799 FwdVal = new Argument(Ty);
1800
1801 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1802 return FwdVal;
1803}
1804
1805/// SetInstName - After an instruction is parsed and inserted into its
1806/// basic block, this installs its name.
1807bool LLParser::PerFunctionState::SetInstName(int NameID,
1808 const std::string &NameStr,
1809 LocTy NameLoc, Instruction *Inst) {
1810 // If this instruction has void type, it cannot have a name or ID specified.
1811 if (Inst->getType()->isVoidTy()) {
1812 if (NameID != -1 || !NameStr.empty())
1813 return P.Error(NameLoc, "instructions returning void cannot have a name");
1814 return false;
1815 }
1816
1817 // If this was a numbered instruction, verify that the instruction is the
1818 // expected value and resolve any forward references.
1819 if (NameStr.empty()) {
1820 // If neither a name nor an ID was specified, just use the next ID.
1821 if (NameID == -1)
1822 NameID = NumberedVals.size();
1823
1824 if (unsigned(NameID) != NumberedVals.size())
1825 return P.Error(NameLoc, "instruction expected to be numbered '%" +
1826 utostr(NumberedVals.size()) + "'");
1827
1828 std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
1829 ForwardRefValIDs.find(NameID);
1830 if (FI != ForwardRefValIDs.end()) {
1831 if (FI->second.first->getType() != Inst->getType())
1832 return P.Error(NameLoc, "instruction forward referenced with type '" +
1833 FI->second.first->getType()->getDescription() + "'");
1834 FI->second.first->replaceAllUsesWith(Inst);
1835 delete FI->second.first;
1836 ForwardRefValIDs.erase(FI);
1837 }
1838
1839 NumberedVals.push_back(Inst);
1840 return false;
1841 }
1842
1843 // Otherwise, the instruction had a name. Resolve forward refs and set it.
1844 std::map<std::string, std::pair<Value*, LocTy> >::iterator
1845 FI = ForwardRefVals.find(NameStr);
1846 if (FI != ForwardRefVals.end()) {
1847 if (FI->second.first->getType() != Inst->getType())
1848 return P.Error(NameLoc, "instruction forward referenced with type '" +
1849 FI->second.first->getType()->getDescription() + "'");
1850 FI->second.first->replaceAllUsesWith(Inst);
1851 delete FI->second.first;
1852 ForwardRefVals.erase(FI);
1853 }
1854
1855 // Set the name on the instruction.
1856 Inst->setName(NameStr);
1857
1858 if (Inst->getNameStr() != NameStr)
1859 return P.Error(NameLoc, "multiple definition of local value named '" +
1860 NameStr + "'");
1861 return false;
1862}
1863
1864/// GetBB - Get a basic block with the specified name or ID, creating a
1865/// forward reference record if needed.
1866BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
1867 LocTy Loc) {
1868 return cast_or_null<BasicBlock>(GetVal(Name,
1869 Type::getLabelTy(F.getContext()), Loc));
1870}
1871
1872BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
1873 return cast_or_null<BasicBlock>(GetVal(ID,
1874 Type::getLabelTy(F.getContext()), Loc));
1875}
1876
1877/// DefineBB - Define the specified basic block, which is either named or
1878/// unnamed. If there is an error, this returns null otherwise it returns
1879/// the block being defined.
1880BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
1881 LocTy Loc) {
1882 BasicBlock *BB;
1883 if (Name.empty())
1884 BB = GetBB(NumberedVals.size(), Loc);
1885 else
1886 BB = GetBB(Name, Loc);
1887 if (BB == 0) return 0; // Already diagnosed error.
1888
1889 // Move the block to the end of the function. Forward ref'd blocks are
1890 // inserted wherever they happen to be referenced.
1891 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
1892
1893 // Remove the block from forward ref sets.
1894 if (Name.empty()) {
1895 ForwardRefValIDs.erase(NumberedVals.size());
1896 NumberedVals.push_back(BB);
1897 } else {
1898 // BB forward references are already in the function symbol table.
1899 ForwardRefVals.erase(Name);
1900 }
1901
1902 return BB;
1903}
1904
1905//===----------------------------------------------------------------------===//
1906// Constants.
1907//===----------------------------------------------------------------------===//
1908
1909/// ParseValID - Parse an abstract value that doesn't necessarily have a
1910/// type implied. For example, if we parse "4" we don't know what integer type
1911/// it has. The value will later be combined with its type and checked for
1912/// sanity.
1913bool LLParser::ParseValID(ValID &ID) {
1914 ID.Loc = Lex.getLoc();
1915 switch (Lex.getKind()) {
1916 default: return TokError("expected value token");
1917 case lltok::GlobalID: // @42
1918 ID.UIntVal = Lex.getUIntVal();
1919 ID.Kind = ValID::t_GlobalID;
1920 break;
1921 case lltok::GlobalVar: // @foo
1922 ID.StrVal = Lex.getStrVal();
1923 ID.Kind = ValID::t_GlobalName;
1924 break;
1925 case lltok::LocalVarID: // %42
1926 ID.UIntVal = Lex.getUIntVal();
1927 ID.Kind = ValID::t_LocalID;
1928 break;
1929 case lltok::LocalVar: // %foo
1930 case lltok::StringConstant: // "foo" - FIXME: REMOVE IN LLVM 3.0
1931 ID.StrVal = Lex.getStrVal();
1932 ID.Kind = ValID::t_LocalName;
1933 break;
| 1402 ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2));
1403 }
1404
1405 Lex.Lex(); // Lex the ')'.
1406 return false;
1407}
1408
1409
1410
1411/// ParseArgumentList - Parse the argument list for a function type or function
1412/// prototype. If 'inType' is true then we are parsing a FunctionType.
1413/// ::= '(' ArgTypeListI ')'
1414/// ArgTypeListI
1415/// ::= /*empty*/
1416/// ::= '...'
1417/// ::= ArgTypeList ',' '...'
1418/// ::= ArgType (',' ArgType)*
1419///
1420bool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList,
1421 bool &isVarArg, bool inType) {
1422 isVarArg = false;
1423 assert(Lex.getKind() == lltok::lparen);
1424 Lex.Lex(); // eat the (.
1425
1426 if (Lex.getKind() == lltok::rparen) {
1427 // empty
1428 } else if (Lex.getKind() == lltok::dotdotdot) {
1429 isVarArg = true;
1430 Lex.Lex();
1431 } else {
1432 LocTy TypeLoc = Lex.getLoc();
1433 PATypeHolder ArgTy(Type::getVoidTy(Context));
1434 unsigned Attrs;
1435 std::string Name;
1436
1437 // If we're parsing a type, use ParseTypeRec, because we allow recursive
1438 // types (such as a function returning a pointer to itself). If parsing a
1439 // function prototype, we require fully resolved types.
1440 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1441 ParseOptionalAttrs(Attrs, 0)) return true;
1442
1443 if (ArgTy->isVoidTy())
1444 return Error(TypeLoc, "argument can not have void type");
1445
1446 if (Lex.getKind() == lltok::LocalVar ||
1447 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1448 Name = Lex.getStrVal();
1449 Lex.Lex();
1450 }
1451
1452 if (!FunctionType::isValidArgumentType(ArgTy))
1453 return Error(TypeLoc, "invalid type for function argument");
1454
1455 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1456
1457 while (EatIfPresent(lltok::comma)) {
1458 // Handle ... at end of arg list.
1459 if (EatIfPresent(lltok::dotdotdot)) {
1460 isVarArg = true;
1461 break;
1462 }
1463
1464 // Otherwise must be an argument type.
1465 TypeLoc = Lex.getLoc();
1466 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1467 ParseOptionalAttrs(Attrs, 0)) return true;
1468
1469 if (ArgTy->isVoidTy())
1470 return Error(TypeLoc, "argument can not have void type");
1471
1472 if (Lex.getKind() == lltok::LocalVar ||
1473 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1474 Name = Lex.getStrVal();
1475 Lex.Lex();
1476 } else {
1477 Name = "";
1478 }
1479
1480 if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy))
1481 return Error(TypeLoc, "invalid type for function argument");
1482
1483 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1484 }
1485 }
1486
1487 return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1488}
1489
1490/// ParseFunctionType
1491/// ::= Type ArgumentList OptionalAttrs
1492bool LLParser::ParseFunctionType(PATypeHolder &Result) {
1493 assert(Lex.getKind() == lltok::lparen);
1494
1495 if (!FunctionType::isValidReturnType(Result))
1496 return TokError("invalid function return type");
1497
1498 std::vector<ArgInfo> ArgList;
1499 bool isVarArg;
1500 unsigned Attrs;
1501 if (ParseArgumentList(ArgList, isVarArg, true) ||
1502 // FIXME: Allow, but ignore attributes on function types!
1503 // FIXME: Remove in LLVM 3.0
1504 ParseOptionalAttrs(Attrs, 2))
1505 return true;
1506
1507 // Reject names on the arguments lists.
1508 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
1509 if (!ArgList[i].Name.empty())
1510 return Error(ArgList[i].Loc, "argument name invalid in function type");
1511 if (!ArgList[i].Attrs != 0) {
1512 // Allow but ignore attributes on function types; this permits
1513 // auto-upgrade.
1514 // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0
1515 }
1516 }
1517
1518 std::vector<const Type*> ArgListTy;
1519 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
1520 ArgListTy.push_back(ArgList[i].Type);
1521
1522 Result = HandleUpRefs(FunctionType::get(Result.get(),
1523 ArgListTy, isVarArg));
1524 return false;
1525}
1526
1527/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere.
1528/// TypeRec
1529/// ::= '{' '}'
1530/// ::= '{' TypeRec (',' TypeRec)* '}'
1531/// ::= '<' '{' '}' '>'
1532/// ::= '<' '{' TypeRec (',' TypeRec)* '}' '>'
1533bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
1534 assert(Lex.getKind() == lltok::lbrace);
1535 Lex.Lex(); // Consume the '{'
1536
1537 if (EatIfPresent(lltok::rbrace)) {
1538 Result = StructType::get(Context, Packed);
1539 return false;
1540 }
1541
1542 std::vector<PATypeHolder> ParamsList;
1543 LocTy EltTyLoc = Lex.getLoc();
1544 if (ParseTypeRec(Result)) return true;
1545 ParamsList.push_back(Result);
1546
1547 if (Result->isVoidTy())
1548 return Error(EltTyLoc, "struct element can not have void type");
1549 if (!StructType::isValidElementType(Result))
1550 return Error(EltTyLoc, "invalid element type for struct");
1551
1552 while (EatIfPresent(lltok::comma)) {
1553 EltTyLoc = Lex.getLoc();
1554 if (ParseTypeRec(Result)) return true;
1555
1556 if (Result->isVoidTy())
1557 return Error(EltTyLoc, "struct element can not have void type");
1558 if (!StructType::isValidElementType(Result))
1559 return Error(EltTyLoc, "invalid element type for struct");
1560
1561 ParamsList.push_back(Result);
1562 }
1563
1564 if (ParseToken(lltok::rbrace, "expected '}' at end of struct"))
1565 return true;
1566
1567 std::vector<const Type*> ParamsListTy;
1568 for (unsigned i = 0, e = ParamsList.size(); i != e; ++i)
1569 ParamsListTy.push_back(ParamsList[i].get());
1570 Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed));
1571 return false;
1572}
1573
1574/// ParseArrayVectorType - Parse an array or vector type, assuming the first
1575/// token has already been consumed.
1576/// TypeRec
1577/// ::= '[' APSINTVAL 'x' Types ']'
1578/// ::= '<' APSINTVAL 'x' Types '>'
1579bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) {
1580 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
1581 Lex.getAPSIntVal().getBitWidth() > 64)
1582 return TokError("expected number in address space");
1583
1584 LocTy SizeLoc = Lex.getLoc();
1585 uint64_t Size = Lex.getAPSIntVal().getZExtValue();
1586 Lex.Lex();
1587
1588 if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
1589 return true;
1590
1591 LocTy TypeLoc = Lex.getLoc();
1592 PATypeHolder EltTy(Type::getVoidTy(Context));
1593 if (ParseTypeRec(EltTy)) return true;
1594
1595 if (EltTy->isVoidTy())
1596 return Error(TypeLoc, "array and vector element type cannot be void");
1597
1598 if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
1599 "expected end of sequential type"))
1600 return true;
1601
1602 if (isVector) {
1603 if (Size == 0)
1604 return Error(SizeLoc, "zero element vector is illegal");
1605 if ((unsigned)Size != Size)
1606 return Error(SizeLoc, "size too large for vector");
1607 if (!VectorType::isValidElementType(EltTy))
1608 return Error(TypeLoc, "vector element type must be fp or integer");
1609 Result = VectorType::get(EltTy, unsigned(Size));
1610 } else {
1611 if (!ArrayType::isValidElementType(EltTy))
1612 return Error(TypeLoc, "invalid array element type");
1613 Result = HandleUpRefs(ArrayType::get(EltTy, Size));
1614 }
1615 return false;
1616}
1617
1618//===----------------------------------------------------------------------===//
1619// Function Semantic Analysis.
1620//===----------------------------------------------------------------------===//
1621
1622LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
1623 int functionNumber)
1624 : P(p), F(f), FunctionNumber(functionNumber) {
1625
1626 // Insert unnamed arguments into the NumberedVals list.
1627 for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
1628 AI != E; ++AI)
1629 if (!AI->hasName())
1630 NumberedVals.push_back(AI);
1631}
1632
1633LLParser::PerFunctionState::~PerFunctionState() {
1634 // If there were any forward referenced non-basicblock values, delete them.
1635 for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
1636 I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
1637 if (!isa<BasicBlock>(I->second.first)) {
1638 I->second.first->replaceAllUsesWith(
1639 UndefValue::get(I->second.first->getType()));
1640 delete I->second.first;
1641 I->second.first = 0;
1642 }
1643
1644 for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1645 I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
1646 if (!isa<BasicBlock>(I->second.first)) {
1647 I->second.first->replaceAllUsesWith(
1648 UndefValue::get(I->second.first->getType()));
1649 delete I->second.first;
1650 I->second.first = 0;
1651 }
1652}
1653
1654bool LLParser::PerFunctionState::FinishFunction() {
1655 // Check to see if someone took the address of labels in this block.
1656 if (!P.ForwardRefBlockAddresses.empty()) {
1657 ValID FunctionID;
1658 if (!F.getName().empty()) {
1659 FunctionID.Kind = ValID::t_GlobalName;
1660 FunctionID.StrVal = F.getName();
1661 } else {
1662 FunctionID.Kind = ValID::t_GlobalID;
1663 FunctionID.UIntVal = FunctionNumber;
1664 }
1665
1666 std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator
1667 FRBAI = P.ForwardRefBlockAddresses.find(FunctionID);
1668 if (FRBAI != P.ForwardRefBlockAddresses.end()) {
1669 // Resolve all these references.
1670 if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this))
1671 return true;
1672
1673 P.ForwardRefBlockAddresses.erase(FRBAI);
1674 }
1675 }
1676
1677 if (!ForwardRefVals.empty())
1678 return P.Error(ForwardRefVals.begin()->second.second,
1679 "use of undefined value '%" + ForwardRefVals.begin()->first +
1680 "'");
1681 if (!ForwardRefValIDs.empty())
1682 return P.Error(ForwardRefValIDs.begin()->second.second,
1683 "use of undefined value '%" +
1684 utostr(ForwardRefValIDs.begin()->first) + "'");
1685 return false;
1686}
1687
1688
1689/// GetVal - Get a value with the specified name or ID, creating a
1690/// forward reference record if needed. This can return null if the value
1691/// exists but does not have the right type.
1692Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
1693 const Type *Ty, LocTy Loc) {
1694 // Look this name up in the normal function symbol table.
1695 Value *Val = F.getValueSymbolTable().lookup(Name);
1696
1697 // If this is a forward reference for the value, see if we already created a
1698 // forward ref record.
1699 if (Val == 0) {
1700 std::map<std::string, std::pair<Value*, LocTy> >::iterator
1701 I = ForwardRefVals.find(Name);
1702 if (I != ForwardRefVals.end())
1703 Val = I->second.first;
1704 }
1705
1706 // If we have the value in the symbol table or fwd-ref table, return it.
1707 if (Val) {
1708 if (Val->getType() == Ty) return Val;
1709 if (Ty->isLabelTy())
1710 P.Error(Loc, "'%" + Name + "' is not a basic block");
1711 else
1712 P.Error(Loc, "'%" + Name + "' defined with type '" +
1713 Val->getType()->getDescription() + "'");
1714 return 0;
1715 }
1716
1717 // Don't make placeholders with invalid type.
1718 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1719 Ty != Type::getLabelTy(F.getContext())) {
1720 P.Error(Loc, "invalid use of a non-first-class type");
1721 return 0;
1722 }
1723
1724 // Otherwise, create a new forward reference for this value and remember it.
1725 Value *FwdVal;
1726 if (Ty->isLabelTy())
1727 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
1728 else
1729 FwdVal = new Argument(Ty, Name);
1730
1731 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1732 return FwdVal;
1733}
1734
1735Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty,
1736 LocTy Loc) {
1737 // Look this name up in the normal function symbol table.
1738 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
1739
1740 // If this is a forward reference for the value, see if we already created a
1741 // forward ref record.
1742 if (Val == 0) {
1743 std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1744 I = ForwardRefValIDs.find(ID);
1745 if (I != ForwardRefValIDs.end())
1746 Val = I->second.first;
1747 }
1748
1749 // If we have the value in the symbol table or fwd-ref table, return it.
1750 if (Val) {
1751 if (Val->getType() == Ty) return Val;
1752 if (Ty->isLabelTy())
1753 P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block");
1754 else
1755 P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" +
1756 Val->getType()->getDescription() + "'");
1757 return 0;
1758 }
1759
1760 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1761 Ty != Type::getLabelTy(F.getContext())) {
1762 P.Error(Loc, "invalid use of a non-first-class type");
1763 return 0;
1764 }
1765
1766 // Otherwise, create a new forward reference for this value and remember it.
1767 Value *FwdVal;
1768 if (Ty->isLabelTy())
1769 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
1770 else
1771 FwdVal = new Argument(Ty);
1772
1773 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1774 return FwdVal;
1775}
1776
1777/// SetInstName - After an instruction is parsed and inserted into its
1778/// basic block, this installs its name.
1779bool LLParser::PerFunctionState::SetInstName(int NameID,
1780 const std::string &NameStr,
1781 LocTy NameLoc, Instruction *Inst) {
1782 // If this instruction has void type, it cannot have a name or ID specified.
1783 if (Inst->getType()->isVoidTy()) {
1784 if (NameID != -1 || !NameStr.empty())
1785 return P.Error(NameLoc, "instructions returning void cannot have a name");
1786 return false;
1787 }
1788
1789 // If this was a numbered instruction, verify that the instruction is the
1790 // expected value and resolve any forward references.
1791 if (NameStr.empty()) {
1792 // If neither a name nor an ID was specified, just use the next ID.
1793 if (NameID == -1)
1794 NameID = NumberedVals.size();
1795
1796 if (unsigned(NameID) != NumberedVals.size())
1797 return P.Error(NameLoc, "instruction expected to be numbered '%" +
1798 utostr(NumberedVals.size()) + "'");
1799
1800 std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
1801 ForwardRefValIDs.find(NameID);
1802 if (FI != ForwardRefValIDs.end()) {
1803 if (FI->second.first->getType() != Inst->getType())
1804 return P.Error(NameLoc, "instruction forward referenced with type '" +
1805 FI->second.first->getType()->getDescription() + "'");
1806 FI->second.first->replaceAllUsesWith(Inst);
1807 delete FI->second.first;
1808 ForwardRefValIDs.erase(FI);
1809 }
1810
1811 NumberedVals.push_back(Inst);
1812 return false;
1813 }
1814
1815 // Otherwise, the instruction had a name. Resolve forward refs and set it.
1816 std::map<std::string, std::pair<Value*, LocTy> >::iterator
1817 FI = ForwardRefVals.find(NameStr);
1818 if (FI != ForwardRefVals.end()) {
1819 if (FI->second.first->getType() != Inst->getType())
1820 return P.Error(NameLoc, "instruction forward referenced with type '" +
1821 FI->second.first->getType()->getDescription() + "'");
1822 FI->second.first->replaceAllUsesWith(Inst);
1823 delete FI->second.first;
1824 ForwardRefVals.erase(FI);
1825 }
1826
1827 // Set the name on the instruction.
1828 Inst->setName(NameStr);
1829
1830 if (Inst->getNameStr() != NameStr)
1831 return P.Error(NameLoc, "multiple definition of local value named '" +
1832 NameStr + "'");
1833 return false;
1834}
1835
1836/// GetBB - Get a basic block with the specified name or ID, creating a
1837/// forward reference record if needed.
1838BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
1839 LocTy Loc) {
1840 return cast_or_null<BasicBlock>(GetVal(Name,
1841 Type::getLabelTy(F.getContext()), Loc));
1842}
1843
1844BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
1845 return cast_or_null<BasicBlock>(GetVal(ID,
1846 Type::getLabelTy(F.getContext()), Loc));
1847}
1848
1849/// DefineBB - Define the specified basic block, which is either named or
1850/// unnamed. If there is an error, this returns null otherwise it returns
1851/// the block being defined.
1852BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
1853 LocTy Loc) {
1854 BasicBlock *BB;
1855 if (Name.empty())
1856 BB = GetBB(NumberedVals.size(), Loc);
1857 else
1858 BB = GetBB(Name, Loc);
1859 if (BB == 0) return 0; // Already diagnosed error.
1860
1861 // Move the block to the end of the function. Forward ref'd blocks are
1862 // inserted wherever they happen to be referenced.
1863 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
1864
1865 // Remove the block from forward ref sets.
1866 if (Name.empty()) {
1867 ForwardRefValIDs.erase(NumberedVals.size());
1868 NumberedVals.push_back(BB);
1869 } else {
1870 // BB forward references are already in the function symbol table.
1871 ForwardRefVals.erase(Name);
1872 }
1873
1874 return BB;
1875}
1876
1877//===----------------------------------------------------------------------===//
1878// Constants.
1879//===----------------------------------------------------------------------===//
1880
1881/// ParseValID - Parse an abstract value that doesn't necessarily have a
1882/// type implied. For example, if we parse "4" we don't know what integer type
1883/// it has. The value will later be combined with its type and checked for
1884/// sanity.
1885bool LLParser::ParseValID(ValID &ID) {
1886 ID.Loc = Lex.getLoc();
1887 switch (Lex.getKind()) {
1888 default: return TokError("expected value token");
1889 case lltok::GlobalID: // @42
1890 ID.UIntVal = Lex.getUIntVal();
1891 ID.Kind = ValID::t_GlobalID;
1892 break;
1893 case lltok::GlobalVar: // @foo
1894 ID.StrVal = Lex.getStrVal();
1895 ID.Kind = ValID::t_GlobalName;
1896 break;
1897 case lltok::LocalVarID: // %42
1898 ID.UIntVal = Lex.getUIntVal();
1899 ID.Kind = ValID::t_LocalID;
1900 break;
1901 case lltok::LocalVar: // %foo
1902 case lltok::StringConstant: // "foo" - FIXME: REMOVE IN LLVM 3.0
1903 ID.StrVal = Lex.getStrVal();
1904 ID.Kind = ValID::t_LocalName;
1905 break;
|
1934 case lltok::Metadata: { // !{...} MDNode, !"foo" MDString
1935 ID.Kind = ValID::t_Metadata;
| 1906 case lltok::exclaim: // !{...} MDNode, !"foo" MDString
|
1936 Lex.Lex();
| 1907 Lex.Lex();
|
1937 if (Lex.getKind() == lltok::lbrace) {
| 1908
1909 if (EatIfPresent(lltok::lbrace)) {
|
1938 SmallVector<Value*, 16> Elts;
1939 if (ParseMDNodeVector(Elts) ||
1940 ParseToken(lltok::rbrace, "expected end of metadata node"))
1941 return true;
1942
| 1910 SmallVector<Value*, 16> Elts;
1911 if (ParseMDNodeVector(Elts) ||
1912 ParseToken(lltok::rbrace, "expected end of metadata node"))
1913 return true;
1914
|
1943 ID.MetadataVal = MDNode::get(Context, Elts.data(), Elts.size());
| 1915 ID.MDNodeVal = MDNode::get(Context, Elts.data(), Elts.size());
1916 ID.Kind = ValID::t_MDNode;
|
1944 return false;
1945 }
1946
1947 // Standalone metadata reference
1948 // !{ ..., !42, ... }
| 1917 return false;
1918 }
1919
1920 // Standalone metadata reference
1921 // !{ ..., !42, ... }
|
1949 if (!ParseMDNode(ID.MetadataVal))
| 1922 if (Lex.getKind() == lltok::APSInt) {
1923 if (ParseMDNodeID(ID.MDNodeVal)) return true;
1924 ID.Kind = ValID::t_MDNode;
|
1950 return false;
| 1925 return false;
|
1951
| 1926 }
1927
|
1952 // MDString:
1953 // ::= '!' STRINGCONSTANT
| 1928 // MDString:
1929 // ::= '!' STRINGCONSTANT
|
1954 if (ParseMDString(ID.MetadataVal)) return true;
1955 ID.Kind = ValID::t_Metadata;
| 1930 if (ParseMDString(ID.MDStringVal)) return true;
1931 ID.Kind = ValID::t_MDString;
|
1956 return false;
| 1932 return false;
|
1957 }
| |
1958 case lltok::APSInt:
1959 ID.APSIntVal = Lex.getAPSIntVal();
1960 ID.Kind = ValID::t_APSInt;
1961 break;
1962 case lltok::APFloat:
1963 ID.APFloatVal = Lex.getAPFloatVal();
1964 ID.Kind = ValID::t_APFloat;
1965 break;
1966 case lltok::kw_true:
1967 ID.ConstantVal = ConstantInt::getTrue(Context);
1968 ID.Kind = ValID::t_Constant;
1969 break;
1970 case lltok::kw_false:
1971 ID.ConstantVal = ConstantInt::getFalse(Context);
1972 ID.Kind = ValID::t_Constant;
1973 break;
1974 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
1975 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
1976 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
1977
1978 case lltok::lbrace: {
1979 // ValID ::= '{' ConstVector '}'
1980 Lex.Lex();
1981 SmallVector<Constant*, 16> Elts;
1982 if (ParseGlobalValueVector(Elts) ||
1983 ParseToken(lltok::rbrace, "expected end of struct constant"))
1984 return true;
1985
1986 ID.ConstantVal = ConstantStruct::get(Context, Elts.data(),
1987 Elts.size(), false);
1988 ID.Kind = ValID::t_Constant;
1989 return false;
1990 }
1991 case lltok::less: {
1992 // ValID ::= '<' ConstVector '>' --> Vector.
1993 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
1994 Lex.Lex();
1995 bool isPackedStruct = EatIfPresent(lltok::lbrace);
1996
1997 SmallVector<Constant*, 16> Elts;
1998 LocTy FirstEltLoc = Lex.getLoc();
1999 if (ParseGlobalValueVector(Elts) ||
2000 (isPackedStruct &&
2001 ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2002 ParseToken(lltok::greater, "expected end of constant"))
2003 return true;
2004
2005 if (isPackedStruct) {
2006 ID.ConstantVal =
2007 ConstantStruct::get(Context, Elts.data(), Elts.size(), true);
2008 ID.Kind = ValID::t_Constant;
2009 return false;
2010 }
2011
2012 if (Elts.empty())
2013 return Error(ID.Loc, "constant vector must not be empty");
2014
2015 if (!Elts[0]->getType()->isInteger() &&
2016 !Elts[0]->getType()->isFloatingPoint())
2017 return Error(FirstEltLoc,
2018 "vector elements must have integer or floating point type");
2019
2020 // Verify that all the vector elements have the same type.
2021 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2022 if (Elts[i]->getType() != Elts[0]->getType())
2023 return Error(FirstEltLoc,
2024 "vector element #" + utostr(i) +
2025 " is not of type '" + Elts[0]->getType()->getDescription());
2026
2027 ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size());
2028 ID.Kind = ValID::t_Constant;
2029 return false;
2030 }
2031 case lltok::lsquare: { // Array Constant
2032 Lex.Lex();
2033 SmallVector<Constant*, 16> Elts;
2034 LocTy FirstEltLoc = Lex.getLoc();
2035 if (ParseGlobalValueVector(Elts) ||
2036 ParseToken(lltok::rsquare, "expected end of array constant"))
2037 return true;
2038
2039 // Handle empty element.
2040 if (Elts.empty()) {
2041 // Use undef instead of an array because it's inconvenient to determine
2042 // the element type at this point, there being no elements to examine.
2043 ID.Kind = ValID::t_EmptyArray;
2044 return false;
2045 }
2046
2047 if (!Elts[0]->getType()->isFirstClassType())
2048 return Error(FirstEltLoc, "invalid array element type: " +
2049 Elts[0]->getType()->getDescription());
2050
2051 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2052
2053 // Verify all elements are correct type!
2054 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2055 if (Elts[i]->getType() != Elts[0]->getType())
2056 return Error(FirstEltLoc,
2057 "array element #" + utostr(i) +
2058 " is not of type '" +Elts[0]->getType()->getDescription());
2059 }
2060
2061 ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size());
2062 ID.Kind = ValID::t_Constant;
2063 return false;
2064 }
2065 case lltok::kw_c: // c "foo"
2066 Lex.Lex();
2067 ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false);
2068 if (ParseToken(lltok::StringConstant, "expected string")) return true;
2069 ID.Kind = ValID::t_Constant;
2070 return false;
2071
2072 case lltok::kw_asm: {
2073 // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT
2074 bool HasSideEffect, AlignStack;
2075 Lex.Lex();
2076 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2077 ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2078 ParseStringConstant(ID.StrVal) ||
2079 ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2080 ParseToken(lltok::StringConstant, "expected constraint string"))
2081 return true;
2082 ID.StrVal2 = Lex.getStrVal();
2083 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1);
2084 ID.Kind = ValID::t_InlineAsm;
2085 return false;
2086 }
2087
2088 case lltok::kw_blockaddress: {
2089 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2090 Lex.Lex();
2091
2092 ValID Fn, Label;
2093 LocTy FnLoc, LabelLoc;
2094
2095 if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2096 ParseValID(Fn) ||
2097 ParseToken(lltok::comma, "expected comma in block address expression")||
2098 ParseValID(Label) ||
2099 ParseToken(lltok::rparen, "expected ')' in block address expression"))
2100 return true;
2101
2102 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2103 return Error(Fn.Loc, "expected function name in blockaddress");
2104 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2105 return Error(Label.Loc, "expected basic block name in blockaddress");
2106
2107 // Make a global variable as a placeholder for this reference.
2108 GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context),
2109 false, GlobalValue::InternalLinkage,
2110 0, "");
2111 ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef));
2112 ID.ConstantVal = FwdRef;
2113 ID.Kind = ValID::t_Constant;
2114 return false;
2115 }
2116
2117 case lltok::kw_trunc:
2118 case lltok::kw_zext:
2119 case lltok::kw_sext:
2120 case lltok::kw_fptrunc:
2121 case lltok::kw_fpext:
2122 case lltok::kw_bitcast:
2123 case lltok::kw_uitofp:
2124 case lltok::kw_sitofp:
2125 case lltok::kw_fptoui:
2126 case lltok::kw_fptosi:
2127 case lltok::kw_inttoptr:
2128 case lltok::kw_ptrtoint: {
2129 unsigned Opc = Lex.getUIntVal();
2130 PATypeHolder DestTy(Type::getVoidTy(Context));
2131 Constant *SrcVal;
2132 Lex.Lex();
2133 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2134 ParseGlobalTypeAndValue(SrcVal) ||
2135 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2136 ParseType(DestTy) ||
2137 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2138 return true;
2139 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2140 return Error(ID.Loc, "invalid cast opcode for cast from '" +
2141 SrcVal->getType()->getDescription() + "' to '" +
2142 DestTy->getDescription() + "'");
2143 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2144 SrcVal, DestTy);
2145 ID.Kind = ValID::t_Constant;
2146 return false;
2147 }
2148 case lltok::kw_extractvalue: {
2149 Lex.Lex();
2150 Constant *Val;
2151 SmallVector<unsigned, 4> Indices;
2152 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2153 ParseGlobalTypeAndValue(Val) ||
2154 ParseIndexList(Indices) ||
2155 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2156 return true;
| 1933 case lltok::APSInt:
1934 ID.APSIntVal = Lex.getAPSIntVal();
1935 ID.Kind = ValID::t_APSInt;
1936 break;
1937 case lltok::APFloat:
1938 ID.APFloatVal = Lex.getAPFloatVal();
1939 ID.Kind = ValID::t_APFloat;
1940 break;
1941 case lltok::kw_true:
1942 ID.ConstantVal = ConstantInt::getTrue(Context);
1943 ID.Kind = ValID::t_Constant;
1944 break;
1945 case lltok::kw_false:
1946 ID.ConstantVal = ConstantInt::getFalse(Context);
1947 ID.Kind = ValID::t_Constant;
1948 break;
1949 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
1950 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
1951 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
1952
1953 case lltok::lbrace: {
1954 // ValID ::= '{' ConstVector '}'
1955 Lex.Lex();
1956 SmallVector<Constant*, 16> Elts;
1957 if (ParseGlobalValueVector(Elts) ||
1958 ParseToken(lltok::rbrace, "expected end of struct constant"))
1959 return true;
1960
1961 ID.ConstantVal = ConstantStruct::get(Context, Elts.data(),
1962 Elts.size(), false);
1963 ID.Kind = ValID::t_Constant;
1964 return false;
1965 }
1966 case lltok::less: {
1967 // ValID ::= '<' ConstVector '>' --> Vector.
1968 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
1969 Lex.Lex();
1970 bool isPackedStruct = EatIfPresent(lltok::lbrace);
1971
1972 SmallVector<Constant*, 16> Elts;
1973 LocTy FirstEltLoc = Lex.getLoc();
1974 if (ParseGlobalValueVector(Elts) ||
1975 (isPackedStruct &&
1976 ParseToken(lltok::rbrace, "expected end of packed struct")) ||
1977 ParseToken(lltok::greater, "expected end of constant"))
1978 return true;
1979
1980 if (isPackedStruct) {
1981 ID.ConstantVal =
1982 ConstantStruct::get(Context, Elts.data(), Elts.size(), true);
1983 ID.Kind = ValID::t_Constant;
1984 return false;
1985 }
1986
1987 if (Elts.empty())
1988 return Error(ID.Loc, "constant vector must not be empty");
1989
1990 if (!Elts[0]->getType()->isInteger() &&
1991 !Elts[0]->getType()->isFloatingPoint())
1992 return Error(FirstEltLoc,
1993 "vector elements must have integer or floating point type");
1994
1995 // Verify that all the vector elements have the same type.
1996 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
1997 if (Elts[i]->getType() != Elts[0]->getType())
1998 return Error(FirstEltLoc,
1999 "vector element #" + utostr(i) +
2000 " is not of type '" + Elts[0]->getType()->getDescription());
2001
2002 ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size());
2003 ID.Kind = ValID::t_Constant;
2004 return false;
2005 }
2006 case lltok::lsquare: { // Array Constant
2007 Lex.Lex();
2008 SmallVector<Constant*, 16> Elts;
2009 LocTy FirstEltLoc = Lex.getLoc();
2010 if (ParseGlobalValueVector(Elts) ||
2011 ParseToken(lltok::rsquare, "expected end of array constant"))
2012 return true;
2013
2014 // Handle empty element.
2015 if (Elts.empty()) {
2016 // Use undef instead of an array because it's inconvenient to determine
2017 // the element type at this point, there being no elements to examine.
2018 ID.Kind = ValID::t_EmptyArray;
2019 return false;
2020 }
2021
2022 if (!Elts[0]->getType()->isFirstClassType())
2023 return Error(FirstEltLoc, "invalid array element type: " +
2024 Elts[0]->getType()->getDescription());
2025
2026 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2027
2028 // Verify all elements are correct type!
2029 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2030 if (Elts[i]->getType() != Elts[0]->getType())
2031 return Error(FirstEltLoc,
2032 "array element #" + utostr(i) +
2033 " is not of type '" +Elts[0]->getType()->getDescription());
2034 }
2035
2036 ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size());
2037 ID.Kind = ValID::t_Constant;
2038 return false;
2039 }
2040 case lltok::kw_c: // c "foo"
2041 Lex.Lex();
2042 ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false);
2043 if (ParseToken(lltok::StringConstant, "expected string")) return true;
2044 ID.Kind = ValID::t_Constant;
2045 return false;
2046
2047 case lltok::kw_asm: {
2048 // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT
2049 bool HasSideEffect, AlignStack;
2050 Lex.Lex();
2051 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2052 ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2053 ParseStringConstant(ID.StrVal) ||
2054 ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2055 ParseToken(lltok::StringConstant, "expected constraint string"))
2056 return true;
2057 ID.StrVal2 = Lex.getStrVal();
2058 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1);
2059 ID.Kind = ValID::t_InlineAsm;
2060 return false;
2061 }
2062
2063 case lltok::kw_blockaddress: {
2064 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2065 Lex.Lex();
2066
2067 ValID Fn, Label;
2068 LocTy FnLoc, LabelLoc;
2069
2070 if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2071 ParseValID(Fn) ||
2072 ParseToken(lltok::comma, "expected comma in block address expression")||
2073 ParseValID(Label) ||
2074 ParseToken(lltok::rparen, "expected ')' in block address expression"))
2075 return true;
2076
2077 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2078 return Error(Fn.Loc, "expected function name in blockaddress");
2079 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2080 return Error(Label.Loc, "expected basic block name in blockaddress");
2081
2082 // Make a global variable as a placeholder for this reference.
2083 GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context),
2084 false, GlobalValue::InternalLinkage,
2085 0, "");
2086 ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef));
2087 ID.ConstantVal = FwdRef;
2088 ID.Kind = ValID::t_Constant;
2089 return false;
2090 }
2091
2092 case lltok::kw_trunc:
2093 case lltok::kw_zext:
2094 case lltok::kw_sext:
2095 case lltok::kw_fptrunc:
2096 case lltok::kw_fpext:
2097 case lltok::kw_bitcast:
2098 case lltok::kw_uitofp:
2099 case lltok::kw_sitofp:
2100 case lltok::kw_fptoui:
2101 case lltok::kw_fptosi:
2102 case lltok::kw_inttoptr:
2103 case lltok::kw_ptrtoint: {
2104 unsigned Opc = Lex.getUIntVal();
2105 PATypeHolder DestTy(Type::getVoidTy(Context));
2106 Constant *SrcVal;
2107 Lex.Lex();
2108 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2109 ParseGlobalTypeAndValue(SrcVal) ||
2110 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2111 ParseType(DestTy) ||
2112 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2113 return true;
2114 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2115 return Error(ID.Loc, "invalid cast opcode for cast from '" +
2116 SrcVal->getType()->getDescription() + "' to '" +
2117 DestTy->getDescription() + "'");
2118 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2119 SrcVal, DestTy);
2120 ID.Kind = ValID::t_Constant;
2121 return false;
2122 }
2123 case lltok::kw_extractvalue: {
2124 Lex.Lex();
2125 Constant *Val;
2126 SmallVector<unsigned, 4> Indices;
2127 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2128 ParseGlobalTypeAndValue(Val) ||
2129 ParseIndexList(Indices) ||
2130 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2131 return true;
|
2157 if (Lex.getKind() == lltok::NamedOrCustomMD)
2158 if (ParseOptionalCustomMetadata()) return true;
| |
2159
2160 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
2161 return Error(ID.Loc, "extractvalue operand must be array or struct");
2162 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
2163 Indices.end()))
2164 return Error(ID.Loc, "invalid indices for extractvalue");
2165 ID.ConstantVal =
2166 ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size());
2167 ID.Kind = ValID::t_Constant;
2168 return false;
2169 }
2170 case lltok::kw_insertvalue: {
2171 Lex.Lex();
2172 Constant *Val0, *Val1;
2173 SmallVector<unsigned, 4> Indices;
2174 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2175 ParseGlobalTypeAndValue(Val0) ||
2176 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2177 ParseGlobalTypeAndValue(Val1) ||
2178 ParseIndexList(Indices) ||
2179 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2180 return true;
| 2132
2133 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
2134 return Error(ID.Loc, "extractvalue operand must be array or struct");
2135 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
2136 Indices.end()))
2137 return Error(ID.Loc, "invalid indices for extractvalue");
2138 ID.ConstantVal =
2139 ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size());
2140 ID.Kind = ValID::t_Constant;
2141 return false;
2142 }
2143 case lltok::kw_insertvalue: {
2144 Lex.Lex();
2145 Constant *Val0, *Val1;
2146 SmallVector<unsigned, 4> Indices;
2147 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2148 ParseGlobalTypeAndValue(Val0) ||
2149 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2150 ParseGlobalTypeAndValue(Val1) ||
2151 ParseIndexList(Indices) ||
2152 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2153 return true;
|
2181 if (Lex.getKind() == lltok::NamedOrCustomMD)
2182 if (ParseOptionalCustomMetadata()) return true;
| |
2183 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
2184 return Error(ID.Loc, "extractvalue operand must be array or struct");
2185 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
2186 Indices.end()))
2187 return Error(ID.Loc, "invalid indices for insertvalue");
2188 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1,
2189 Indices.data(), Indices.size());
2190 ID.Kind = ValID::t_Constant;
2191 return false;
2192 }
2193 case lltok::kw_icmp:
2194 case lltok::kw_fcmp: {
2195 unsigned PredVal, Opc = Lex.getUIntVal();
2196 Constant *Val0, *Val1;
2197 Lex.Lex();
2198 if (ParseCmpPredicate(PredVal, Opc) ||
2199 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2200 ParseGlobalTypeAndValue(Val0) ||
2201 ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2202 ParseGlobalTypeAndValue(Val1) ||
2203 ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2204 return true;
2205
2206 if (Val0->getType() != Val1->getType())
2207 return Error(ID.Loc, "compare operands must have the same type");
2208
2209 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2210
2211 if (Opc == Instruction::FCmp) {
2212 if (!Val0->getType()->isFPOrFPVector())
2213 return Error(ID.Loc, "fcmp requires floating point operands");
2214 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2215 } else {
2216 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2217 if (!Val0->getType()->isIntOrIntVector() &&
2218 !isa<PointerType>(Val0->getType()))
2219 return Error(ID.Loc, "icmp requires pointer or integer operands");
2220 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2221 }
2222 ID.Kind = ValID::t_Constant;
2223 return false;
2224 }
2225
2226 // Binary Operators.
2227 case lltok::kw_add:
2228 case lltok::kw_fadd:
2229 case lltok::kw_sub:
2230 case lltok::kw_fsub:
2231 case lltok::kw_mul:
2232 case lltok::kw_fmul:
2233 case lltok::kw_udiv:
2234 case lltok::kw_sdiv:
2235 case lltok::kw_fdiv:
2236 case lltok::kw_urem:
2237 case lltok::kw_srem:
2238 case lltok::kw_frem: {
2239 bool NUW = false;
2240 bool NSW = false;
2241 bool Exact = false;
2242 unsigned Opc = Lex.getUIntVal();
2243 Constant *Val0, *Val1;
2244 Lex.Lex();
2245 LocTy ModifierLoc = Lex.getLoc();
2246 if (Opc == Instruction::Add ||
2247 Opc == Instruction::Sub ||
2248 Opc == Instruction::Mul) {
2249 if (EatIfPresent(lltok::kw_nuw))
2250 NUW = true;
2251 if (EatIfPresent(lltok::kw_nsw)) {
2252 NSW = true;
2253 if (EatIfPresent(lltok::kw_nuw))
2254 NUW = true;
2255 }
2256 } else if (Opc == Instruction::SDiv) {
2257 if (EatIfPresent(lltok::kw_exact))
2258 Exact = true;
2259 }
2260 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2261 ParseGlobalTypeAndValue(Val0) ||
2262 ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2263 ParseGlobalTypeAndValue(Val1) ||
2264 ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2265 return true;
2266 if (Val0->getType() != Val1->getType())
2267 return Error(ID.Loc, "operands of constexpr must have same type");
2268 if (!Val0->getType()->isIntOrIntVector()) {
2269 if (NUW)
2270 return Error(ModifierLoc, "nuw only applies to integer operations");
2271 if (NSW)
2272 return Error(ModifierLoc, "nsw only applies to integer operations");
2273 }
2274 // API compatibility: Accept either integer or floating-point types with
2275 // add, sub, and mul.
2276 if (!Val0->getType()->isIntOrIntVector() &&
2277 !Val0->getType()->isFPOrFPVector())
2278 return Error(ID.Loc,"constexpr requires integer, fp, or vector operands");
2279 unsigned Flags = 0;
2280 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2281 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
2282 if (Exact) Flags |= SDivOperator::IsExact;
2283 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2284 ID.ConstantVal = C;
2285 ID.Kind = ValID::t_Constant;
2286 return false;
2287 }
2288
2289 // Logical Operations
2290 case lltok::kw_shl:
2291 case lltok::kw_lshr:
2292 case lltok::kw_ashr:
2293 case lltok::kw_and:
2294 case lltok::kw_or:
2295 case lltok::kw_xor: {
2296 unsigned Opc = Lex.getUIntVal();
2297 Constant *Val0, *Val1;
2298 Lex.Lex();
2299 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2300 ParseGlobalTypeAndValue(Val0) ||
2301 ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2302 ParseGlobalTypeAndValue(Val1) ||
2303 ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2304 return true;
2305 if (Val0->getType() != Val1->getType())
2306 return Error(ID.Loc, "operands of constexpr must have same type");
2307 if (!Val0->getType()->isIntOrIntVector())
2308 return Error(ID.Loc,
2309 "constexpr requires integer or integer vector operands");
2310 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2311 ID.Kind = ValID::t_Constant;
2312 return false;
2313 }
2314
2315 case lltok::kw_getelementptr:
2316 case lltok::kw_shufflevector:
2317 case lltok::kw_insertelement:
2318 case lltok::kw_extractelement:
2319 case lltok::kw_select: {
2320 unsigned Opc = Lex.getUIntVal();
2321 SmallVector<Constant*, 16> Elts;
2322 bool InBounds = false;
2323 Lex.Lex();
2324 if (Opc == Instruction::GetElementPtr)
2325 InBounds = EatIfPresent(lltok::kw_inbounds);
2326 if (ParseToken(lltok::lparen, "expected '(' in constantexpr") ||
2327 ParseGlobalValueVector(Elts) ||
2328 ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2329 return true;
2330
2331 if (Opc == Instruction::GetElementPtr) {
2332 if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType()))
2333 return Error(ID.Loc, "getelementptr requires pointer operand");
2334
2335 if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(),
2336 (Value**)(Elts.data() + 1),
2337 Elts.size() - 1))
2338 return Error(ID.Loc, "invalid indices for getelementptr");
2339 ID.ConstantVal = InBounds ?
2340 ConstantExpr::getInBoundsGetElementPtr(Elts[0],
2341 Elts.data() + 1,
2342 Elts.size() - 1) :
2343 ConstantExpr::getGetElementPtr(Elts[0],
2344 Elts.data() + 1, Elts.size() - 1);
2345 } else if (Opc == Instruction::Select) {
2346 if (Elts.size() != 3)
2347 return Error(ID.Loc, "expected three operands to select");
2348 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2349 Elts[2]))
2350 return Error(ID.Loc, Reason);
2351 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2352 } else if (Opc == Instruction::ShuffleVector) {
2353 if (Elts.size() != 3)
2354 return Error(ID.Loc, "expected three operands to shufflevector");
2355 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2356 return Error(ID.Loc, "invalid operands to shufflevector");
2357 ID.ConstantVal =
2358 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2359 } else if (Opc == Instruction::ExtractElement) {
2360 if (Elts.size() != 2)
2361 return Error(ID.Loc, "expected two operands to extractelement");
2362 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2363 return Error(ID.Loc, "invalid extractelement operands");
2364 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2365 } else {
2366 assert(Opc == Instruction::InsertElement && "Unknown opcode");
2367 if (Elts.size() != 3)
2368 return Error(ID.Loc, "expected three operands to insertelement");
2369 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2370 return Error(ID.Loc, "invalid insertelement operands");
2371 ID.ConstantVal =
2372 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2373 }
2374
2375 ID.Kind = ValID::t_Constant;
2376 return false;
2377 }
2378 }
2379
2380 Lex.Lex();
2381 return false;
2382}
2383
2384/// ParseGlobalValue - Parse a global value with the specified type.
2385bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) {
2386 V = 0;
2387 ValID ID;
2388 return ParseValID(ID) ||
2389 ConvertGlobalValIDToValue(Ty, ID, V);
2390}
2391
2392/// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved
2393/// constant.
2394bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
2395 Constant *&V) {
2396 if (isa<FunctionType>(Ty))
2397 return Error(ID.Loc, "functions are not values, refer to them as pointers");
2398
2399 switch (ID.Kind) {
2400 default: llvm_unreachable("Unknown ValID!");
| 2154 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
2155 return Error(ID.Loc, "extractvalue operand must be array or struct");
2156 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
2157 Indices.end()))
2158 return Error(ID.Loc, "invalid indices for insertvalue");
2159 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1,
2160 Indices.data(), Indices.size());
2161 ID.Kind = ValID::t_Constant;
2162 return false;
2163 }
2164 case lltok::kw_icmp:
2165 case lltok::kw_fcmp: {
2166 unsigned PredVal, Opc = Lex.getUIntVal();
2167 Constant *Val0, *Val1;
2168 Lex.Lex();
2169 if (ParseCmpPredicate(PredVal, Opc) ||
2170 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2171 ParseGlobalTypeAndValue(Val0) ||
2172 ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2173 ParseGlobalTypeAndValue(Val1) ||
2174 ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2175 return true;
2176
2177 if (Val0->getType() != Val1->getType())
2178 return Error(ID.Loc, "compare operands must have the same type");
2179
2180 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2181
2182 if (Opc == Instruction::FCmp) {
2183 if (!Val0->getType()->isFPOrFPVector())
2184 return Error(ID.Loc, "fcmp requires floating point operands");
2185 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2186 } else {
2187 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2188 if (!Val0->getType()->isIntOrIntVector() &&
2189 !isa<PointerType>(Val0->getType()))
2190 return Error(ID.Loc, "icmp requires pointer or integer operands");
2191 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2192 }
2193 ID.Kind = ValID::t_Constant;
2194 return false;
2195 }
2196
2197 // Binary Operators.
2198 case lltok::kw_add:
2199 case lltok::kw_fadd:
2200 case lltok::kw_sub:
2201 case lltok::kw_fsub:
2202 case lltok::kw_mul:
2203 case lltok::kw_fmul:
2204 case lltok::kw_udiv:
2205 case lltok::kw_sdiv:
2206 case lltok::kw_fdiv:
2207 case lltok::kw_urem:
2208 case lltok::kw_srem:
2209 case lltok::kw_frem: {
2210 bool NUW = false;
2211 bool NSW = false;
2212 bool Exact = false;
2213 unsigned Opc = Lex.getUIntVal();
2214 Constant *Val0, *Val1;
2215 Lex.Lex();
2216 LocTy ModifierLoc = Lex.getLoc();
2217 if (Opc == Instruction::Add ||
2218 Opc == Instruction::Sub ||
2219 Opc == Instruction::Mul) {
2220 if (EatIfPresent(lltok::kw_nuw))
2221 NUW = true;
2222 if (EatIfPresent(lltok::kw_nsw)) {
2223 NSW = true;
2224 if (EatIfPresent(lltok::kw_nuw))
2225 NUW = true;
2226 }
2227 } else if (Opc == Instruction::SDiv) {
2228 if (EatIfPresent(lltok::kw_exact))
2229 Exact = true;
2230 }
2231 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2232 ParseGlobalTypeAndValue(Val0) ||
2233 ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2234 ParseGlobalTypeAndValue(Val1) ||
2235 ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2236 return true;
2237 if (Val0->getType() != Val1->getType())
2238 return Error(ID.Loc, "operands of constexpr must have same type");
2239 if (!Val0->getType()->isIntOrIntVector()) {
2240 if (NUW)
2241 return Error(ModifierLoc, "nuw only applies to integer operations");
2242 if (NSW)
2243 return Error(ModifierLoc, "nsw only applies to integer operations");
2244 }
2245 // API compatibility: Accept either integer or floating-point types with
2246 // add, sub, and mul.
2247 if (!Val0->getType()->isIntOrIntVector() &&
2248 !Val0->getType()->isFPOrFPVector())
2249 return Error(ID.Loc,"constexpr requires integer, fp, or vector operands");
2250 unsigned Flags = 0;
2251 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2252 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
2253 if (Exact) Flags |= SDivOperator::IsExact;
2254 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2255 ID.ConstantVal = C;
2256 ID.Kind = ValID::t_Constant;
2257 return false;
2258 }
2259
2260 // Logical Operations
2261 case lltok::kw_shl:
2262 case lltok::kw_lshr:
2263 case lltok::kw_ashr:
2264 case lltok::kw_and:
2265 case lltok::kw_or:
2266 case lltok::kw_xor: {
2267 unsigned Opc = Lex.getUIntVal();
2268 Constant *Val0, *Val1;
2269 Lex.Lex();
2270 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2271 ParseGlobalTypeAndValue(Val0) ||
2272 ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2273 ParseGlobalTypeAndValue(Val1) ||
2274 ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2275 return true;
2276 if (Val0->getType() != Val1->getType())
2277 return Error(ID.Loc, "operands of constexpr must have same type");
2278 if (!Val0->getType()->isIntOrIntVector())
2279 return Error(ID.Loc,
2280 "constexpr requires integer or integer vector operands");
2281 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2282 ID.Kind = ValID::t_Constant;
2283 return false;
2284 }
2285
2286 case lltok::kw_getelementptr:
2287 case lltok::kw_shufflevector:
2288 case lltok::kw_insertelement:
2289 case lltok::kw_extractelement:
2290 case lltok::kw_select: {
2291 unsigned Opc = Lex.getUIntVal();
2292 SmallVector<Constant*, 16> Elts;
2293 bool InBounds = false;
2294 Lex.Lex();
2295 if (Opc == Instruction::GetElementPtr)
2296 InBounds = EatIfPresent(lltok::kw_inbounds);
2297 if (ParseToken(lltok::lparen, "expected '(' in constantexpr") ||
2298 ParseGlobalValueVector(Elts) ||
2299 ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2300 return true;
2301
2302 if (Opc == Instruction::GetElementPtr) {
2303 if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType()))
2304 return Error(ID.Loc, "getelementptr requires pointer operand");
2305
2306 if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(),
2307 (Value**)(Elts.data() + 1),
2308 Elts.size() - 1))
2309 return Error(ID.Loc, "invalid indices for getelementptr");
2310 ID.ConstantVal = InBounds ?
2311 ConstantExpr::getInBoundsGetElementPtr(Elts[0],
2312 Elts.data() + 1,
2313 Elts.size() - 1) :
2314 ConstantExpr::getGetElementPtr(Elts[0],
2315 Elts.data() + 1, Elts.size() - 1);
2316 } else if (Opc == Instruction::Select) {
2317 if (Elts.size() != 3)
2318 return Error(ID.Loc, "expected three operands to select");
2319 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2320 Elts[2]))
2321 return Error(ID.Loc, Reason);
2322 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2323 } else if (Opc == Instruction::ShuffleVector) {
2324 if (Elts.size() != 3)
2325 return Error(ID.Loc, "expected three operands to shufflevector");
2326 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2327 return Error(ID.Loc, "invalid operands to shufflevector");
2328 ID.ConstantVal =
2329 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2330 } else if (Opc == Instruction::ExtractElement) {
2331 if (Elts.size() != 2)
2332 return Error(ID.Loc, "expected two operands to extractelement");
2333 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2334 return Error(ID.Loc, "invalid extractelement operands");
2335 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2336 } else {
2337 assert(Opc == Instruction::InsertElement && "Unknown opcode");
2338 if (Elts.size() != 3)
2339 return Error(ID.Loc, "expected three operands to insertelement");
2340 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2341 return Error(ID.Loc, "invalid insertelement operands");
2342 ID.ConstantVal =
2343 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2344 }
2345
2346 ID.Kind = ValID::t_Constant;
2347 return false;
2348 }
2349 }
2350
2351 Lex.Lex();
2352 return false;
2353}
2354
2355/// ParseGlobalValue - Parse a global value with the specified type.
2356bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) {
2357 V = 0;
2358 ValID ID;
2359 return ParseValID(ID) ||
2360 ConvertGlobalValIDToValue(Ty, ID, V);
2361}
2362
2363/// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved
2364/// constant.
2365bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
2366 Constant *&V) {
2367 if (isa<FunctionType>(Ty))
2368 return Error(ID.Loc, "functions are not values, refer to them as pointers");
2369
2370 switch (ID.Kind) {
2371 default: llvm_unreachable("Unknown ValID!");
|
2401 case ValID::t_Metadata:
| 2372 case ValID::t_MDNode:
2373 case ValID::t_MDString:
|
2402 return Error(ID.Loc, "invalid use of metadata");
2403 case ValID::t_LocalID:
2404 case ValID::t_LocalName:
2405 return Error(ID.Loc, "invalid use of function-local name");
2406 case ValID::t_InlineAsm:
2407 return Error(ID.Loc, "inline asm can only be an operand of call/invoke");
2408 case ValID::t_GlobalName:
2409 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
2410 return V == 0;
2411 case ValID::t_GlobalID:
2412 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
2413 return V == 0;
2414 case ValID::t_APSInt:
2415 if (!isa<IntegerType>(Ty))
2416 return Error(ID.Loc, "integer constant must have integer type");
2417 ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
2418 V = ConstantInt::get(Context, ID.APSIntVal);
2419 return false;
2420 case ValID::t_APFloat:
2421 if (!Ty->isFloatingPoint() ||
2422 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
2423 return Error(ID.Loc, "floating point constant invalid for type");
2424
2425 // The lexer has no type info, so builds all float and double FP constants
2426 // as double. Fix this here. Long double does not need this.
2427 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble &&
2428 Ty->isFloatTy()) {
2429 bool Ignored;
2430 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
2431 &Ignored);
2432 }
2433 V = ConstantFP::get(Context, ID.APFloatVal);
2434
2435 if (V->getType() != Ty)
2436 return Error(ID.Loc, "floating point constant does not have type '" +
2437 Ty->getDescription() + "'");
2438
2439 return false;
2440 case ValID::t_Null:
2441 if (!isa<PointerType>(Ty))
2442 return Error(ID.Loc, "null must be a pointer type");
2443 V = ConstantPointerNull::get(cast<PointerType>(Ty));
2444 return false;
2445 case ValID::t_Undef:
2446 // FIXME: LabelTy should not be a first-class type.
2447 if ((!Ty->isFirstClassType() || Ty->isLabelTy()) &&
2448 !isa<OpaqueType>(Ty))
2449 return Error(ID.Loc, "invalid type for undef constant");
2450 V = UndefValue::get(Ty);
2451 return false;
2452 case ValID::t_EmptyArray:
2453 if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
2454 return Error(ID.Loc, "invalid empty array initializer");
2455 V = UndefValue::get(Ty);
2456 return false;
2457 case ValID::t_Zero:
2458 // FIXME: LabelTy should not be a first-class type.
2459 if (!Ty->isFirstClassType() || Ty->isLabelTy())
2460 return Error(ID.Loc, "invalid type for null constant");
2461 V = Constant::getNullValue(Ty);
2462 return false;
2463 case ValID::t_Constant:
2464 if (ID.ConstantVal->getType() != Ty)
2465 return Error(ID.Loc, "constant expression type mismatch");
2466 V = ID.ConstantVal;
2467 return false;
2468 }
2469}
2470
| 2374 return Error(ID.Loc, "invalid use of metadata");
2375 case ValID::t_LocalID:
2376 case ValID::t_LocalName:
2377 return Error(ID.Loc, "invalid use of function-local name");
2378 case ValID::t_InlineAsm:
2379 return Error(ID.Loc, "inline asm can only be an operand of call/invoke");
2380 case ValID::t_GlobalName:
2381 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
2382 return V == 0;
2383 case ValID::t_GlobalID:
2384 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
2385 return V == 0;
2386 case ValID::t_APSInt:
2387 if (!isa<IntegerType>(Ty))
2388 return Error(ID.Loc, "integer constant must have integer type");
2389 ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
2390 V = ConstantInt::get(Context, ID.APSIntVal);
2391 return false;
2392 case ValID::t_APFloat:
2393 if (!Ty->isFloatingPoint() ||
2394 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
2395 return Error(ID.Loc, "floating point constant invalid for type");
2396
2397 // The lexer has no type info, so builds all float and double FP constants
2398 // as double. Fix this here. Long double does not need this.
2399 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble &&
2400 Ty->isFloatTy()) {
2401 bool Ignored;
2402 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
2403 &Ignored);
2404 }
2405 V = ConstantFP::get(Context, ID.APFloatVal);
2406
2407 if (V->getType() != Ty)
2408 return Error(ID.Loc, "floating point constant does not have type '" +
2409 Ty->getDescription() + "'");
2410
2411 return false;
2412 case ValID::t_Null:
2413 if (!isa<PointerType>(Ty))
2414 return Error(ID.Loc, "null must be a pointer type");
2415 V = ConstantPointerNull::get(cast<PointerType>(Ty));
2416 return false;
2417 case ValID::t_Undef:
2418 // FIXME: LabelTy should not be a first-class type.
2419 if ((!Ty->isFirstClassType() || Ty->isLabelTy()) &&
2420 !isa<OpaqueType>(Ty))
2421 return Error(ID.Loc, "invalid type for undef constant");
2422 V = UndefValue::get(Ty);
2423 return false;
2424 case ValID::t_EmptyArray:
2425 if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
2426 return Error(ID.Loc, "invalid empty array initializer");
2427 V = UndefValue::get(Ty);
2428 return false;
2429 case ValID::t_Zero:
2430 // FIXME: LabelTy should not be a first-class type.
2431 if (!Ty->isFirstClassType() || Ty->isLabelTy())
2432 return Error(ID.Loc, "invalid type for null constant");
2433 V = Constant::getNullValue(Ty);
2434 return false;
2435 case ValID::t_Constant:
2436 if (ID.ConstantVal->getType() != Ty)
2437 return Error(ID.Loc, "constant expression type mismatch");
2438 V = ID.ConstantVal;
2439 return false;
2440 }
2441}
2442
|
| 2443/// ConvertGlobalOrMetadataValIDToValue - Apply a type to a ValID to get a fully
2444/// resolved constant or metadata value.
2445bool LLParser::ConvertGlobalOrMetadataValIDToValue(const Type *Ty, ValID &ID,
2446 Value *&V) {
2447 switch (ID.Kind) {
2448 case ValID::t_MDNode:
2449 if (!Ty->isMetadataTy())
2450 return Error(ID.Loc, "metadata value must have metadata type");
2451 V = ID.MDNodeVal;
2452 return false;
2453 case ValID::t_MDString:
2454 if (!Ty->isMetadataTy())
2455 return Error(ID.Loc, "metadata value must have metadata type");
2456 V = ID.MDStringVal;
2457 return false;
2458 default:
2459 Constant *C;
2460 if (ConvertGlobalValIDToValue(Ty, ID, C)) return true;
2461 V = C;
2462 return false;
2463 }
2464}
2465
2466
|
2471bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2472 PATypeHolder Type(Type::getVoidTy(Context));
2473 return ParseType(Type) ||
2474 ParseGlobalValue(Type, V);
2475}
2476
2477/// ParseGlobalValueVector
2478/// ::= /*empty*/
2479/// ::= TypeAndValue (',' TypeAndValue)*
2480bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) {
2481 // Empty list.
2482 if (Lex.getKind() == lltok::rbrace ||
2483 Lex.getKind() == lltok::rsquare ||
2484 Lex.getKind() == lltok::greater ||
2485 Lex.getKind() == lltok::rparen)
2486 return false;
2487
2488 Constant *C;
2489 if (ParseGlobalTypeAndValue(C)) return true;
2490 Elts.push_back(C);
2491
2492 while (EatIfPresent(lltok::comma)) {
2493 if (ParseGlobalTypeAndValue(C)) return true;
2494 Elts.push_back(C);
2495 }
2496
2497 return false;
2498}
2499
2500
2501//===----------------------------------------------------------------------===//
2502// Function Parsing.
2503//===----------------------------------------------------------------------===//
2504
2505bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V,
2506 PerFunctionState &PFS) {
| 2467bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2468 PATypeHolder Type(Type::getVoidTy(Context));
2469 return ParseType(Type) ||
2470 ParseGlobalValue(Type, V);
2471}
2472
2473/// ParseGlobalValueVector
2474/// ::= /*empty*/
2475/// ::= TypeAndValue (',' TypeAndValue)*
2476bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) {
2477 // Empty list.
2478 if (Lex.getKind() == lltok::rbrace ||
2479 Lex.getKind() == lltok::rsquare ||
2480 Lex.getKind() == lltok::greater ||
2481 Lex.getKind() == lltok::rparen)
2482 return false;
2483
2484 Constant *C;
2485 if (ParseGlobalTypeAndValue(C)) return true;
2486 Elts.push_back(C);
2487
2488 while (EatIfPresent(lltok::comma)) {
2489 if (ParseGlobalTypeAndValue(C)) return true;
2490 Elts.push_back(C);
2491 }
2492
2493 return false;
2494}
2495
2496
2497//===----------------------------------------------------------------------===//
2498// Function Parsing.
2499//===----------------------------------------------------------------------===//
2500
2501bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V,
2502 PerFunctionState &PFS) {
|
2507 if (ID.Kind == ValID::t_LocalID)
2508 V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc);
2509 else if (ID.Kind == ValID::t_LocalName)
2510 V = PFS.GetVal(ID.StrVal, Ty, ID.Loc);
2511 else if (ID.Kind == ValID::t_InlineAsm) {
| 2503 switch (ID.Kind) {
2504 case ValID::t_LocalID: V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc); break;
2505 case ValID::t_LocalName: V = PFS.GetVal(ID.StrVal, Ty, ID.Loc); break;
2506 case ValID::t_InlineAsm: {
|
2512 const PointerType *PTy = dyn_cast<PointerType>(Ty);
| 2507 const PointerType *PTy = dyn_cast<PointerType>(Ty);
|
2513 const FunctionType *FTy =
| 2508 const FunctionType *FTy =
|
2514 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
2515 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
2516 return Error(ID.Loc, "invalid type for inline asm constraint string");
2517 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1);
2518 return false;
| 2509 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
2510 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
2511 return Error(ID.Loc, "invalid type for inline asm constraint string");
2512 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1);
2513 return false;
|
2519 } else if (ID.Kind == ValID::t_Metadata) {
2520 V = ID.MetadataVal;
2521 } else {
2522 Constant *C;
2523 if (ConvertGlobalValIDToValue(Ty, ID, C)) return true;
2524 V = C;
2525 return false;
| |
2526 }
| 2514 }
|
| 2515 default:
2516 return ConvertGlobalOrMetadataValIDToValue(Ty, ID, V);
2517 }
|
2527
2528 return V == 0;
2529}
2530
2531bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) {
2532 V = 0;
2533 ValID ID;
2534 return ParseValID(ID) ||
2535 ConvertValIDToValue(Ty, ID, V, PFS);
2536}
2537
2538bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
2539 PATypeHolder T(Type::getVoidTy(Context));
2540 return ParseType(T) ||
2541 ParseValue(T, V, PFS);
2542}
2543
2544bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
2545 PerFunctionState &PFS) {
2546 Value *V;
2547 Loc = Lex.getLoc();
2548 if (ParseTypeAndValue(V, PFS)) return true;
2549 if (!isa<BasicBlock>(V))
2550 return Error(Loc, "expected a basic block");
2551 BB = cast<BasicBlock>(V);
2552 return false;
2553}
2554
2555
2556/// FunctionHeader
2557/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
2558/// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
2559/// OptionalAlign OptGC
2560bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
2561 // Parse the linkage.
2562 LocTy LinkageLoc = Lex.getLoc();
2563 unsigned Linkage;
2564
2565 unsigned Visibility, RetAttrs;
2566 CallingConv::ID CC;
2567 PATypeHolder RetType(Type::getVoidTy(Context));
2568 LocTy RetTypeLoc = Lex.getLoc();
2569 if (ParseOptionalLinkage(Linkage) ||
2570 ParseOptionalVisibility(Visibility) ||
2571 ParseOptionalCallingConv(CC) ||
2572 ParseOptionalAttrs(RetAttrs, 1) ||
2573 ParseType(RetType, RetTypeLoc, true /*void allowed*/))
2574 return true;
2575
2576 // Verify that the linkage is ok.
2577 switch ((GlobalValue::LinkageTypes)Linkage) {
2578 case GlobalValue::ExternalLinkage:
2579 break; // always ok.
2580 case GlobalValue::DLLImportLinkage:
2581 case GlobalValue::ExternalWeakLinkage:
2582 if (isDefine)
2583 return Error(LinkageLoc, "invalid linkage for function definition");
2584 break;
2585 case GlobalValue::PrivateLinkage:
2586 case GlobalValue::LinkerPrivateLinkage:
2587 case GlobalValue::InternalLinkage:
2588 case GlobalValue::AvailableExternallyLinkage:
2589 case GlobalValue::LinkOnceAnyLinkage:
2590 case GlobalValue::LinkOnceODRLinkage:
2591 case GlobalValue::WeakAnyLinkage:
2592 case GlobalValue::WeakODRLinkage:
2593 case GlobalValue::DLLExportLinkage:
2594 if (!isDefine)
2595 return Error(LinkageLoc, "invalid linkage for function declaration");
2596 break;
2597 case GlobalValue::AppendingLinkage:
2598 case GlobalValue::GhostLinkage:
2599 case GlobalValue::CommonLinkage:
2600 return Error(LinkageLoc, "invalid function linkage type");
2601 }
2602
2603 if (!FunctionType::isValidReturnType(RetType) ||
2604 isa<OpaqueType>(RetType))
2605 return Error(RetTypeLoc, "invalid function return type");
2606
2607 LocTy NameLoc = Lex.getLoc();
2608
2609 std::string FunctionName;
2610 if (Lex.getKind() == lltok::GlobalVar) {
2611 FunctionName = Lex.getStrVal();
2612 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
2613 unsigned NameID = Lex.getUIntVal();
2614
2615 if (NameID != NumberedVals.size())
2616 return TokError("function expected to be numbered '%" +
2617 utostr(NumberedVals.size()) + "'");
2618 } else {
2619 return TokError("expected function name");
2620 }
2621
2622 Lex.Lex();
2623
2624 if (Lex.getKind() != lltok::lparen)
2625 return TokError("expected '(' in function argument list");
2626
2627 std::vector<ArgInfo> ArgList;
2628 bool isVarArg;
2629 unsigned FuncAttrs;
2630 std::string Section;
2631 unsigned Alignment;
2632 std::string GC;
2633
2634 if (ParseArgumentList(ArgList, isVarArg, false) ||
2635 ParseOptionalAttrs(FuncAttrs, 2) ||
2636 (EatIfPresent(lltok::kw_section) &&
2637 ParseStringConstant(Section)) ||
2638 ParseOptionalAlignment(Alignment) ||
2639 (EatIfPresent(lltok::kw_gc) &&
2640 ParseStringConstant(GC)))
2641 return true;
2642
2643 // If the alignment was parsed as an attribute, move to the alignment field.
2644 if (FuncAttrs & Attribute::Alignment) {
2645 Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs);
2646 FuncAttrs &= ~Attribute::Alignment;
2647 }
2648
2649 // Okay, if we got here, the function is syntactically valid. Convert types
2650 // and do semantic checks.
2651 std::vector<const Type*> ParamTypeList;
2652 SmallVector<AttributeWithIndex, 8> Attrs;
2653 // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
2654 // attributes.
2655 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
2656 if (FuncAttrs & ObsoleteFuncAttrs) {
2657 RetAttrs |= FuncAttrs & ObsoleteFuncAttrs;
2658 FuncAttrs &= ~ObsoleteFuncAttrs;
2659 }
2660
2661 if (RetAttrs != Attribute::None)
2662 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
2663
2664 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2665 ParamTypeList.push_back(ArgList[i].Type);
2666 if (ArgList[i].Attrs != Attribute::None)
2667 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
2668 }
2669
2670 if (FuncAttrs != Attribute::None)
2671 Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs));
2672
2673 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
2674
2675 if (PAL.paramHasAttr(1, Attribute::StructRet) &&
2676 RetType != Type::getVoidTy(Context))
2677 return Error(RetTypeLoc, "functions with 'sret' argument must return void");
2678
2679 const FunctionType *FT =
2680 FunctionType::get(RetType, ParamTypeList, isVarArg);
2681 const PointerType *PFT = PointerType::getUnqual(FT);
2682
2683 Fn = 0;
2684 if (!FunctionName.empty()) {
2685 // If this was a definition of a forward reference, remove the definition
2686 // from the forward reference table and fill in the forward ref.
2687 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI =
2688 ForwardRefVals.find(FunctionName);
2689 if (FRVI != ForwardRefVals.end()) {
2690 Fn = M->getFunction(FunctionName);
2691 ForwardRefVals.erase(FRVI);
2692 } else if ((Fn = M->getFunction(FunctionName))) {
2693 // If this function already exists in the symbol table, then it is
2694 // multiply defined. We accept a few cases for old backwards compat.
2695 // FIXME: Remove this stuff for LLVM 3.0.
2696 if (Fn->getType() != PFT || Fn->getAttributes() != PAL ||
2697 (!Fn->isDeclaration() && isDefine)) {
2698 // If the redefinition has different type or different attributes,
2699 // reject it. If both have bodies, reject it.
2700 return Error(NameLoc, "invalid redefinition of function '" +
2701 FunctionName + "'");
2702 } else if (Fn->isDeclaration()) {
2703 // Make sure to strip off any argument names so we can't get conflicts.
2704 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
2705 AI != AE; ++AI)
2706 AI->setName("");
2707 }
2708 } else if (M->getNamedValue(FunctionName)) {
2709 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
2710 }
2711
2712 } else {
2713 // If this is a definition of a forward referenced function, make sure the
2714 // types agree.
2715 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I
2716 = ForwardRefValIDs.find(NumberedVals.size());
2717 if (I != ForwardRefValIDs.end()) {
2718 Fn = cast<Function>(I->second.first);
2719 if (Fn->getType() != PFT)
2720 return Error(NameLoc, "type of definition and forward reference of '@" +
2721 utostr(NumberedVals.size()) +"' disagree");
2722 ForwardRefValIDs.erase(I);
2723 }
2724 }
2725
2726 if (Fn == 0)
2727 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
2728 else // Move the forward-reference to the correct spot in the module.
2729 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
2730
2731 if (FunctionName.empty())
2732 NumberedVals.push_back(Fn);
2733
2734 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
2735 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
2736 Fn->setCallingConv(CC);
2737 Fn->setAttributes(PAL);
2738 Fn->setAlignment(Alignment);
2739 Fn->setSection(Section);
2740 if (!GC.empty()) Fn->setGC(GC.c_str());
2741
2742 // Add all of the arguments we parsed to the function.
2743 Function::arg_iterator ArgIt = Fn->arg_begin();
2744 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
2745 // If we run out of arguments in the Function prototype, exit early.
2746 // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above.
2747 if (ArgIt == Fn->arg_end()) break;
2748
2749 // If the argument has a name, insert it into the argument symbol table.
2750 if (ArgList[i].Name.empty()) continue;
2751
2752 // Set the name, if it conflicted, it will be auto-renamed.
2753 ArgIt->setName(ArgList[i].Name);
2754
2755 if (ArgIt->getNameStr() != ArgList[i].Name)
2756 return Error(ArgList[i].Loc, "redefinition of argument '%" +
2757 ArgList[i].Name + "'");
2758 }
2759
2760 return false;
2761}
2762
2763
2764/// ParseFunctionBody
2765/// ::= '{' BasicBlock+ '}'
2766/// ::= 'begin' BasicBlock+ 'end' // FIXME: remove in LLVM 3.0
2767///
2768bool LLParser::ParseFunctionBody(Function &Fn) {
2769 if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin)
2770 return TokError("expected '{' in function body");
2771 Lex.Lex(); // eat the {.
2772
2773 int FunctionNumber = -1;
2774 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
2775
2776 PerFunctionState PFS(*this, Fn, FunctionNumber);
2777
2778 while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end)
2779 if (ParseBasicBlock(PFS)) return true;
2780
2781 // Eat the }.
2782 Lex.Lex();
2783
2784 // Verify function is ok.
2785 return PFS.FinishFunction();
2786}
2787
2788/// ParseBasicBlock
2789/// ::= LabelStr? Instruction*
2790bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
2791 // If this basic block starts out with a name, remember it.
2792 std::string Name;
2793 LocTy NameLoc = Lex.getLoc();
2794 if (Lex.getKind() == lltok::LabelStr) {
2795 Name = Lex.getStrVal();
2796 Lex.Lex();
2797 }
2798
2799 BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
2800 if (BB == 0) return true;
2801
2802 std::string NameStr;
2803
2804 // Parse the instructions in this block until we get a terminator.
2805 Instruction *Inst;
| 2518
2519 return V == 0;
2520}
2521
2522bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) {
2523 V = 0;
2524 ValID ID;
2525 return ParseValID(ID) ||
2526 ConvertValIDToValue(Ty, ID, V, PFS);
2527}
2528
2529bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
2530 PATypeHolder T(Type::getVoidTy(Context));
2531 return ParseType(T) ||
2532 ParseValue(T, V, PFS);
2533}
2534
2535bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
2536 PerFunctionState &PFS) {
2537 Value *V;
2538 Loc = Lex.getLoc();
2539 if (ParseTypeAndValue(V, PFS)) return true;
2540 if (!isa<BasicBlock>(V))
2541 return Error(Loc, "expected a basic block");
2542 BB = cast<BasicBlock>(V);
2543 return false;
2544}
2545
2546
2547/// FunctionHeader
2548/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
2549/// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
2550/// OptionalAlign OptGC
2551bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
2552 // Parse the linkage.
2553 LocTy LinkageLoc = Lex.getLoc();
2554 unsigned Linkage;
2555
2556 unsigned Visibility, RetAttrs;
2557 CallingConv::ID CC;
2558 PATypeHolder RetType(Type::getVoidTy(Context));
2559 LocTy RetTypeLoc = Lex.getLoc();
2560 if (ParseOptionalLinkage(Linkage) ||
2561 ParseOptionalVisibility(Visibility) ||
2562 ParseOptionalCallingConv(CC) ||
2563 ParseOptionalAttrs(RetAttrs, 1) ||
2564 ParseType(RetType, RetTypeLoc, true /*void allowed*/))
2565 return true;
2566
2567 // Verify that the linkage is ok.
2568 switch ((GlobalValue::LinkageTypes)Linkage) {
2569 case GlobalValue::ExternalLinkage:
2570 break; // always ok.
2571 case GlobalValue::DLLImportLinkage:
2572 case GlobalValue::ExternalWeakLinkage:
2573 if (isDefine)
2574 return Error(LinkageLoc, "invalid linkage for function definition");
2575 break;
2576 case GlobalValue::PrivateLinkage:
2577 case GlobalValue::LinkerPrivateLinkage:
2578 case GlobalValue::InternalLinkage:
2579 case GlobalValue::AvailableExternallyLinkage:
2580 case GlobalValue::LinkOnceAnyLinkage:
2581 case GlobalValue::LinkOnceODRLinkage:
2582 case GlobalValue::WeakAnyLinkage:
2583 case GlobalValue::WeakODRLinkage:
2584 case GlobalValue::DLLExportLinkage:
2585 if (!isDefine)
2586 return Error(LinkageLoc, "invalid linkage for function declaration");
2587 break;
2588 case GlobalValue::AppendingLinkage:
2589 case GlobalValue::GhostLinkage:
2590 case GlobalValue::CommonLinkage:
2591 return Error(LinkageLoc, "invalid function linkage type");
2592 }
2593
2594 if (!FunctionType::isValidReturnType(RetType) ||
2595 isa<OpaqueType>(RetType))
2596 return Error(RetTypeLoc, "invalid function return type");
2597
2598 LocTy NameLoc = Lex.getLoc();
2599
2600 std::string FunctionName;
2601 if (Lex.getKind() == lltok::GlobalVar) {
2602 FunctionName = Lex.getStrVal();
2603 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
2604 unsigned NameID = Lex.getUIntVal();
2605
2606 if (NameID != NumberedVals.size())
2607 return TokError("function expected to be numbered '%" +
2608 utostr(NumberedVals.size()) + "'");
2609 } else {
2610 return TokError("expected function name");
2611 }
2612
2613 Lex.Lex();
2614
2615 if (Lex.getKind() != lltok::lparen)
2616 return TokError("expected '(' in function argument list");
2617
2618 std::vector<ArgInfo> ArgList;
2619 bool isVarArg;
2620 unsigned FuncAttrs;
2621 std::string Section;
2622 unsigned Alignment;
2623 std::string GC;
2624
2625 if (ParseArgumentList(ArgList, isVarArg, false) ||
2626 ParseOptionalAttrs(FuncAttrs, 2) ||
2627 (EatIfPresent(lltok::kw_section) &&
2628 ParseStringConstant(Section)) ||
2629 ParseOptionalAlignment(Alignment) ||
2630 (EatIfPresent(lltok::kw_gc) &&
2631 ParseStringConstant(GC)))
2632 return true;
2633
2634 // If the alignment was parsed as an attribute, move to the alignment field.
2635 if (FuncAttrs & Attribute::Alignment) {
2636 Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs);
2637 FuncAttrs &= ~Attribute::Alignment;
2638 }
2639
2640 // Okay, if we got here, the function is syntactically valid. Convert types
2641 // and do semantic checks.
2642 std::vector<const Type*> ParamTypeList;
2643 SmallVector<AttributeWithIndex, 8> Attrs;
2644 // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
2645 // attributes.
2646 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
2647 if (FuncAttrs & ObsoleteFuncAttrs) {
2648 RetAttrs |= FuncAttrs & ObsoleteFuncAttrs;
2649 FuncAttrs &= ~ObsoleteFuncAttrs;
2650 }
2651
2652 if (RetAttrs != Attribute::None)
2653 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
2654
2655 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2656 ParamTypeList.push_back(ArgList[i].Type);
2657 if (ArgList[i].Attrs != Attribute::None)
2658 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
2659 }
2660
2661 if (FuncAttrs != Attribute::None)
2662 Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs));
2663
2664 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
2665
2666 if (PAL.paramHasAttr(1, Attribute::StructRet) &&
2667 RetType != Type::getVoidTy(Context))
2668 return Error(RetTypeLoc, "functions with 'sret' argument must return void");
2669
2670 const FunctionType *FT =
2671 FunctionType::get(RetType, ParamTypeList, isVarArg);
2672 const PointerType *PFT = PointerType::getUnqual(FT);
2673
2674 Fn = 0;
2675 if (!FunctionName.empty()) {
2676 // If this was a definition of a forward reference, remove the definition
2677 // from the forward reference table and fill in the forward ref.
2678 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI =
2679 ForwardRefVals.find(FunctionName);
2680 if (FRVI != ForwardRefVals.end()) {
2681 Fn = M->getFunction(FunctionName);
2682 ForwardRefVals.erase(FRVI);
2683 } else if ((Fn = M->getFunction(FunctionName))) {
2684 // If this function already exists in the symbol table, then it is
2685 // multiply defined. We accept a few cases for old backwards compat.
2686 // FIXME: Remove this stuff for LLVM 3.0.
2687 if (Fn->getType() != PFT || Fn->getAttributes() != PAL ||
2688 (!Fn->isDeclaration() && isDefine)) {
2689 // If the redefinition has different type or different attributes,
2690 // reject it. If both have bodies, reject it.
2691 return Error(NameLoc, "invalid redefinition of function '" +
2692 FunctionName + "'");
2693 } else if (Fn->isDeclaration()) {
2694 // Make sure to strip off any argument names so we can't get conflicts.
2695 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
2696 AI != AE; ++AI)
2697 AI->setName("");
2698 }
2699 } else if (M->getNamedValue(FunctionName)) {
2700 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
2701 }
2702
2703 } else {
2704 // If this is a definition of a forward referenced function, make sure the
2705 // types agree.
2706 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I
2707 = ForwardRefValIDs.find(NumberedVals.size());
2708 if (I != ForwardRefValIDs.end()) {
2709 Fn = cast<Function>(I->second.first);
2710 if (Fn->getType() != PFT)
2711 return Error(NameLoc, "type of definition and forward reference of '@" +
2712 utostr(NumberedVals.size()) +"' disagree");
2713 ForwardRefValIDs.erase(I);
2714 }
2715 }
2716
2717 if (Fn == 0)
2718 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
2719 else // Move the forward-reference to the correct spot in the module.
2720 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
2721
2722 if (FunctionName.empty())
2723 NumberedVals.push_back(Fn);
2724
2725 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
2726 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
2727 Fn->setCallingConv(CC);
2728 Fn->setAttributes(PAL);
2729 Fn->setAlignment(Alignment);
2730 Fn->setSection(Section);
2731 if (!GC.empty()) Fn->setGC(GC.c_str());
2732
2733 // Add all of the arguments we parsed to the function.
2734 Function::arg_iterator ArgIt = Fn->arg_begin();
2735 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
2736 // If we run out of arguments in the Function prototype, exit early.
2737 // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above.
2738 if (ArgIt == Fn->arg_end()) break;
2739
2740 // If the argument has a name, insert it into the argument symbol table.
2741 if (ArgList[i].Name.empty()) continue;
2742
2743 // Set the name, if it conflicted, it will be auto-renamed.
2744 ArgIt->setName(ArgList[i].Name);
2745
2746 if (ArgIt->getNameStr() != ArgList[i].Name)
2747 return Error(ArgList[i].Loc, "redefinition of argument '%" +
2748 ArgList[i].Name + "'");
2749 }
2750
2751 return false;
2752}
2753
2754
2755/// ParseFunctionBody
2756/// ::= '{' BasicBlock+ '}'
2757/// ::= 'begin' BasicBlock+ 'end' // FIXME: remove in LLVM 3.0
2758///
2759bool LLParser::ParseFunctionBody(Function &Fn) {
2760 if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin)
2761 return TokError("expected '{' in function body");
2762 Lex.Lex(); // eat the {.
2763
2764 int FunctionNumber = -1;
2765 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
2766
2767 PerFunctionState PFS(*this, Fn, FunctionNumber);
2768
2769 while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end)
2770 if (ParseBasicBlock(PFS)) return true;
2771
2772 // Eat the }.
2773 Lex.Lex();
2774
2775 // Verify function is ok.
2776 return PFS.FinishFunction();
2777}
2778
2779/// ParseBasicBlock
2780/// ::= LabelStr? Instruction*
2781bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
2782 // If this basic block starts out with a name, remember it.
2783 std::string Name;
2784 LocTy NameLoc = Lex.getLoc();
2785 if (Lex.getKind() == lltok::LabelStr) {
2786 Name = Lex.getStrVal();
2787 Lex.Lex();
2788 }
2789
2790 BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
2791 if (BB == 0) return true;
2792
2793 std::string NameStr;
2794
2795 // Parse the instructions in this block until we get a terminator.
2796 Instruction *Inst;
|
| 2797 SmallVector<std::pair<unsigned, MDNode *>, 4> MetadataOnInst;
|
2806 do {
2807 // This instruction may have three possibilities for a name: a) none
2808 // specified, b) name specified "%foo =", c) number specified: "%4 =".
2809 LocTy NameLoc = Lex.getLoc();
2810 int NameID = -1;
2811 NameStr = "";
2812
2813 if (Lex.getKind() == lltok::LocalVarID) {
2814 NameID = Lex.getUIntVal();
2815 Lex.Lex();
2816 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
2817 return true;
2818 } else if (Lex.getKind() == lltok::LocalVar ||
2819 // FIXME: REMOVE IN LLVM 3.0
2820 Lex.getKind() == lltok::StringConstant) {
2821 NameStr = Lex.getStrVal();
2822 Lex.Lex();
2823 if (ParseToken(lltok::equal, "expected '=' after instruction name"))
2824 return true;
2825 }
2826
| 2798 do {
2799 // This instruction may have three possibilities for a name: a) none
2800 // specified, b) name specified "%foo =", c) number specified: "%4 =".
2801 LocTy NameLoc = Lex.getLoc();
2802 int NameID = -1;
2803 NameStr = "";
2804
2805 if (Lex.getKind() == lltok::LocalVarID) {
2806 NameID = Lex.getUIntVal();
2807 Lex.Lex();
2808 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
2809 return true;
2810 } else if (Lex.getKind() == lltok::LocalVar ||
2811 // FIXME: REMOVE IN LLVM 3.0
2812 Lex.getKind() == lltok::StringConstant) {
2813 NameStr = Lex.getStrVal();
2814 Lex.Lex();
2815 if (ParseToken(lltok::equal, "expected '=' after instruction name"))
2816 return true;
2817 }
2818
|
2827 if (ParseInstruction(Inst, BB, PFS)) return true;
2828 if (EatIfPresent(lltok::comma))
2829 ParseOptionalCustomMetadata();
| 2819 switch (ParseInstruction(Inst, BB, PFS)) {
2820 default: assert(0 && "Unknown ParseInstruction result!");
2821 case InstError: return true;
2822 case InstNormal:
2823 // With a normal result, we check to see if the instruction is followed by
2824 // a comma and metadata.
2825 if (EatIfPresent(lltok::comma))
2826 if (ParseInstructionMetadata(MetadataOnInst))
2827 return true;
2828 break;
2829 case InstExtraComma:
2830 // If the instruction parser ate an extra comma at the end of it, it
2831 // *must* be followed by metadata.
2832 if (ParseInstructionMetadata(MetadataOnInst))
2833 return true;
2834 break;
2835 }
|
2830
2831 // Set metadata attached with this instruction.
| 2836
2837 // Set metadata attached with this instruction.
|
2832 MetadataContext &TheMetadata = M->getContext().getMetadata();
2833 for (SmallVector<std::pair<unsigned, MDNode *>, 2>::iterator
2834 MDI = MDsOnInst.begin(), MDE = MDsOnInst.end(); MDI != MDE; ++MDI)
2835 TheMetadata.addMD(MDI->first, MDI->second, Inst);
2836 MDsOnInst.clear();
| 2838 for (unsigned i = 0, e = MetadataOnInst.size(); i != e; ++i)
2839 Inst->setMetadata(MetadataOnInst[i].first, MetadataOnInst[i].second);
2840 MetadataOnInst.clear();
|
2837
2838 BB->getInstList().push_back(Inst);
2839
2840 // Set the name on the instruction.
2841 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
2842 } while (!isa<TerminatorInst>(Inst));
2843
2844 return false;
2845}
2846
2847//===----------------------------------------------------------------------===//
2848// Instruction Parsing.
2849//===----------------------------------------------------------------------===//
2850
2851/// ParseInstruction - Parse one of the many different instructions.
2852///
| 2841
2842 BB->getInstList().push_back(Inst);
2843
2844 // Set the name on the instruction.
2845 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
2846 } while (!isa<TerminatorInst>(Inst));
2847
2848 return false;
2849}
2850
2851//===----------------------------------------------------------------------===//
2852// Instruction Parsing.
2853//===----------------------------------------------------------------------===//
2854
2855/// ParseInstruction - Parse one of the many different instructions.
2856///
|
2853bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
2854 PerFunctionState &PFS) {
| 2857int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
2858 PerFunctionState &PFS) {
|
2855 lltok::Kind Token = Lex.getKind();
2856 if (Token == lltok::Eof)
2857 return TokError("found end of file when expecting more instructions");
2858 LocTy Loc = Lex.getLoc();
2859 unsigned KeywordVal = Lex.getUIntVal();
2860 Lex.Lex(); // Eat the keyword.
2861
2862 switch (Token) {
2863 default: return Error(Loc, "expected instruction opcode");
2864 // Terminator Instructions.
2865 case lltok::kw_unwind: Inst = new UnwindInst(Context); return false;
2866 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
2867 case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
2868 case lltok::kw_br: return ParseBr(Inst, PFS);
2869 case lltok::kw_switch: return ParseSwitch(Inst, PFS);
2870 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
2871 case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
2872 // Binary Operators.
2873 case lltok::kw_add:
2874 case lltok::kw_sub:
2875 case lltok::kw_mul: {
2876 bool NUW = false;
2877 bool NSW = false;
2878 LocTy ModifierLoc = Lex.getLoc();
2879 if (EatIfPresent(lltok::kw_nuw))
2880 NUW = true;
2881 if (EatIfPresent(lltok::kw_nsw)) {
2882 NSW = true;
2883 if (EatIfPresent(lltok::kw_nuw))
2884 NUW = true;
2885 }
2886 // API compatibility: Accept either integer or floating-point types.
2887 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0);
2888 if (!Result) {
2889 if (!Inst->getType()->isIntOrIntVector()) {
2890 if (NUW)
2891 return Error(ModifierLoc, "nuw only applies to integer operations");
2892 if (NSW)
2893 return Error(ModifierLoc, "nsw only applies to integer operations");
2894 }
2895 if (NUW)
2896 cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
2897 if (NSW)
2898 cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
2899 }
2900 return Result;
2901 }
2902 case lltok::kw_fadd:
2903 case lltok::kw_fsub:
2904 case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2905
2906 case lltok::kw_sdiv: {
2907 bool Exact = false;
2908 if (EatIfPresent(lltok::kw_exact))
2909 Exact = true;
2910 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1);
2911 if (!Result)
2912 if (Exact)
2913 cast<BinaryOperator>(Inst)->setIsExact(true);
2914 return Result;
2915 }
2916
2917 case lltok::kw_udiv:
2918 case lltok::kw_urem:
2919 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
2920 case lltok::kw_fdiv:
2921 case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2922 case lltok::kw_shl:
2923 case lltok::kw_lshr:
2924 case lltok::kw_ashr:
2925 case lltok::kw_and:
2926 case lltok::kw_or:
2927 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
2928 case lltok::kw_icmp:
2929 case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal);
2930 // Casts.
2931 case lltok::kw_trunc:
2932 case lltok::kw_zext:
2933 case lltok::kw_sext:
2934 case lltok::kw_fptrunc:
2935 case lltok::kw_fpext:
2936 case lltok::kw_bitcast:
2937 case lltok::kw_uitofp:
2938 case lltok::kw_sitofp:
2939 case lltok::kw_fptoui:
2940 case lltok::kw_fptosi:
2941 case lltok::kw_inttoptr:
2942 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
2943 // Other.
2944 case lltok::kw_select: return ParseSelect(Inst, PFS);
2945 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
2946 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
2947 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
2948 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
2949 case lltok::kw_phi: return ParsePHI(Inst, PFS);
2950 case lltok::kw_call: return ParseCall(Inst, PFS, false);
2951 case lltok::kw_tail: return ParseCall(Inst, PFS, true);
2952 // Memory.
2953 case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
2954 case lltok::kw_malloc: return ParseAlloc(Inst, PFS, BB, false);
2955 case lltok::kw_free: return ParseFree(Inst, PFS, BB);
2956 case lltok::kw_load: return ParseLoad(Inst, PFS, false);
2957 case lltok::kw_store: return ParseStore(Inst, PFS, false);
2958 case lltok::kw_volatile:
2959 if (EatIfPresent(lltok::kw_load))
2960 return ParseLoad(Inst, PFS, true);
2961 else if (EatIfPresent(lltok::kw_store))
2962 return ParseStore(Inst, PFS, true);
2963 else
2964 return TokError("expected 'load' or 'store'");
2965 case lltok::kw_getresult: return ParseGetResult(Inst, PFS);
2966 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
2967 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
2968 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
2969 }
2970}
2971
2972/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
2973bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
2974 if (Opc == Instruction::FCmp) {
2975 switch (Lex.getKind()) {
2976 default: TokError("expected fcmp predicate (e.g. 'oeq')");
2977 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
2978 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
2979 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
2980 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
2981 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
2982 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
2983 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
2984 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
2985 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
2986 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
2987 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
2988 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
2989 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
2990 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
2991 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
2992 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
2993 }
2994 } else {
2995 switch (Lex.getKind()) {
2996 default: TokError("expected icmp predicate (e.g. 'eq')");
2997 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
2998 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
2999 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
3000 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
3001 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
3002 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
3003 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
3004 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
3005 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
3006 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
3007 }
3008 }
3009 Lex.Lex();
3010 return false;
3011}
3012
3013//===----------------------------------------------------------------------===//
3014// Terminator Instructions.
3015//===----------------------------------------------------------------------===//
3016
3017/// ParseRet - Parse a return instruction.
| 2859 lltok::Kind Token = Lex.getKind();
2860 if (Token == lltok::Eof)
2861 return TokError("found end of file when expecting more instructions");
2862 LocTy Loc = Lex.getLoc();
2863 unsigned KeywordVal = Lex.getUIntVal();
2864 Lex.Lex(); // Eat the keyword.
2865
2866 switch (Token) {
2867 default: return Error(Loc, "expected instruction opcode");
2868 // Terminator Instructions.
2869 case lltok::kw_unwind: Inst = new UnwindInst(Context); return false;
2870 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
2871 case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
2872 case lltok::kw_br: return ParseBr(Inst, PFS);
2873 case lltok::kw_switch: return ParseSwitch(Inst, PFS);
2874 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
2875 case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
2876 // Binary Operators.
2877 case lltok::kw_add:
2878 case lltok::kw_sub:
2879 case lltok::kw_mul: {
2880 bool NUW = false;
2881 bool NSW = false;
2882 LocTy ModifierLoc = Lex.getLoc();
2883 if (EatIfPresent(lltok::kw_nuw))
2884 NUW = true;
2885 if (EatIfPresent(lltok::kw_nsw)) {
2886 NSW = true;
2887 if (EatIfPresent(lltok::kw_nuw))
2888 NUW = true;
2889 }
2890 // API compatibility: Accept either integer or floating-point types.
2891 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0);
2892 if (!Result) {
2893 if (!Inst->getType()->isIntOrIntVector()) {
2894 if (NUW)
2895 return Error(ModifierLoc, "nuw only applies to integer operations");
2896 if (NSW)
2897 return Error(ModifierLoc, "nsw only applies to integer operations");
2898 }
2899 if (NUW)
2900 cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
2901 if (NSW)
2902 cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
2903 }
2904 return Result;
2905 }
2906 case lltok::kw_fadd:
2907 case lltok::kw_fsub:
2908 case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2909
2910 case lltok::kw_sdiv: {
2911 bool Exact = false;
2912 if (EatIfPresent(lltok::kw_exact))
2913 Exact = true;
2914 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1);
2915 if (!Result)
2916 if (Exact)
2917 cast<BinaryOperator>(Inst)->setIsExact(true);
2918 return Result;
2919 }
2920
2921 case lltok::kw_udiv:
2922 case lltok::kw_urem:
2923 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
2924 case lltok::kw_fdiv:
2925 case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2926 case lltok::kw_shl:
2927 case lltok::kw_lshr:
2928 case lltok::kw_ashr:
2929 case lltok::kw_and:
2930 case lltok::kw_or:
2931 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
2932 case lltok::kw_icmp:
2933 case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal);
2934 // Casts.
2935 case lltok::kw_trunc:
2936 case lltok::kw_zext:
2937 case lltok::kw_sext:
2938 case lltok::kw_fptrunc:
2939 case lltok::kw_fpext:
2940 case lltok::kw_bitcast:
2941 case lltok::kw_uitofp:
2942 case lltok::kw_sitofp:
2943 case lltok::kw_fptoui:
2944 case lltok::kw_fptosi:
2945 case lltok::kw_inttoptr:
2946 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
2947 // Other.
2948 case lltok::kw_select: return ParseSelect(Inst, PFS);
2949 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
2950 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
2951 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
2952 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
2953 case lltok::kw_phi: return ParsePHI(Inst, PFS);
2954 case lltok::kw_call: return ParseCall(Inst, PFS, false);
2955 case lltok::kw_tail: return ParseCall(Inst, PFS, true);
2956 // Memory.
2957 case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
2958 case lltok::kw_malloc: return ParseAlloc(Inst, PFS, BB, false);
2959 case lltok::kw_free: return ParseFree(Inst, PFS, BB);
2960 case lltok::kw_load: return ParseLoad(Inst, PFS, false);
2961 case lltok::kw_store: return ParseStore(Inst, PFS, false);
2962 case lltok::kw_volatile:
2963 if (EatIfPresent(lltok::kw_load))
2964 return ParseLoad(Inst, PFS, true);
2965 else if (EatIfPresent(lltok::kw_store))
2966 return ParseStore(Inst, PFS, true);
2967 else
2968 return TokError("expected 'load' or 'store'");
2969 case lltok::kw_getresult: return ParseGetResult(Inst, PFS);
2970 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
2971 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
2972 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
2973 }
2974}
2975
2976/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
2977bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
2978 if (Opc == Instruction::FCmp) {
2979 switch (Lex.getKind()) {
2980 default: TokError("expected fcmp predicate (e.g. 'oeq')");
2981 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
2982 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
2983 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
2984 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
2985 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
2986 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
2987 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
2988 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
2989 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
2990 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
2991 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
2992 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
2993 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
2994 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
2995 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
2996 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
2997 }
2998 } else {
2999 switch (Lex.getKind()) {
3000 default: TokError("expected icmp predicate (e.g. 'eq')");
3001 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
3002 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
3003 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
3004 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
3005 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
3006 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
3007 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
3008 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
3009 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
3010 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
3011 }
3012 }
3013 Lex.Lex();
3014 return false;
3015}
3016
3017//===----------------------------------------------------------------------===//
3018// Terminator Instructions.
3019//===----------------------------------------------------------------------===//
3020
3021/// ParseRet - Parse a return instruction.
|
3018/// ::= 'ret' void (',' !dbg, !1)
3019/// ::= 'ret' TypeAndValue (',' !dbg, !1)
3020/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' !dbg, !1)
| 3022/// ::= 'ret' void (',' !dbg, !1)*
3023/// ::= 'ret' TypeAndValue (',' !dbg, !1)*
3024/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' !dbg, !1)*
|
3021/// [[obsolete: LLVM 3.0]]
| 3025/// [[obsolete: LLVM 3.0]]
|
3022bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
3023 PerFunctionState &PFS) {
| 3026int LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
3027 PerFunctionState &PFS) {
|
3024 PATypeHolder Ty(Type::getVoidTy(Context));
3025 if (ParseType(Ty, true /*void allowed*/)) return true;
3026
3027 if (Ty->isVoidTy()) {
3028 Inst = ReturnInst::Create(Context);
3029 return false;
3030 }
3031
3032 Value *RV;
3033 if (ParseValue(Ty, RV, PFS)) return true;
3034
| 3028 PATypeHolder Ty(Type::getVoidTy(Context));
3029 if (ParseType(Ty, true /*void allowed*/)) return true;
3030
3031 if (Ty->isVoidTy()) {
3032 Inst = ReturnInst::Create(Context);
3033 return false;
3034 }
3035
3036 Value *RV;
3037 if (ParseValue(Ty, RV, PFS)) return true;
3038
|
| 3039 bool ExtraComma = false;
|
3035 if (EatIfPresent(lltok::comma)) {
3036 // Parse optional custom metadata, e.g. !dbg
| 3040 if (EatIfPresent(lltok::comma)) {
3041 // Parse optional custom metadata, e.g. !dbg
|
3037 if (Lex.getKind() == lltok::NamedOrCustomMD) {
3038 if (ParseOptionalCustomMetadata()) return true;
| 3042 if (Lex.getKind() == lltok::MetadataVar) {
3043 ExtraComma = true;
|
3039 } else {
3040 // The normal case is one return value.
| 3044 } else {
3045 // The normal case is one return value.
|
3041 // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring use
3042 // of 'ret {i32,i32} {i32 1, i32 2}'
| 3046 // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring
3047 // use of 'ret {i32,i32} {i32 1, i32 2}'
|
3043 SmallVector<Value*, 8> RVs;
3044 RVs.push_back(RV);
3045
3046 do {
3047 // If optional custom metadata, e.g. !dbg is seen then this is the
3048 // end of MRV.
| 3048 SmallVector<Value*, 8> RVs;
3049 RVs.push_back(RV);
3050
3051 do {
3052 // If optional custom metadata, e.g. !dbg is seen then this is the
3053 // end of MRV.
|
3049 if (Lex.getKind() == lltok::NamedOrCustomMD)
| 3054 if (Lex.getKind() == lltok::MetadataVar)
|
3050 break;
3051 if (ParseTypeAndValue(RV, PFS)) return true;
3052 RVs.push_back(RV);
3053 } while (EatIfPresent(lltok::comma));
3054
3055 RV = UndefValue::get(PFS.getFunction().getReturnType());
3056 for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
3057 Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
3058 BB->getInstList().push_back(I);
3059 RV = I;
3060 }
3061 }
3062 }
3063
3064 Inst = ReturnInst::Create(Context, RV);
| 3055 break;
3056 if (ParseTypeAndValue(RV, PFS)) return true;
3057 RVs.push_back(RV);
3058 } while (EatIfPresent(lltok::comma));
3059
3060 RV = UndefValue::get(PFS.getFunction().getReturnType());
3061 for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
3062 Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
3063 BB->getInstList().push_back(I);
3064 RV = I;
3065 }
3066 }
3067 }
3068
3069 Inst = ReturnInst::Create(Context, RV);
|
3065 return false;
| 3070 return ExtraComma ? InstExtraComma : InstNormal;
|
3066}
3067
3068
3069/// ParseBr
3070/// ::= 'br' TypeAndValue
3071/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3072bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
3073 LocTy Loc, Loc2;
3074 Value *Op0;
3075 BasicBlock *Op1, *Op2;
3076 if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
3077
3078 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
3079 Inst = BranchInst::Create(BB);
3080 return false;
3081 }
3082
3083 if (Op0->getType() != Type::getInt1Ty(Context))
3084 return Error(Loc, "branch condition must have 'i1' type");
3085
3086 if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
3087 ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
3088 ParseToken(lltok::comma, "expected ',' after true destination") ||
3089 ParseTypeAndBasicBlock(Op2, Loc2, PFS))
3090 return true;
3091
3092 Inst = BranchInst::Create(Op1, Op2, Op0);
3093 return false;
3094}
3095
3096/// ParseSwitch
3097/// Instruction
3098/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
3099/// JumpTable
3100/// ::= (TypeAndValue ',' TypeAndValue)*
3101bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
3102 LocTy CondLoc, BBLoc;
3103 Value *Cond;
3104 BasicBlock *DefaultBB;
3105 if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
3106 ParseToken(lltok::comma, "expected ',' after switch condition") ||
3107 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
3108 ParseToken(lltok::lsquare, "expected '[' with switch table"))
3109 return true;
3110
3111 if (!isa<IntegerType>(Cond->getType()))
3112 return Error(CondLoc, "switch condition must have integer type");
3113
3114 // Parse the jump table pairs.
3115 SmallPtrSet<Value*, 32> SeenCases;
3116 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
3117 while (Lex.getKind() != lltok::rsquare) {
3118 Value *Constant;
3119 BasicBlock *DestBB;
3120
3121 if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
3122 ParseToken(lltok::comma, "expected ',' after case value") ||
3123 ParseTypeAndBasicBlock(DestBB, PFS))
3124 return true;
3125
3126 if (!SeenCases.insert(Constant))
3127 return Error(CondLoc, "duplicate case value in switch");
3128 if (!isa<ConstantInt>(Constant))
3129 return Error(CondLoc, "case value is not a constant integer");
3130
3131 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
3132 }
3133
3134 Lex.Lex(); // Eat the ']'.
3135
3136 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
3137 for (unsigned i = 0, e = Table.size(); i != e; ++i)
3138 SI->addCase(Table[i].first, Table[i].second);
3139 Inst = SI;
3140 return false;
3141}
3142
3143/// ParseIndirectBr
3144/// Instruction
3145/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
3146bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
3147 LocTy AddrLoc;
3148 Value *Address;
3149 if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
3150 ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
3151 ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
3152 return true;
3153
3154 if (!isa<PointerType>(Address->getType()))
3155 return Error(AddrLoc, "indirectbr address must have pointer type");
3156
3157 // Parse the destination list.
3158 SmallVector<BasicBlock*, 16> DestList;
3159
3160 if (Lex.getKind() != lltok::rsquare) {
3161 BasicBlock *DestBB;
3162 if (ParseTypeAndBasicBlock(DestBB, PFS))
3163 return true;
3164 DestList.push_back(DestBB);
3165
3166 while (EatIfPresent(lltok::comma)) {
3167 if (ParseTypeAndBasicBlock(DestBB, PFS))
3168 return true;
3169 DestList.push_back(DestBB);
3170 }
3171 }
3172
3173 if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
3174 return true;
3175
3176 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
3177 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
3178 IBI->addDestination(DestList[i]);
3179 Inst = IBI;
3180 return false;
3181}
3182
3183
3184/// ParseInvoke
3185/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
3186/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
3187bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
3188 LocTy CallLoc = Lex.getLoc();
3189 unsigned RetAttrs, FnAttrs;
3190 CallingConv::ID CC;
3191 PATypeHolder RetType(Type::getVoidTy(Context));
3192 LocTy RetTypeLoc;
3193 ValID CalleeID;
3194 SmallVector<ParamInfo, 16> ArgList;
3195
3196 BasicBlock *NormalBB, *UnwindBB;
3197 if (ParseOptionalCallingConv(CC) ||
3198 ParseOptionalAttrs(RetAttrs, 1) ||
3199 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3200 ParseValID(CalleeID) ||
3201 ParseParameterList(ArgList, PFS) ||
3202 ParseOptionalAttrs(FnAttrs, 2) ||
3203 ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
3204 ParseTypeAndBasicBlock(NormalBB, PFS) ||
3205 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
3206 ParseTypeAndBasicBlock(UnwindBB, PFS))
3207 return true;
3208
3209 // If RetType is a non-function pointer type, then this is the short syntax
3210 // for the call, which means that RetType is just the return type. Infer the
3211 // rest of the function argument types from the arguments that are present.
3212 const PointerType *PFTy = 0;
3213 const FunctionType *Ty = 0;
3214 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3215 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3216 // Pull out the types of all of the arguments...
3217 std::vector<const Type*> ParamTypes;
3218 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3219 ParamTypes.push_back(ArgList[i].V->getType());
3220
3221 if (!FunctionType::isValidReturnType(RetType))
3222 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3223
3224 Ty = FunctionType::get(RetType, ParamTypes, false);
3225 PFTy = PointerType::getUnqual(Ty);
3226 }
3227
3228 // Look up the callee.
3229 Value *Callee;
3230 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3231
3232 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3233 // function attributes.
3234 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3235 if (FnAttrs & ObsoleteFuncAttrs) {
3236 RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3237 FnAttrs &= ~ObsoleteFuncAttrs;
3238 }
3239
3240 // Set up the Attributes for the function.
3241 SmallVector<AttributeWithIndex, 8> Attrs;
3242 if (RetAttrs != Attribute::None)
3243 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3244
3245 SmallVector<Value*, 8> Args;
3246
3247 // Loop through FunctionType's arguments and ensure they are specified
3248 // correctly. Also, gather any parameter attributes.
3249 FunctionType::param_iterator I = Ty->param_begin();
3250 FunctionType::param_iterator E = Ty->param_end();
3251 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3252 const Type *ExpectedTy = 0;
3253 if (I != E) {
3254 ExpectedTy = *I++;
3255 } else if (!Ty->isVarArg()) {
3256 return Error(ArgList[i].Loc, "too many arguments specified");
3257 }
3258
3259 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3260 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3261 ExpectedTy->getDescription() + "'");
3262 Args.push_back(ArgList[i].V);
3263 if (ArgList[i].Attrs != Attribute::None)
3264 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3265 }
3266
3267 if (I != E)
3268 return Error(CallLoc, "not enough parameters specified for call");
3269
3270 if (FnAttrs != Attribute::None)
3271 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3272
3273 // Finish off the Attributes and check them
3274 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3275
3276 InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB,
3277 Args.begin(), Args.end());
3278 II->setCallingConv(CC);
3279 II->setAttributes(PAL);
3280 Inst = II;
3281 return false;
3282}
3283
3284
3285
3286//===----------------------------------------------------------------------===//
3287// Binary Operators.
3288//===----------------------------------------------------------------------===//
3289
3290/// ParseArithmetic
3291/// ::= ArithmeticOps TypeAndValue ',' Value
3292///
3293/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1,
3294/// then any integer operand is allowed, if it is 2, any fp operand is allowed.
3295bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
3296 unsigned Opc, unsigned OperandType) {
3297 LocTy Loc; Value *LHS, *RHS;
3298 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3299 ParseToken(lltok::comma, "expected ',' in arithmetic operation") ||
3300 ParseValue(LHS->getType(), RHS, PFS))
3301 return true;
3302
3303 bool Valid;
3304 switch (OperandType) {
3305 default: llvm_unreachable("Unknown operand type!");
3306 case 0: // int or FP.
3307 Valid = LHS->getType()->isIntOrIntVector() ||
3308 LHS->getType()->isFPOrFPVector();
3309 break;
3310 case 1: Valid = LHS->getType()->isIntOrIntVector(); break;
3311 case 2: Valid = LHS->getType()->isFPOrFPVector(); break;
3312 }
3313
3314 if (!Valid)
3315 return Error(Loc, "invalid operand type for instruction");
3316
3317 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3318 return false;
3319}
3320
3321/// ParseLogical
3322/// ::= ArithmeticOps TypeAndValue ',' Value {
3323bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS,
3324 unsigned Opc) {
3325 LocTy Loc; Value *LHS, *RHS;
3326 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3327 ParseToken(lltok::comma, "expected ',' in logical operation") ||
3328 ParseValue(LHS->getType(), RHS, PFS))
3329 return true;
3330
3331 if (!LHS->getType()->isIntOrIntVector())
3332 return Error(Loc,"instruction requires integer or integer vector operands");
3333
3334 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3335 return false;
3336}
3337
3338
3339/// ParseCompare
3340/// ::= 'icmp' IPredicates TypeAndValue ',' Value
3341/// ::= 'fcmp' FPredicates TypeAndValue ',' Value
3342bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS,
3343 unsigned Opc) {
3344 // Parse the integer/fp comparison predicate.
3345 LocTy Loc;
3346 unsigned Pred;
3347 Value *LHS, *RHS;
3348 if (ParseCmpPredicate(Pred, Opc) ||
3349 ParseTypeAndValue(LHS, Loc, PFS) ||
3350 ParseToken(lltok::comma, "expected ',' after compare value") ||
3351 ParseValue(LHS->getType(), RHS, PFS))
3352 return true;
3353
3354 if (Opc == Instruction::FCmp) {
3355 if (!LHS->getType()->isFPOrFPVector())
3356 return Error(Loc, "fcmp requires floating point operands");
3357 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3358 } else {
3359 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
3360 if (!LHS->getType()->isIntOrIntVector() &&
3361 !isa<PointerType>(LHS->getType()))
3362 return Error(Loc, "icmp requires integer operands");
3363 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3364 }
3365 return false;
3366}
3367
3368//===----------------------------------------------------------------------===//
3369// Other Instructions.
3370//===----------------------------------------------------------------------===//
3371
3372
3373/// ParseCast
3374/// ::= CastOpc TypeAndValue 'to' Type
3375bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS,
3376 unsigned Opc) {
3377 LocTy Loc; Value *Op;
3378 PATypeHolder DestTy(Type::getVoidTy(Context));
3379 if (ParseTypeAndValue(Op, Loc, PFS) ||
3380 ParseToken(lltok::kw_to, "expected 'to' after cast value") ||
3381 ParseType(DestTy))
3382 return true;
3383
3384 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
3385 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
3386 return Error(Loc, "invalid cast opcode for cast from '" +
3387 Op->getType()->getDescription() + "' to '" +
3388 DestTy->getDescription() + "'");
3389 }
3390 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
3391 return false;
3392}
3393
3394/// ParseSelect
3395/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3396bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) {
3397 LocTy Loc;
3398 Value *Op0, *Op1, *Op2;
3399 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3400 ParseToken(lltok::comma, "expected ',' after select condition") ||
3401 ParseTypeAndValue(Op1, PFS) ||
3402 ParseToken(lltok::comma, "expected ',' after select value") ||
3403 ParseTypeAndValue(Op2, PFS))
3404 return true;
3405
3406 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
3407 return Error(Loc, Reason);
3408
3409 Inst = SelectInst::Create(Op0, Op1, Op2);
3410 return false;
3411}
3412
3413/// ParseVA_Arg
3414/// ::= 'va_arg' TypeAndValue ',' Type
3415bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) {
3416 Value *Op;
3417 PATypeHolder EltTy(Type::getVoidTy(Context));
3418 LocTy TypeLoc;
3419 if (ParseTypeAndValue(Op, PFS) ||
3420 ParseToken(lltok::comma, "expected ',' after vaarg operand") ||
3421 ParseType(EltTy, TypeLoc))
3422 return true;
3423
3424 if (!EltTy->isFirstClassType())
3425 return Error(TypeLoc, "va_arg requires operand with first class type");
3426
3427 Inst = new VAArgInst(Op, EltTy);
3428 return false;
3429}
3430
3431/// ParseExtractElement
3432/// ::= 'extractelement' TypeAndValue ',' TypeAndValue
3433bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
3434 LocTy Loc;
3435 Value *Op0, *Op1;
3436 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3437 ParseToken(lltok::comma, "expected ',' after extract value") ||
3438 ParseTypeAndValue(Op1, PFS))
3439 return true;
3440
3441 if (!ExtractElementInst::isValidOperands(Op0, Op1))
3442 return Error(Loc, "invalid extractelement operands");
3443
3444 Inst = ExtractElementInst::Create(Op0, Op1);
3445 return false;
3446}
3447
3448/// ParseInsertElement
3449/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3450bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
3451 LocTy Loc;
3452 Value *Op0, *Op1, *Op2;
3453 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3454 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3455 ParseTypeAndValue(Op1, PFS) ||
3456 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3457 ParseTypeAndValue(Op2, PFS))
3458 return true;
3459
3460 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
3461 return Error(Loc, "invalid insertelement operands");
3462
3463 Inst = InsertElementInst::Create(Op0, Op1, Op2);
3464 return false;
3465}
3466
3467/// ParseShuffleVector
3468/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3469bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
3470 LocTy Loc;
3471 Value *Op0, *Op1, *Op2;
3472 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3473 ParseToken(lltok::comma, "expected ',' after shuffle mask") ||
3474 ParseTypeAndValue(Op1, PFS) ||
3475 ParseToken(lltok::comma, "expected ',' after shuffle value") ||
3476 ParseTypeAndValue(Op2, PFS))
3477 return true;
3478
3479 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
3480 return Error(Loc, "invalid extractelement operands");
3481
3482 Inst = new ShuffleVectorInst(Op0, Op1, Op2);
3483 return false;
3484}
3485
3486/// ParsePHI
3487/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
| 3071}
3072
3073
3074/// ParseBr
3075/// ::= 'br' TypeAndValue
3076/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3077bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
3078 LocTy Loc, Loc2;
3079 Value *Op0;
3080 BasicBlock *Op1, *Op2;
3081 if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
3082
3083 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
3084 Inst = BranchInst::Create(BB);
3085 return false;
3086 }
3087
3088 if (Op0->getType() != Type::getInt1Ty(Context))
3089 return Error(Loc, "branch condition must have 'i1' type");
3090
3091 if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
3092 ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
3093 ParseToken(lltok::comma, "expected ',' after true destination") ||
3094 ParseTypeAndBasicBlock(Op2, Loc2, PFS))
3095 return true;
3096
3097 Inst = BranchInst::Create(Op1, Op2, Op0);
3098 return false;
3099}
3100
3101/// ParseSwitch
3102/// Instruction
3103/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
3104/// JumpTable
3105/// ::= (TypeAndValue ',' TypeAndValue)*
3106bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
3107 LocTy CondLoc, BBLoc;
3108 Value *Cond;
3109 BasicBlock *DefaultBB;
3110 if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
3111 ParseToken(lltok::comma, "expected ',' after switch condition") ||
3112 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
3113 ParseToken(lltok::lsquare, "expected '[' with switch table"))
3114 return true;
3115
3116 if (!isa<IntegerType>(Cond->getType()))
3117 return Error(CondLoc, "switch condition must have integer type");
3118
3119 // Parse the jump table pairs.
3120 SmallPtrSet<Value*, 32> SeenCases;
3121 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
3122 while (Lex.getKind() != lltok::rsquare) {
3123 Value *Constant;
3124 BasicBlock *DestBB;
3125
3126 if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
3127 ParseToken(lltok::comma, "expected ',' after case value") ||
3128 ParseTypeAndBasicBlock(DestBB, PFS))
3129 return true;
3130
3131 if (!SeenCases.insert(Constant))
3132 return Error(CondLoc, "duplicate case value in switch");
3133 if (!isa<ConstantInt>(Constant))
3134 return Error(CondLoc, "case value is not a constant integer");
3135
3136 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
3137 }
3138
3139 Lex.Lex(); // Eat the ']'.
3140
3141 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
3142 for (unsigned i = 0, e = Table.size(); i != e; ++i)
3143 SI->addCase(Table[i].first, Table[i].second);
3144 Inst = SI;
3145 return false;
3146}
3147
3148/// ParseIndirectBr
3149/// Instruction
3150/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
3151bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
3152 LocTy AddrLoc;
3153 Value *Address;
3154 if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
3155 ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
3156 ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
3157 return true;
3158
3159 if (!isa<PointerType>(Address->getType()))
3160 return Error(AddrLoc, "indirectbr address must have pointer type");
3161
3162 // Parse the destination list.
3163 SmallVector<BasicBlock*, 16> DestList;
3164
3165 if (Lex.getKind() != lltok::rsquare) {
3166 BasicBlock *DestBB;
3167 if (ParseTypeAndBasicBlock(DestBB, PFS))
3168 return true;
3169 DestList.push_back(DestBB);
3170
3171 while (EatIfPresent(lltok::comma)) {
3172 if (ParseTypeAndBasicBlock(DestBB, PFS))
3173 return true;
3174 DestList.push_back(DestBB);
3175 }
3176 }
3177
3178 if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
3179 return true;
3180
3181 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
3182 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
3183 IBI->addDestination(DestList[i]);
3184 Inst = IBI;
3185 return false;
3186}
3187
3188
3189/// ParseInvoke
3190/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
3191/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
3192bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
3193 LocTy CallLoc = Lex.getLoc();
3194 unsigned RetAttrs, FnAttrs;
3195 CallingConv::ID CC;
3196 PATypeHolder RetType(Type::getVoidTy(Context));
3197 LocTy RetTypeLoc;
3198 ValID CalleeID;
3199 SmallVector<ParamInfo, 16> ArgList;
3200
3201 BasicBlock *NormalBB, *UnwindBB;
3202 if (ParseOptionalCallingConv(CC) ||
3203 ParseOptionalAttrs(RetAttrs, 1) ||
3204 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3205 ParseValID(CalleeID) ||
3206 ParseParameterList(ArgList, PFS) ||
3207 ParseOptionalAttrs(FnAttrs, 2) ||
3208 ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
3209 ParseTypeAndBasicBlock(NormalBB, PFS) ||
3210 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
3211 ParseTypeAndBasicBlock(UnwindBB, PFS))
3212 return true;
3213
3214 // If RetType is a non-function pointer type, then this is the short syntax
3215 // for the call, which means that RetType is just the return type. Infer the
3216 // rest of the function argument types from the arguments that are present.
3217 const PointerType *PFTy = 0;
3218 const FunctionType *Ty = 0;
3219 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3220 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3221 // Pull out the types of all of the arguments...
3222 std::vector<const Type*> ParamTypes;
3223 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3224 ParamTypes.push_back(ArgList[i].V->getType());
3225
3226 if (!FunctionType::isValidReturnType(RetType))
3227 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3228
3229 Ty = FunctionType::get(RetType, ParamTypes, false);
3230 PFTy = PointerType::getUnqual(Ty);
3231 }
3232
3233 // Look up the callee.
3234 Value *Callee;
3235 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3236
3237 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3238 // function attributes.
3239 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3240 if (FnAttrs & ObsoleteFuncAttrs) {
3241 RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3242 FnAttrs &= ~ObsoleteFuncAttrs;
3243 }
3244
3245 // Set up the Attributes for the function.
3246 SmallVector<AttributeWithIndex, 8> Attrs;
3247 if (RetAttrs != Attribute::None)
3248 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3249
3250 SmallVector<Value*, 8> Args;
3251
3252 // Loop through FunctionType's arguments and ensure they are specified
3253 // correctly. Also, gather any parameter attributes.
3254 FunctionType::param_iterator I = Ty->param_begin();
3255 FunctionType::param_iterator E = Ty->param_end();
3256 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3257 const Type *ExpectedTy = 0;
3258 if (I != E) {
3259 ExpectedTy = *I++;
3260 } else if (!Ty->isVarArg()) {
3261 return Error(ArgList[i].Loc, "too many arguments specified");
3262 }
3263
3264 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3265 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3266 ExpectedTy->getDescription() + "'");
3267 Args.push_back(ArgList[i].V);
3268 if (ArgList[i].Attrs != Attribute::None)
3269 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3270 }
3271
3272 if (I != E)
3273 return Error(CallLoc, "not enough parameters specified for call");
3274
3275 if (FnAttrs != Attribute::None)
3276 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3277
3278 // Finish off the Attributes and check them
3279 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3280
3281 InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB,
3282 Args.begin(), Args.end());
3283 II->setCallingConv(CC);
3284 II->setAttributes(PAL);
3285 Inst = II;
3286 return false;
3287}
3288
3289
3290
3291//===----------------------------------------------------------------------===//
3292// Binary Operators.
3293//===----------------------------------------------------------------------===//
3294
3295/// ParseArithmetic
3296/// ::= ArithmeticOps TypeAndValue ',' Value
3297///
3298/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1,
3299/// then any integer operand is allowed, if it is 2, any fp operand is allowed.
3300bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
3301 unsigned Opc, unsigned OperandType) {
3302 LocTy Loc; Value *LHS, *RHS;
3303 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3304 ParseToken(lltok::comma, "expected ',' in arithmetic operation") ||
3305 ParseValue(LHS->getType(), RHS, PFS))
3306 return true;
3307
3308 bool Valid;
3309 switch (OperandType) {
3310 default: llvm_unreachable("Unknown operand type!");
3311 case 0: // int or FP.
3312 Valid = LHS->getType()->isIntOrIntVector() ||
3313 LHS->getType()->isFPOrFPVector();
3314 break;
3315 case 1: Valid = LHS->getType()->isIntOrIntVector(); break;
3316 case 2: Valid = LHS->getType()->isFPOrFPVector(); break;
3317 }
3318
3319 if (!Valid)
3320 return Error(Loc, "invalid operand type for instruction");
3321
3322 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3323 return false;
3324}
3325
3326/// ParseLogical
3327/// ::= ArithmeticOps TypeAndValue ',' Value {
3328bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS,
3329 unsigned Opc) {
3330 LocTy Loc; Value *LHS, *RHS;
3331 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3332 ParseToken(lltok::comma, "expected ',' in logical operation") ||
3333 ParseValue(LHS->getType(), RHS, PFS))
3334 return true;
3335
3336 if (!LHS->getType()->isIntOrIntVector())
3337 return Error(Loc,"instruction requires integer or integer vector operands");
3338
3339 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3340 return false;
3341}
3342
3343
3344/// ParseCompare
3345/// ::= 'icmp' IPredicates TypeAndValue ',' Value
3346/// ::= 'fcmp' FPredicates TypeAndValue ',' Value
3347bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS,
3348 unsigned Opc) {
3349 // Parse the integer/fp comparison predicate.
3350 LocTy Loc;
3351 unsigned Pred;
3352 Value *LHS, *RHS;
3353 if (ParseCmpPredicate(Pred, Opc) ||
3354 ParseTypeAndValue(LHS, Loc, PFS) ||
3355 ParseToken(lltok::comma, "expected ',' after compare value") ||
3356 ParseValue(LHS->getType(), RHS, PFS))
3357 return true;
3358
3359 if (Opc == Instruction::FCmp) {
3360 if (!LHS->getType()->isFPOrFPVector())
3361 return Error(Loc, "fcmp requires floating point operands");
3362 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3363 } else {
3364 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
3365 if (!LHS->getType()->isIntOrIntVector() &&
3366 !isa<PointerType>(LHS->getType()))
3367 return Error(Loc, "icmp requires integer operands");
3368 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3369 }
3370 return false;
3371}
3372
3373//===----------------------------------------------------------------------===//
3374// Other Instructions.
3375//===----------------------------------------------------------------------===//
3376
3377
3378/// ParseCast
3379/// ::= CastOpc TypeAndValue 'to' Type
3380bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS,
3381 unsigned Opc) {
3382 LocTy Loc; Value *Op;
3383 PATypeHolder DestTy(Type::getVoidTy(Context));
3384 if (ParseTypeAndValue(Op, Loc, PFS) ||
3385 ParseToken(lltok::kw_to, "expected 'to' after cast value") ||
3386 ParseType(DestTy))
3387 return true;
3388
3389 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
3390 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
3391 return Error(Loc, "invalid cast opcode for cast from '" +
3392 Op->getType()->getDescription() + "' to '" +
3393 DestTy->getDescription() + "'");
3394 }
3395 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
3396 return false;
3397}
3398
3399/// ParseSelect
3400/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3401bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) {
3402 LocTy Loc;
3403 Value *Op0, *Op1, *Op2;
3404 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3405 ParseToken(lltok::comma, "expected ',' after select condition") ||
3406 ParseTypeAndValue(Op1, PFS) ||
3407 ParseToken(lltok::comma, "expected ',' after select value") ||
3408 ParseTypeAndValue(Op2, PFS))
3409 return true;
3410
3411 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
3412 return Error(Loc, Reason);
3413
3414 Inst = SelectInst::Create(Op0, Op1, Op2);
3415 return false;
3416}
3417
3418/// ParseVA_Arg
3419/// ::= 'va_arg' TypeAndValue ',' Type
3420bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) {
3421 Value *Op;
3422 PATypeHolder EltTy(Type::getVoidTy(Context));
3423 LocTy TypeLoc;
3424 if (ParseTypeAndValue(Op, PFS) ||
3425 ParseToken(lltok::comma, "expected ',' after vaarg operand") ||
3426 ParseType(EltTy, TypeLoc))
3427 return true;
3428
3429 if (!EltTy->isFirstClassType())
3430 return Error(TypeLoc, "va_arg requires operand with first class type");
3431
3432 Inst = new VAArgInst(Op, EltTy);
3433 return false;
3434}
3435
3436/// ParseExtractElement
3437/// ::= 'extractelement' TypeAndValue ',' TypeAndValue
3438bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
3439 LocTy Loc;
3440 Value *Op0, *Op1;
3441 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3442 ParseToken(lltok::comma, "expected ',' after extract value") ||
3443 ParseTypeAndValue(Op1, PFS))
3444 return true;
3445
3446 if (!ExtractElementInst::isValidOperands(Op0, Op1))
3447 return Error(Loc, "invalid extractelement operands");
3448
3449 Inst = ExtractElementInst::Create(Op0, Op1);
3450 return false;
3451}
3452
3453/// ParseInsertElement
3454/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3455bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
3456 LocTy Loc;
3457 Value *Op0, *Op1, *Op2;
3458 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3459 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3460 ParseTypeAndValue(Op1, PFS) ||
3461 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3462 ParseTypeAndValue(Op2, PFS))
3463 return true;
3464
3465 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
3466 return Error(Loc, "invalid insertelement operands");
3467
3468 Inst = InsertElementInst::Create(Op0, Op1, Op2);
3469 return false;
3470}
3471
3472/// ParseShuffleVector
3473/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3474bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
3475 LocTy Loc;
3476 Value *Op0, *Op1, *Op2;
3477 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3478 ParseToken(lltok::comma, "expected ',' after shuffle mask") ||
3479 ParseTypeAndValue(Op1, PFS) ||
3480 ParseToken(lltok::comma, "expected ',' after shuffle value") ||
3481 ParseTypeAndValue(Op2, PFS))
3482 return true;
3483
3484 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
3485 return Error(Loc, "invalid extractelement operands");
3486
3487 Inst = new ShuffleVectorInst(Op0, Op1, Op2);
3488 return false;
3489}
3490
3491/// ParsePHI
3492/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
|
3488bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
| 3493int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
|
3489 PATypeHolder Ty(Type::getVoidTy(Context));
3490 Value *Op0, *Op1;
3491 LocTy TypeLoc = Lex.getLoc();
3492
3493 if (ParseType(Ty) ||
3494 ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3495 ParseValue(Ty, Op0, PFS) ||
3496 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3497 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3498 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3499 return true;
3500
| 3494 PATypeHolder Ty(Type::getVoidTy(Context));
3495 Value *Op0, *Op1;
3496 LocTy TypeLoc = Lex.getLoc();
3497
3498 if (ParseType(Ty) ||
3499 ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3500 ParseValue(Ty, Op0, PFS) ||
3501 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3502 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3503 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3504 return true;
3505
|
| 3506 bool AteExtraComma = false;
|
3501 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
3502 while (1) {
3503 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
3504
3505 if (!EatIfPresent(lltok::comma))
3506 break;
3507
| 3507 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
3508 while (1) {
3509 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
3510
3511 if (!EatIfPresent(lltok::comma))
3512 break;
3513
|
3508 if (Lex.getKind() == lltok::NamedOrCustomMD)
| 3514 if (Lex.getKind() == lltok::MetadataVar) {
3515 AteExtraComma = true;
|
3509 break;
| 3516 break;
|
| 3517 }
|
3510
3511 if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3512 ParseValue(Ty, Op0, PFS) ||
3513 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3514 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3515 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3516 return true;
3517 }
3518
| 3518
3519 if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3520 ParseValue(Ty, Op0, PFS) ||
3521 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3522 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3523 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3524 return true;
3525 }
3526
|
3519 if (Lex.getKind() == lltok::NamedOrCustomMD)
3520 if (ParseOptionalCustomMetadata()) return true;
3521
| |
3522 if (!Ty->isFirstClassType())
3523 return Error(TypeLoc, "phi node must have first class type");
3524
3525 PHINode *PN = PHINode::Create(Ty);
3526 PN->reserveOperandSpace(PHIVals.size());
3527 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
3528 PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
3529 Inst = PN;
| 3527 if (!Ty->isFirstClassType())
3528 return Error(TypeLoc, "phi node must have first class type");
3529
3530 PHINode *PN = PHINode::Create(Ty);
3531 PN->reserveOperandSpace(PHIVals.size());
3532 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
3533 PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
3534 Inst = PN;
|
3530 return false;
| 3535 return AteExtraComma ? InstExtraComma : InstNormal;
|
3531}
3532
3533/// ParseCall
3534/// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value
3535/// ParameterList OptionalAttrs
3536bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
3537 bool isTail) {
3538 unsigned RetAttrs, FnAttrs;
3539 CallingConv::ID CC;
3540 PATypeHolder RetType(Type::getVoidTy(Context));
3541 LocTy RetTypeLoc;
3542 ValID CalleeID;
3543 SmallVector<ParamInfo, 16> ArgList;
3544 LocTy CallLoc = Lex.getLoc();
3545
3546 if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) ||
3547 ParseOptionalCallingConv(CC) ||
3548 ParseOptionalAttrs(RetAttrs, 1) ||
3549 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3550 ParseValID(CalleeID) ||
3551 ParseParameterList(ArgList, PFS) ||
3552 ParseOptionalAttrs(FnAttrs, 2))
3553 return true;
3554
3555 // If RetType is a non-function pointer type, then this is the short syntax
3556 // for the call, which means that RetType is just the return type. Infer the
3557 // rest of the function argument types from the arguments that are present.
3558 const PointerType *PFTy = 0;
3559 const FunctionType *Ty = 0;
3560 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3561 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3562 // Pull out the types of all of the arguments...
3563 std::vector<const Type*> ParamTypes;
3564 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3565 ParamTypes.push_back(ArgList[i].V->getType());
3566
3567 if (!FunctionType::isValidReturnType(RetType))
3568 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3569
3570 Ty = FunctionType::get(RetType, ParamTypes, false);
3571 PFTy = PointerType::getUnqual(Ty);
3572 }
3573
3574 // Look up the callee.
3575 Value *Callee;
3576 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3577
3578 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3579 // function attributes.
3580 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3581 if (FnAttrs & ObsoleteFuncAttrs) {
3582 RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3583 FnAttrs &= ~ObsoleteFuncAttrs;
3584 }
3585
3586 // Set up the Attributes for the function.
3587 SmallVector<AttributeWithIndex, 8> Attrs;
3588 if (RetAttrs != Attribute::None)
3589 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3590
3591 SmallVector<Value*, 8> Args;
3592
3593 // Loop through FunctionType's arguments and ensure they are specified
3594 // correctly. Also, gather any parameter attributes.
3595 FunctionType::param_iterator I = Ty->param_begin();
3596 FunctionType::param_iterator E = Ty->param_end();
3597 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3598 const Type *ExpectedTy = 0;
3599 if (I != E) {
3600 ExpectedTy = *I++;
3601 } else if (!Ty->isVarArg()) {
3602 return Error(ArgList[i].Loc, "too many arguments specified");
3603 }
3604
3605 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3606 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3607 ExpectedTy->getDescription() + "'");
3608 Args.push_back(ArgList[i].V);
3609 if (ArgList[i].Attrs != Attribute::None)
3610 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3611 }
3612
3613 if (I != E)
3614 return Error(CallLoc, "not enough parameters specified for call");
3615
3616 if (FnAttrs != Attribute::None)
3617 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3618
3619 // Finish off the Attributes and check them
3620 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3621
3622 CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end());
3623 CI->setTailCall(isTail);
3624 CI->setCallingConv(CC);
3625 CI->setAttributes(PAL);
3626 Inst = CI;
3627 return false;
3628}
3629
3630//===----------------------------------------------------------------------===//
3631// Memory Instructions.
3632//===----------------------------------------------------------------------===//
3633
3634/// ParseAlloc
3635/// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)?
3636/// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)?
| 3536}
3537
3538/// ParseCall
3539/// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value
3540/// ParameterList OptionalAttrs
3541bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
3542 bool isTail) {
3543 unsigned RetAttrs, FnAttrs;
3544 CallingConv::ID CC;
3545 PATypeHolder RetType(Type::getVoidTy(Context));
3546 LocTy RetTypeLoc;
3547 ValID CalleeID;
3548 SmallVector<ParamInfo, 16> ArgList;
3549 LocTy CallLoc = Lex.getLoc();
3550
3551 if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) ||
3552 ParseOptionalCallingConv(CC) ||
3553 ParseOptionalAttrs(RetAttrs, 1) ||
3554 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3555 ParseValID(CalleeID) ||
3556 ParseParameterList(ArgList, PFS) ||
3557 ParseOptionalAttrs(FnAttrs, 2))
3558 return true;
3559
3560 // If RetType is a non-function pointer type, then this is the short syntax
3561 // for the call, which means that RetType is just the return type. Infer the
3562 // rest of the function argument types from the arguments that are present.
3563 const PointerType *PFTy = 0;
3564 const FunctionType *Ty = 0;
3565 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3566 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3567 // Pull out the types of all of the arguments...
3568 std::vector<const Type*> ParamTypes;
3569 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3570 ParamTypes.push_back(ArgList[i].V->getType());
3571
3572 if (!FunctionType::isValidReturnType(RetType))
3573 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3574
3575 Ty = FunctionType::get(RetType, ParamTypes, false);
3576 PFTy = PointerType::getUnqual(Ty);
3577 }
3578
3579 // Look up the callee.
3580 Value *Callee;
3581 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3582
3583 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3584 // function attributes.
3585 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3586 if (FnAttrs & ObsoleteFuncAttrs) {
3587 RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3588 FnAttrs &= ~ObsoleteFuncAttrs;
3589 }
3590
3591 // Set up the Attributes for the function.
3592 SmallVector<AttributeWithIndex, 8> Attrs;
3593 if (RetAttrs != Attribute::None)
3594 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3595
3596 SmallVector<Value*, 8> Args;
3597
3598 // Loop through FunctionType's arguments and ensure they are specified
3599 // correctly. Also, gather any parameter attributes.
3600 FunctionType::param_iterator I = Ty->param_begin();
3601 FunctionType::param_iterator E = Ty->param_end();
3602 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3603 const Type *ExpectedTy = 0;
3604 if (I != E) {
3605 ExpectedTy = *I++;
3606 } else if (!Ty->isVarArg()) {
3607 return Error(ArgList[i].Loc, "too many arguments specified");
3608 }
3609
3610 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3611 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3612 ExpectedTy->getDescription() + "'");
3613 Args.push_back(ArgList[i].V);
3614 if (ArgList[i].Attrs != Attribute::None)
3615 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3616 }
3617
3618 if (I != E)
3619 return Error(CallLoc, "not enough parameters specified for call");
3620
3621 if (FnAttrs != Attribute::None)
3622 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3623
3624 // Finish off the Attributes and check them
3625 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3626
3627 CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end());
3628 CI->setTailCall(isTail);
3629 CI->setCallingConv(CC);
3630 CI->setAttributes(PAL);
3631 Inst = CI;
3632 return false;
3633}
3634
3635//===----------------------------------------------------------------------===//
3636// Memory Instructions.
3637//===----------------------------------------------------------------------===//
3638
3639/// ParseAlloc
3640/// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)?
3641/// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)?
|
3637bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
3638 BasicBlock* BB, bool isAlloca) {
| 3642int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
3643 BasicBlock* BB, bool isAlloca) {
|
3639 PATypeHolder Ty(Type::getVoidTy(Context));
3640 Value *Size = 0;
3641 LocTy SizeLoc;
3642 unsigned Alignment = 0;
3643 if (ParseType(Ty)) return true;
3644
| 3644 PATypeHolder Ty(Type::getVoidTy(Context));
3645 Value *Size = 0;
3646 LocTy SizeLoc;
3647 unsigned Alignment = 0;
3648 if (ParseType(Ty)) return true;
3649
|
| 3650 bool AteExtraComma = false;
|
3645 if (EatIfPresent(lltok::comma)) {
| 3651 if (EatIfPresent(lltok::comma)) {
|
3646 if (Lex.getKind() == lltok::kw_align
3647 || Lex.getKind() == lltok::NamedOrCustomMD) {
3648 if (ParseOptionalInfo(Alignment)) return true;
| 3652 if (Lex.getKind() == lltok::kw_align) {
3653 if (ParseOptionalAlignment(Alignment)) return true;
3654 } else if (Lex.getKind() == lltok::MetadataVar) {
3655 AteExtraComma = true;
|
3649 } else {
| 3656 } else {
|
3650 if (ParseTypeAndValue(Size, SizeLoc, PFS)) return true;
3651 if (EatIfPresent(lltok::comma))
3652 if (ParseOptionalInfo(Alignment)) return true;
| 3657 if (ParseTypeAndValue(Size, SizeLoc, PFS) ||
3658 ParseOptionalCommaAlign(Alignment, AteExtraComma))
3659 return true;
|
3653 }
3654 }
3655
3656 if (Size && Size->getType() != Type::getInt32Ty(Context))
3657 return Error(SizeLoc, "element count must be i32");
3658
3659 if (isAlloca) {
3660 Inst = new AllocaInst(Ty, Size, Alignment);
| 3660 }
3661 }
3662
3663 if (Size && Size->getType() != Type::getInt32Ty(Context))
3664 return Error(SizeLoc, "element count must be i32");
3665
3666 if (isAlloca) {
3667 Inst = new AllocaInst(Ty, Size, Alignment);
|
3661 return false;
| 3668 return AteExtraComma ? InstExtraComma : InstNormal;
|
3662 }
3663
3664 // Autoupgrade old malloc instruction to malloc call.
3665 // FIXME: Remove in LLVM 3.0.
3666 const Type *IntPtrTy = Type::getInt32Ty(Context);
3667 Constant *AllocSize = ConstantExpr::getSizeOf(Ty);
3668 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy);
3669 if (!MallocF)
3670 // Prototype malloc as "void *(int32)".
3671 // This function is renamed as "malloc" in ValidateEndOfModule().
3672 MallocF = cast<Function>(
3673 M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL));
3674 Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF);
| 3669 }
3670
3671 // Autoupgrade old malloc instruction to malloc call.
3672 // FIXME: Remove in LLVM 3.0.
3673 const Type *IntPtrTy = Type::getInt32Ty(Context);
3674 Constant *AllocSize = ConstantExpr::getSizeOf(Ty);
3675 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy);
3676 if (!MallocF)
3677 // Prototype malloc as "void *(int32)".
3678 // This function is renamed as "malloc" in ValidateEndOfModule().
3679 MallocF = cast<Function>(
3680 M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL));
3681 Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF);
|
3675 return false;
| 3682return AteExtraComma ? InstExtraComma : InstNormal;
|
3676}
3677
3678/// ParseFree
3679/// ::= 'free' TypeAndValue
3680bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS,
3681 BasicBlock* BB) {
3682 Value *Val; LocTy Loc;
3683 if (ParseTypeAndValue(Val, Loc, PFS)) return true;
3684 if (!isa<PointerType>(Val->getType()))
3685 return Error(Loc, "operand to free must be a pointer");
3686 Inst = CallInst::CreateFree(Val, BB);
3687 return false;
3688}
3689
3690/// ParseLoad
3691/// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)?
| 3683}
3684
3685/// ParseFree
3686/// ::= 'free' TypeAndValue
3687bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS,
3688 BasicBlock* BB) {
3689 Value *Val; LocTy Loc;
3690 if (ParseTypeAndValue(Val, Loc, PFS)) return true;
3691 if (!isa<PointerType>(Val->getType()))
3692 return Error(Loc, "operand to free must be a pointer");
3693 Inst = CallInst::CreateFree(Val, BB);
3694 return false;
3695}
3696
3697/// ParseLoad
3698/// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)?
|
3692bool LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS,
3693 bool isVolatile) {
| 3699int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS,
3700 bool isVolatile) {
|
3694 Value *Val; LocTy Loc;
3695 unsigned Alignment = 0;
| 3701 Value *Val; LocTy Loc;
3702 unsigned Alignment = 0;
|
3696 if (ParseTypeAndValue(Val, Loc, PFS)) return true;
| 3703 bool AteExtraComma = false;
3704 if (ParseTypeAndValue(Val, Loc, PFS) ||
3705 ParseOptionalCommaAlign(Alignment, AteExtraComma))
3706 return true;
|
3697
| 3707
|
3698 if (EatIfPresent(lltok::comma))
3699 if (ParseOptionalInfo(Alignment)) return true;
3700
| |
3701 if (!isa<PointerType>(Val->getType()) ||
3702 !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType())
3703 return Error(Loc, "load operand must be a pointer to a first class type");
3704
3705 Inst = new LoadInst(Val, "", isVolatile, Alignment);
| 3708 if (!isa<PointerType>(Val->getType()) ||
3709 !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType())
3710 return Error(Loc, "load operand must be a pointer to a first class type");
3711
3712 Inst = new LoadInst(Val, "", isVolatile, Alignment);
|
3706 return false;
| 3713 return AteExtraComma ? InstExtraComma : InstNormal;
|
3707}
3708
3709/// ParseStore
3710/// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)?
| 3714}
3715
3716/// ParseStore
3717/// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)?
|
3711bool LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS,
3712 bool isVolatile) {
| 3718int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS,
3719 bool isVolatile) {
|
3713 Value *Val, *Ptr; LocTy Loc, PtrLoc;
3714 unsigned Alignment = 0;
| 3720 Value *Val, *Ptr; LocTy Loc, PtrLoc;
3721 unsigned Alignment = 0;
|
| 3722 bool AteExtraComma = false;
|
3715 if (ParseTypeAndValue(Val, Loc, PFS) ||
3716 ParseToken(lltok::comma, "expected ',' after store operand") ||
| 3723 if (ParseTypeAndValue(Val, Loc, PFS) ||
3724 ParseToken(lltok::comma, "expected ',' after store operand") ||
|
3717 ParseTypeAndValue(Ptr, PtrLoc, PFS))
| 3725 ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
3726 ParseOptionalCommaAlign(Alignment, AteExtraComma))
|
3718 return true;
3719
| 3727 return true;
3728
|
3720 if (EatIfPresent(lltok::comma))
3721 if (ParseOptionalInfo(Alignment)) return true;
3722
| |
3723 if (!isa<PointerType>(Ptr->getType()))
3724 return Error(PtrLoc, "store operand must be a pointer");
3725 if (!Val->getType()->isFirstClassType())
3726 return Error(Loc, "store operand must be a first class value");
3727 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
3728 return Error(Loc, "stored value and pointer type do not match");
3729
3730 Inst = new StoreInst(Val, Ptr, isVolatile, Alignment);
| 3729 if (!isa<PointerType>(Ptr->getType()))
3730 return Error(PtrLoc, "store operand must be a pointer");
3731 if (!Val->getType()->isFirstClassType())
3732 return Error(Loc, "store operand must be a first class value");
3733 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
3734 return Error(Loc, "stored value and pointer type do not match");
3735
3736 Inst = new StoreInst(Val, Ptr, isVolatile, Alignment);
|
3731 return false;
| 3737 return AteExtraComma ? InstExtraComma : InstNormal;
|
3732}
3733
3734/// ParseGetResult
3735/// ::= 'getresult' TypeAndValue ',' i32
3736/// FIXME: Remove support for getresult in LLVM 3.0
3737bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) {
3738 Value *Val; LocTy ValLoc, EltLoc;
3739 unsigned Element;
3740 if (ParseTypeAndValue(Val, ValLoc, PFS) ||
3741 ParseToken(lltok::comma, "expected ',' after getresult operand") ||
3742 ParseUInt32(Element, EltLoc))
3743 return true;
3744
3745 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3746 return Error(ValLoc, "getresult inst requires an aggregate operand");
3747 if (!ExtractValueInst::getIndexedType(Val->getType(), Element))
3748 return Error(EltLoc, "invalid getresult index for value");
3749 Inst = ExtractValueInst::Create(Val, Element);
3750 return false;
3751}
3752
3753/// ParseGetElementPtr
3754/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
| 3738}
3739
3740/// ParseGetResult
3741/// ::= 'getresult' TypeAndValue ',' i32
3742/// FIXME: Remove support for getresult in LLVM 3.0
3743bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) {
3744 Value *Val; LocTy ValLoc, EltLoc;
3745 unsigned Element;
3746 if (ParseTypeAndValue(Val, ValLoc, PFS) ||
3747 ParseToken(lltok::comma, "expected ',' after getresult operand") ||
3748 ParseUInt32(Element, EltLoc))
3749 return true;
3750
3751 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3752 return Error(ValLoc, "getresult inst requires an aggregate operand");
3753 if (!ExtractValueInst::getIndexedType(Val->getType(), Element))
3754 return Error(EltLoc, "invalid getresult index for value");
3755 Inst = ExtractValueInst::Create(Val, Element);
3756 return false;
3757}
3758
3759/// ParseGetElementPtr
3760/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
|
3755bool LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
| 3761int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
|
3756 Value *Ptr, *Val; LocTy Loc, EltLoc;
3757
3758 bool InBounds = EatIfPresent(lltok::kw_inbounds);
3759
3760 if (ParseTypeAndValue(Ptr, Loc, PFS)) return true;
3761
3762 if (!isa<PointerType>(Ptr->getType()))
3763 return Error(Loc, "base of getelementptr must be a pointer");
3764
3765 SmallVector<Value*, 16> Indices;
| 3762 Value *Ptr, *Val; LocTy Loc, EltLoc;
3763
3764 bool InBounds = EatIfPresent(lltok::kw_inbounds);
3765
3766 if (ParseTypeAndValue(Ptr, Loc, PFS)) return true;
3767
3768 if (!isa<PointerType>(Ptr->getType()))
3769 return Error(Loc, "base of getelementptr must be a pointer");
3770
3771 SmallVector<Value*, 16> Indices;
|
| 3772 bool AteExtraComma = false;
|
3766 while (EatIfPresent(lltok::comma)) {
| 3773 while (EatIfPresent(lltok::comma)) {
|
3767 if (Lex.getKind() == lltok::NamedOrCustomMD)
| 3774 if (Lex.getKind() == lltok::MetadataVar) {
3775 AteExtraComma = true;
|
3768 break;
| 3776 break;
|
| 3777 }
|
3769 if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
3770 if (!isa<IntegerType>(Val->getType()))
3771 return Error(EltLoc, "getelementptr index must be an integer");
3772 Indices.push_back(Val);
3773 }
| 3778 if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
3779 if (!isa<IntegerType>(Val->getType()))
3780 return Error(EltLoc, "getelementptr index must be an integer");
3781 Indices.push_back(Val);
3782 }
|
3774 if (Lex.getKind() == lltok::NamedOrCustomMD)
3775 if (ParseOptionalCustomMetadata()) return true;
| |
3776
3777 if (!GetElementPtrInst::getIndexedType(Ptr->getType(),
3778 Indices.begin(), Indices.end()))
3779 return Error(Loc, "invalid getelementptr indices");
3780 Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end());
3781 if (InBounds)
3782 cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
| 3783
3784 if (!GetElementPtrInst::getIndexedType(Ptr->getType(),
3785 Indices.begin(), Indices.end()))
3786 return Error(Loc, "invalid getelementptr indices");
3787 Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end());
3788 if (InBounds)
3789 cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
|
3783 return false;
| 3790 return AteExtraComma ? InstExtraComma : InstNormal;
|
3784}
3785
3786/// ParseExtractValue
3787/// ::= 'extractvalue' TypeAndValue (',' uint32)+
| 3791}
3792
3793/// ParseExtractValue
3794/// ::= 'extractvalue' TypeAndValue (',' uint32)+
|
3788bool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
| 3795int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
|
3789 Value *Val; LocTy Loc;
3790 SmallVector<unsigned, 4> Indices;
| 3796 Value *Val; LocTy Loc;
3797 SmallVector<unsigned, 4> Indices;
|
| 3798 bool AteExtraComma;
|
3791 if (ParseTypeAndValue(Val, Loc, PFS) ||
| 3799 if (ParseTypeAndValue(Val, Loc, PFS) ||
|
3792 ParseIndexList(Indices))
| 3800 ParseIndexList(Indices, AteExtraComma))
|
3793 return true;
| 3801 return true;
|
3794 if (Lex.getKind() == lltok::NamedOrCustomMD)
3795 if (ParseOptionalCustomMetadata()) return true;
| |
3796
3797 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3798 return Error(Loc, "extractvalue operand must be array or struct");
3799
3800 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
3801 Indices.end()))
3802 return Error(Loc, "invalid indices for extractvalue");
3803 Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end());
| 3802
3803 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3804 return Error(Loc, "extractvalue operand must be array or struct");
3805
3806 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
3807 Indices.end()))
3808 return Error(Loc, "invalid indices for extractvalue");
3809 Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end());
|
3804 return false;
| 3810 return AteExtraComma ? InstExtraComma : InstNormal;
|
3805}
3806
3807/// ParseInsertValue
3808/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
| 3811}
3812
3813/// ParseInsertValue
3814/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
|
3809bool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
| 3815int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
|
3810 Value *Val0, *Val1; LocTy Loc0, Loc1;
3811 SmallVector<unsigned, 4> Indices;
| 3816 Value *Val0, *Val1; LocTy Loc0, Loc1;
3817 SmallVector<unsigned, 4> Indices;
|
| 3818 bool AteExtraComma;
|
3812 if (ParseTypeAndValue(Val0, Loc0, PFS) ||
3813 ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
3814 ParseTypeAndValue(Val1, Loc1, PFS) ||
| 3819 if (ParseTypeAndValue(Val0, Loc0, PFS) ||
3820 ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
3821 ParseTypeAndValue(Val1, Loc1, PFS) ||
|
3815 ParseIndexList(Indices))
| 3822 ParseIndexList(Indices, AteExtraComma))
|
3816 return true;
| 3823 return true;
|
3817 if (Lex.getKind() == lltok::NamedOrCustomMD)
3818 if (ParseOptionalCustomMetadata()) return true;
3819
| 3824
|
3820 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
3821 return Error(Loc0, "extractvalue operand must be array or struct");
3822
3823 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
3824 Indices.end()))
3825 return Error(Loc0, "invalid indices for insertvalue");
3826 Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end());
| 3825 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
3826 return Error(Loc0, "extractvalue operand must be array or struct");
3827
3828 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
3829 Indices.end()))
3830 return Error(Loc0, "invalid indices for insertvalue");
3831 Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end());
|
3827 return false;
| 3832 return AteExtraComma ? InstExtraComma : InstNormal;
|
3828}
3829
3830//===----------------------------------------------------------------------===//
3831// Embedded metadata.
3832//===----------------------------------------------------------------------===//
3833
3834/// ParseMDNodeVector
3835/// ::= Element (',' Element)*
3836/// Element
3837/// ::= 'null' | TypeAndValue
3838bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) {
| 3833}
3834
3835//===----------------------------------------------------------------------===//
3836// Embedded metadata.
3837//===----------------------------------------------------------------------===//
3838
3839/// ParseMDNodeVector
3840/// ::= Element (',' Element)*
3841/// Element
3842/// ::= 'null' | TypeAndValue
3843bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) {
|
3839 assert(Lex.getKind() == lltok::lbrace);
3840 Lex.Lex();
| |
3841 do {
| 3844 do {
|
3842 Value *V = 0;
3843 if (Lex.getKind() == lltok::kw_null) {
3844 Lex.Lex();
3845 V = 0;
3846 } else {
3847 PATypeHolder Ty(Type::getVoidTy(Context));
3848 if (ParseType(Ty)) return true;
3849 if (Lex.getKind() == lltok::Metadata) {
3850 Lex.Lex();
3851 MetadataBase *Node = 0;
3852 if (!ParseMDNode(Node))
3853 V = Node;
3854 else {
3855 MetadataBase *MDS = 0;
3856 if (ParseMDString(MDS)) return true;
3857 V = MDS;
3858 }
3859 } else {
3860 Constant *C;
3861 if (ParseGlobalValue(Ty, C)) return true;
3862 V = C;
3863 }
| 3845 // Null is a special case since it is typeless.
3846 if (EatIfPresent(lltok::kw_null)) {
3847 Elts.push_back(0);
3848 continue;
|
3864 }
| 3849 }
|
| 3850
3851 Value *V = 0;
3852 PATypeHolder Ty(Type::getVoidTy(Context));
3853 ValID ID;
3854 if (ParseType(Ty) || ParseValID(ID) ||
3855 ConvertGlobalOrMetadataValIDToValue(Ty, ID, V))
3856 return true;
3857
|
3865 Elts.push_back(V);
3866 } while (EatIfPresent(lltok::comma));
3867
3868 return false;
3869}
| 3858 Elts.push_back(V);
3859 } while (EatIfPresent(lltok::comma));
3860
3861 return false;
3862}
|