Bug Summary

File:lib/AsmParser/LLParser.cpp
Warning:line 5257, column 7
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LLParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/lib/AsmParser -I /build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/lib/AsmParser -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp

/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp

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/ADT/DenseMap.h"
16#include "llvm/ADT/None.h"
17#include "llvm/ADT/Optional.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/AsmParser/SlotMapping.h"
21#include "llvm/BinaryFormat/Dwarf.h"
22#include "llvm/IR/Argument.h"
23#include "llvm/IR/AutoUpgrade.h"
24#include "llvm/IR/BasicBlock.h"
25#include "llvm/IR/CallingConv.h"
26#include "llvm/IR/Comdat.h"
27#include "llvm/IR/Constants.h"
28#include "llvm/IR/DebugInfoMetadata.h"
29#include "llvm/IR/DerivedTypes.h"
30#include "llvm/IR/Function.h"
31#include "llvm/IR/GlobalIFunc.h"
32#include "llvm/IR/GlobalObject.h"
33#include "llvm/IR/InlineAsm.h"
34#include "llvm/IR/Instruction.h"
35#include "llvm/IR/Instructions.h"
36#include "llvm/IR/Intrinsics.h"
37#include "llvm/IR/LLVMContext.h"
38#include "llvm/IR/Metadata.h"
39#include "llvm/IR/Module.h"
40#include "llvm/IR/Operator.h"
41#include "llvm/IR/Type.h"
42#include "llvm/IR/Value.h"
43#include "llvm/IR/ValueSymbolTable.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/MathExtras.h"
47#include "llvm/Support/SaveAndRestore.h"
48#include "llvm/Support/raw_ostream.h"
49#include <algorithm>
50#include <cassert>
51#include <cstring>
52#include <iterator>
53#include <vector>
54
55using namespace llvm;
56
57static std::string getTypeString(Type *T) {
58 std::string Result;
59 raw_string_ostream Tmp(Result);
60 Tmp << *T;
61 return Tmp.str();
62}
63
64/// Run: module ::= toplevelentity*
65bool LLParser::Run() {
66 // Prime the lexer.
67 Lex.Lex();
68
69 if (Context.shouldDiscardValueNames())
70 return Error(
71 Lex.getLoc(),
72 "Can't read textual IR with a Context that discards named Values");
73
74 return ParseTopLevelEntities() ||
75 ValidateEndOfModule();
76}
77
78bool LLParser::parseStandaloneConstantValue(Constant *&C,
79 const SlotMapping *Slots) {
80 restoreParsingState(Slots);
81 Lex.Lex();
82
83 Type *Ty = nullptr;
84 if (ParseType(Ty) || parseConstantValue(Ty, C))
85 return true;
86 if (Lex.getKind() != lltok::Eof)
87 return Error(Lex.getLoc(), "expected end of string");
88 return false;
89}
90
91bool LLParser::parseTypeAtBeginning(Type *&Ty, unsigned &Read,
92 const SlotMapping *Slots) {
93 restoreParsingState(Slots);
94 Lex.Lex();
95
96 Read = 0;
97 SMLoc Start = Lex.getLoc();
98 Ty = nullptr;
99 if (ParseType(Ty))
100 return true;
101 SMLoc End = Lex.getLoc();
102 Read = End.getPointer() - Start.getPointer();
103
104 return false;
105}
106
107void LLParser::restoreParsingState(const SlotMapping *Slots) {
108 if (!Slots)
109 return;
110 NumberedVals = Slots->GlobalValues;
111 NumberedMetadata = Slots->MetadataNodes;
112 for (const auto &I : Slots->NamedTypes)
113 NamedTypes.insert(
114 std::make_pair(I.getKey(), std::make_pair(I.second, LocTy())));
115 for (const auto &I : Slots->Types)
116 NumberedTypes.insert(
117 std::make_pair(I.first, std::make_pair(I.second, LocTy())));
118}
119
120/// ValidateEndOfModule - Do final validity and sanity checks at the end of the
121/// module.
122bool LLParser::ValidateEndOfModule() {
123 // Handle any function attribute group forward references.
124 for (const auto &RAG : ForwardRefAttrGroups) {
125 Value *V = RAG.first;
126 const std::vector<unsigned> &Attrs = RAG.second;
127 AttrBuilder B;
128
129 for (const auto &Attr : Attrs)
130 B.merge(NumberedAttrBuilders[Attr]);
131
132 if (Function *Fn = dyn_cast<Function>(V)) {
133 AttributeList AS = Fn->getAttributes();
134 AttrBuilder FnAttrs(AS.getFnAttributes());
135 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
136
137 FnAttrs.merge(B);
138
139 // If the alignment was parsed as an attribute, move to the alignment
140 // field.
141 if (FnAttrs.hasAlignmentAttr()) {
142 Fn->setAlignment(FnAttrs.getAlignment());
143 FnAttrs.removeAttribute(Attribute::Alignment);
144 }
145
146 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
147 AttributeSet::get(Context, FnAttrs));
148 Fn->setAttributes(AS);
149 } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
150 AttributeList AS = CI->getAttributes();
151 AttrBuilder FnAttrs(AS.getFnAttributes());
152 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
153 FnAttrs.merge(B);
154 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
155 AttributeSet::get(Context, FnAttrs));
156 CI->setAttributes(AS);
157 } else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) {
158 AttributeList AS = II->getAttributes();
159 AttrBuilder FnAttrs(AS.getFnAttributes());
160 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
161 FnAttrs.merge(B);
162 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
163 AttributeSet::get(Context, FnAttrs));
164 II->setAttributes(AS);
165 } else if (auto *GV = dyn_cast<GlobalVariable>(V)) {
166 AttrBuilder Attrs(GV->getAttributes());
167 Attrs.merge(B);
168 GV->setAttributes(AttributeSet::get(Context,Attrs));
169 } else {
170 llvm_unreachable("invalid object with forward attribute group reference")::llvm::llvm_unreachable_internal("invalid object with forward attribute group reference"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 170)
;
171 }
172 }
173
174 // If there are entries in ForwardRefBlockAddresses at this point, the
175 // function was never defined.
176 if (!ForwardRefBlockAddresses.empty())
177 return Error(ForwardRefBlockAddresses.begin()->first.Loc,
178 "expected function name in blockaddress");
179
180 for (const auto &NT : NumberedTypes)
181 if (NT.second.second.isValid())
182 return Error(NT.second.second,
183 "use of undefined type '%" + Twine(NT.first) + "'");
184
185 for (StringMap<std::pair<Type*, LocTy> >::iterator I =
186 NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
187 if (I->second.second.isValid())
188 return Error(I->second.second,
189 "use of undefined type named '" + I->getKey() + "'");
190
191 if (!ForwardRefComdats.empty())
192 return Error(ForwardRefComdats.begin()->second,
193 "use of undefined comdat '$" +
194 ForwardRefComdats.begin()->first + "'");
195
196 if (!ForwardRefVals.empty())
197 return Error(ForwardRefVals.begin()->second.second,
198 "use of undefined value '@" + ForwardRefVals.begin()->first +
199 "'");
200
201 if (!ForwardRefValIDs.empty())
202 return Error(ForwardRefValIDs.begin()->second.second,
203 "use of undefined value '@" +
204 Twine(ForwardRefValIDs.begin()->first) + "'");
205
206 if (!ForwardRefMDNodes.empty())
207 return Error(ForwardRefMDNodes.begin()->second.second,
208 "use of undefined metadata '!" +
209 Twine(ForwardRefMDNodes.begin()->first) + "'");
210
211 // Resolve metadata cycles.
212 for (auto &N : NumberedMetadata) {
213 if (N.second && !N.second->isResolved())
214 N.second->resolveCycles();
215 }
216
217 for (auto *Inst : InstsWithTBAATag) {
218 MDNode *MD = Inst->getMetadata(LLVMContext::MD_tbaa);
219 assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag")(static_cast <bool> (MD && "UpgradeInstWithTBAATag should have a TBAA tag"
) ? void (0) : __assert_fail ("MD && \"UpgradeInstWithTBAATag should have a TBAA tag\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 219, __extension__ __PRETTY_FUNCTION__))
;
220 auto *UpgradedMD = UpgradeTBAANode(*MD);
221 if (MD != UpgradedMD)
222 Inst->setMetadata(LLVMContext::MD_tbaa, UpgradedMD);
223 }
224
225 // Look for intrinsic functions and CallInst that need to be upgraded
226 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
227 UpgradeCallsToIntrinsic(&*FI++); // must be post-increment, as we remove
228
229 // Some types could be renamed during loading if several modules are
230 // loaded in the same LLVMContext (LTO scenario). In this case we should
231 // remangle intrinsics names as well.
232 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) {
233 Function *F = &*FI++;
234 if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) {
235 F->replaceAllUsesWith(Remangled.getValue());
236 F->eraseFromParent();
237 }
238 }
239
240 if (UpgradeDebugInfo)
241 llvm::UpgradeDebugInfo(*M);
242
243 UpgradeModuleFlags(*M);
244 UpgradeSectionAttributes(*M);
245
246 if (!Slots)
247 return false;
248 // Initialize the slot mapping.
249 // Because by this point we've parsed and validated everything, we can "steal"
250 // the mapping from LLParser as it doesn't need it anymore.
251 Slots->GlobalValues = std::move(NumberedVals);
252 Slots->MetadataNodes = std::move(NumberedMetadata);
253 for (const auto &I : NamedTypes)
254 Slots->NamedTypes.insert(std::make_pair(I.getKey(), I.second.first));
255 for (const auto &I : NumberedTypes)
256 Slots->Types.insert(std::make_pair(I.first, I.second.first));
257
258 return false;
259}
260
261//===----------------------------------------------------------------------===//
262// Top-Level Entities
263//===----------------------------------------------------------------------===//
264
265bool LLParser::ParseTopLevelEntities() {
266 while (true) {
267 switch (Lex.getKind()) {
268 default: return TokError("expected top-level entity");
269 case lltok::Eof: return false;
270 case lltok::kw_declare: if (ParseDeclare()) return true; break;
271 case lltok::kw_define: if (ParseDefine()) return true; break;
272 case lltok::kw_module: if (ParseModuleAsm()) return true; break;
273 case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
274 case lltok::kw_source_filename:
275 if (ParseSourceFileName())
276 return true;
277 break;
278 case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
279 case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
280 case lltok::LocalVar: if (ParseNamedType()) return true; break;
281 case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break;
282 case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break;
283 case lltok::ComdatVar: if (parseComdat()) return true; break;
284 case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break;
285 case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
286 case lltok::kw_attributes: if (ParseUnnamedAttrGrp()) return true; break;
287 case lltok::kw_uselistorder: if (ParseUseListOrder()) return true; break;
288 case lltok::kw_uselistorder_bb:
289 if (ParseUseListOrderBB())
290 return true;
291 break;
292 }
293 }
294}
295
296/// toplevelentity
297/// ::= 'module' 'asm' STRINGCONSTANT
298bool LLParser::ParseModuleAsm() {
299 assert(Lex.getKind() == lltok::kw_module)(static_cast <bool> (Lex.getKind() == lltok::kw_module)
? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_module"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300 Lex.Lex();
301
302 std::string AsmStr;
303 if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
304 ParseStringConstant(AsmStr)) return true;
305
306 M->appendModuleInlineAsm(AsmStr);
307 return false;
308}
309
310/// toplevelentity
311/// ::= 'target' 'triple' '=' STRINGCONSTANT
312/// ::= 'target' 'datalayout' '=' STRINGCONSTANT
313bool LLParser::ParseTargetDefinition() {
314 assert(Lex.getKind() == lltok::kw_target)(static_cast <bool> (Lex.getKind() == lltok::kw_target)
? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_target"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 314, __extension__ __PRETTY_FUNCTION__))
;
315 std::string Str;
316 switch (Lex.Lex()) {
317 default: return TokError("unknown target property");
318 case lltok::kw_triple:
319 Lex.Lex();
320 if (ParseToken(lltok::equal, "expected '=' after target triple") ||
321 ParseStringConstant(Str))
322 return true;
323 M->setTargetTriple(Str);
324 return false;
325 case lltok::kw_datalayout:
326 Lex.Lex();
327 if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
328 ParseStringConstant(Str))
329 return true;
330 if (DataLayoutStr.empty())
331 M->setDataLayout(Str);
332 return false;
333 }
334}
335
336/// toplevelentity
337/// ::= 'source_filename' '=' STRINGCONSTANT
338bool LLParser::ParseSourceFileName() {
339 assert(Lex.getKind() == lltok::kw_source_filename)(static_cast <bool> (Lex.getKind() == lltok::kw_source_filename
) ? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_source_filename"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 339, __extension__ __PRETTY_FUNCTION__))
;
340 std::string Str;
341 Lex.Lex();
342 if (ParseToken(lltok::equal, "expected '=' after source_filename") ||
343 ParseStringConstant(Str))
344 return true;
345 M->setSourceFileName(Str);
346 return false;
347}
348
349/// toplevelentity
350/// ::= 'deplibs' '=' '[' ']'
351/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
352/// FIXME: Remove in 4.0. Currently parse, but ignore.
353bool LLParser::ParseDepLibs() {
354 assert(Lex.getKind() == lltok::kw_deplibs)(static_cast <bool> (Lex.getKind() == lltok::kw_deplibs
) ? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_deplibs"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 354, __extension__ __PRETTY_FUNCTION__))
;
355 Lex.Lex();
356 if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
357 ParseToken(lltok::lsquare, "expected '=' after deplibs"))
358 return true;
359
360 if (EatIfPresent(lltok::rsquare))
361 return false;
362
363 do {
364 std::string Str;
365 if (ParseStringConstant(Str)) return true;
366 } while (EatIfPresent(lltok::comma));
367
368 return ParseToken(lltok::rsquare, "expected ']' at end of list");
369}
370
371/// ParseUnnamedType:
372/// ::= LocalVarID '=' 'type' type
373bool LLParser::ParseUnnamedType() {
374 LocTy TypeLoc = Lex.getLoc();
375 unsigned TypeID = Lex.getUIntVal();
376 Lex.Lex(); // eat LocalVarID;
377
378 if (ParseToken(lltok::equal, "expected '=' after name") ||
379 ParseToken(lltok::kw_type, "expected 'type' after '='"))
380 return true;
381
382 Type *Result = nullptr;
383 if (ParseStructDefinition(TypeLoc, "",
384 NumberedTypes[TypeID], Result)) return true;
385
386 if (!isa<StructType>(Result)) {
387 std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
388 if (Entry.first)
389 return Error(TypeLoc, "non-struct types may not be recursive");
390 Entry.first = Result;
391 Entry.second = SMLoc();
392 }
393
394 return false;
395}
396
397/// toplevelentity
398/// ::= LocalVar '=' 'type' type
399bool LLParser::ParseNamedType() {
400 std::string Name = Lex.getStrVal();
401 LocTy NameLoc = Lex.getLoc();
402 Lex.Lex(); // eat LocalVar.
403
404 if (ParseToken(lltok::equal, "expected '=' after name") ||
405 ParseToken(lltok::kw_type, "expected 'type' after name"))
406 return true;
407
408 Type *Result = nullptr;
409 if (ParseStructDefinition(NameLoc, Name,
410 NamedTypes[Name], Result)) return true;
411
412 if (!isa<StructType>(Result)) {
413 std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
414 if (Entry.first)
415 return Error(NameLoc, "non-struct types may not be recursive");
416 Entry.first = Result;
417 Entry.second = SMLoc();
418 }
419
420 return false;
421}
422
423/// toplevelentity
424/// ::= 'declare' FunctionHeader
425bool LLParser::ParseDeclare() {
426 assert(Lex.getKind() == lltok::kw_declare)(static_cast <bool> (Lex.getKind() == lltok::kw_declare
) ? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_declare"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 426, __extension__ __PRETTY_FUNCTION__))
;
427 Lex.Lex();
428
429 std::vector<std::pair<unsigned, MDNode *>> MDs;
430 while (Lex.getKind() == lltok::MetadataVar) {
431 unsigned MDK;
432 MDNode *N;
433 if (ParseMetadataAttachment(MDK, N))
434 return true;
435 MDs.push_back({MDK, N});
436 }
437
438 Function *F;
439 if (ParseFunctionHeader(F, false))
440 return true;
441 for (auto &MD : MDs)
442 F->addMetadata(MD.first, *MD.second);
443 return false;
444}
445
446/// toplevelentity
447/// ::= 'define' FunctionHeader (!dbg !56)* '{' ...
448bool LLParser::ParseDefine() {
449 assert(Lex.getKind() == lltok::kw_define)(static_cast <bool> (Lex.getKind() == lltok::kw_define)
? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_define"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 449, __extension__ __PRETTY_FUNCTION__))
;
450 Lex.Lex();
451
452 Function *F;
453 return ParseFunctionHeader(F, true) ||
454 ParseOptionalFunctionMetadata(*F) ||
455 ParseFunctionBody(*F);
1
Calling 'LLParser::ParseFunctionBody'
456}
457
458/// ParseGlobalType
459/// ::= 'constant'
460/// ::= 'global'
461bool LLParser::ParseGlobalType(bool &IsConstant) {
462 if (Lex.getKind() == lltok::kw_constant)
463 IsConstant = true;
464 else if (Lex.getKind() == lltok::kw_global)
465 IsConstant = false;
466 else {
467 IsConstant = false;
468 return TokError("expected 'global' or 'constant'");
469 }
470 Lex.Lex();
471 return false;
472}
473
474bool LLParser::ParseOptionalUnnamedAddr(
475 GlobalVariable::UnnamedAddr &UnnamedAddr) {
476 if (EatIfPresent(lltok::kw_unnamed_addr))
477 UnnamedAddr = GlobalValue::UnnamedAddr::Global;
478 else if (EatIfPresent(lltok::kw_local_unnamed_addr))
479 UnnamedAddr = GlobalValue::UnnamedAddr::Local;
480 else
481 UnnamedAddr = GlobalValue::UnnamedAddr::None;
482 return false;
483}
484
485/// ParseUnnamedGlobal:
486/// OptionalVisibility (ALIAS | IFUNC) ...
487/// OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
488/// OptionalDLLStorageClass
489/// ... -> global variable
490/// GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
491/// GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
492/// OptionalDLLStorageClass
493/// ... -> global variable
494bool LLParser::ParseUnnamedGlobal() {
495 unsigned VarID = NumberedVals.size();
496 std::string Name;
497 LocTy NameLoc = Lex.getLoc();
498
499 // Handle the GlobalID form.
500 if (Lex.getKind() == lltok::GlobalID) {
501 if (Lex.getUIntVal() != VarID)
502 return Error(Lex.getLoc(), "variable expected to be numbered '%" +
503 Twine(VarID) + "'");
504 Lex.Lex(); // eat GlobalID;
505
506 if (ParseToken(lltok::equal, "expected '=' after name"))
507 return true;
508 }
509
510 bool HasLinkage;
511 unsigned Linkage, Visibility, DLLStorageClass;
512 bool DSOLocal;
513 GlobalVariable::ThreadLocalMode TLM;
514 GlobalVariable::UnnamedAddr UnnamedAddr;
515 if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
516 DSOLocal) ||
517 ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
518 return true;
519
520 if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
521 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
522 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
523
524 return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
525 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
526}
527
528/// ParseNamedGlobal:
529/// GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
530/// GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
531/// OptionalVisibility OptionalDLLStorageClass
532/// ... -> global variable
533bool LLParser::ParseNamedGlobal() {
534 assert(Lex.getKind() == lltok::GlobalVar)(static_cast <bool> (Lex.getKind() == lltok::GlobalVar)
? void (0) : __assert_fail ("Lex.getKind() == lltok::GlobalVar"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 534, __extension__ __PRETTY_FUNCTION__))
;
535 LocTy NameLoc = Lex.getLoc();
536 std::string Name = Lex.getStrVal();
537 Lex.Lex();
538
539 bool HasLinkage;
540 unsigned Linkage, Visibility, DLLStorageClass;
541 bool DSOLocal;
542 GlobalVariable::ThreadLocalMode TLM;
543 GlobalVariable::UnnamedAddr UnnamedAddr;
544 if (ParseToken(lltok::equal, "expected '=' in global variable") ||
545 ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
546 DSOLocal) ||
547 ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
548 return true;
549
550 if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
551 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
552 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
553
554 return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
555 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
556}
557
558bool LLParser::parseComdat() {
559 assert(Lex.getKind() == lltok::ComdatVar)(static_cast <bool> (Lex.getKind() == lltok::ComdatVar)
? void (0) : __assert_fail ("Lex.getKind() == lltok::ComdatVar"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 559, __extension__ __PRETTY_FUNCTION__))
;
560 std::string Name = Lex.getStrVal();
561 LocTy NameLoc = Lex.getLoc();
562 Lex.Lex();
563
564 if (ParseToken(lltok::equal, "expected '=' here"))
565 return true;
566
567 if (ParseToken(lltok::kw_comdat, "expected comdat keyword"))
568 return TokError("expected comdat type");
569
570 Comdat::SelectionKind SK;
571 switch (Lex.getKind()) {
572 default:
573 return TokError("unknown selection kind");
574 case lltok::kw_any:
575 SK = Comdat::Any;
576 break;
577 case lltok::kw_exactmatch:
578 SK = Comdat::ExactMatch;
579 break;
580 case lltok::kw_largest:
581 SK = Comdat::Largest;
582 break;
583 case lltok::kw_noduplicates:
584 SK = Comdat::NoDuplicates;
585 break;
586 case lltok::kw_samesize:
587 SK = Comdat::SameSize;
588 break;
589 }
590 Lex.Lex();
591
592 // See if the comdat was forward referenced, if so, use the comdat.
593 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
594 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
595 if (I != ComdatSymTab.end() && !ForwardRefComdats.erase(Name))
596 return Error(NameLoc, "redefinition of comdat '$" + Name + "'");
597
598 Comdat *C;
599 if (I != ComdatSymTab.end())
600 C = &I->second;
601 else
602 C = M->getOrInsertComdat(Name);
603 C->setSelectionKind(SK);
604
605 return false;
606}
607
608// MDString:
609// ::= '!' STRINGCONSTANT
610bool LLParser::ParseMDString(MDString *&Result) {
611 std::string Str;
612 if (ParseStringConstant(Str)) return true;
613 Result = MDString::get(Context, Str);
614 return false;
615}
616
617// MDNode:
618// ::= '!' MDNodeNumber
619bool LLParser::ParseMDNodeID(MDNode *&Result) {
620 // !{ ..., !42, ... }
621 LocTy IDLoc = Lex.getLoc();
622 unsigned MID = 0;
623 if (ParseUInt32(MID))
624 return true;
625
626 // If not a forward reference, just return it now.
627 if (NumberedMetadata.count(MID)) {
628 Result = NumberedMetadata[MID];
629 return false;
630 }
631
632 // Otherwise, create MDNode forward reference.
633 auto &FwdRef = ForwardRefMDNodes[MID];
634 FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), IDLoc);
635
636 Result = FwdRef.first.get();
637 NumberedMetadata[MID].reset(Result);
638 return false;
639}
640
641/// ParseNamedMetadata:
642/// !foo = !{ !1, !2 }
643bool LLParser::ParseNamedMetadata() {
644 assert(Lex.getKind() == lltok::MetadataVar)(static_cast <bool> (Lex.getKind() == lltok::MetadataVar
) ? void (0) : __assert_fail ("Lex.getKind() == lltok::MetadataVar"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 644, __extension__ __PRETTY_FUNCTION__))
;
645 std::string Name = Lex.getStrVal();
646 Lex.Lex();
647
648 if (ParseToken(lltok::equal, "expected '=' here") ||
649 ParseToken(lltok::exclaim, "Expected '!' here") ||
650 ParseToken(lltok::lbrace, "Expected '{' here"))
651 return true;
652
653 NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
654 if (Lex.getKind() != lltok::rbrace)
655 do {
656 MDNode *N = nullptr;
657 // Parse DIExpressions inline as a special case. They are still MDNodes,
658 // so they can still appear in named metadata. Remove this logic if they
659 // become plain Metadata.
660 if (Lex.getKind() == lltok::MetadataVar &&
661 Lex.getStrVal() == "DIExpression") {
662 if (ParseDIExpression(N, /*IsDistinct=*/false))
663 return true;
664 } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
665 ParseMDNodeID(N)) {
666 return true;
667 }
668 NMD->addOperand(N);
669 } while (EatIfPresent(lltok::comma));
670
671 return ParseToken(lltok::rbrace, "expected end of metadata node");
672}
673
674/// ParseStandaloneMetadata:
675/// !42 = !{...}
676bool LLParser::ParseStandaloneMetadata() {
677 assert(Lex.getKind() == lltok::exclaim)(static_cast <bool> (Lex.getKind() == lltok::exclaim) ?
void (0) : __assert_fail ("Lex.getKind() == lltok::exclaim",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 677, __extension__ __PRETTY_FUNCTION__))
;
678 Lex.Lex();
679 unsigned MetadataID = 0;
680
681 MDNode *Init;
682 if (ParseUInt32(MetadataID) ||
683 ParseToken(lltok::equal, "expected '=' here"))
684 return true;
685
686 // Detect common error, from old metadata syntax.
687 if (Lex.getKind() == lltok::Type)
688 return TokError("unexpected type in metadata definition");
689
690 bool IsDistinct = EatIfPresent(lltok::kw_distinct);
691 if (Lex.getKind() == lltok::MetadataVar) {
692 if (ParseSpecializedMDNode(Init, IsDistinct))
693 return true;
694 } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
695 ParseMDTuple(Init, IsDistinct))
696 return true;
697
698 // See if this was forward referenced, if so, handle it.
699 auto FI = ForwardRefMDNodes.find(MetadataID);
700 if (FI != ForwardRefMDNodes.end()) {
701 FI->second.first->replaceAllUsesWith(Init);
702 ForwardRefMDNodes.erase(FI);
703
704 assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work")(static_cast <bool> (NumberedMetadata[MetadataID] == Init
&& "Tracking VH didn't work") ? void (0) : __assert_fail
("NumberedMetadata[MetadataID] == Init && \"Tracking VH didn't work\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 704, __extension__ __PRETTY_FUNCTION__))
;
705 } else {
706 if (NumberedMetadata.count(MetadataID))
707 return TokError("Metadata id is already used");
708 NumberedMetadata[MetadataID].reset(Init);
709 }
710
711 return false;
712}
713
714static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
715 return !GlobalValue::isLocalLinkage((GlobalValue::LinkageTypes)L) ||
716 (GlobalValue::VisibilityTypes)V == GlobalValue::DefaultVisibility;
717}
718
719// If there was an explicit dso_local, update GV. In the absence of an explicit
720// dso_local we keep the default value.
721static void maybeSetDSOLocal(bool DSOLocal, GlobalValue &GV) {
722 if (DSOLocal)
723 GV.setDSOLocal(true);
724}
725
726/// parseIndirectSymbol:
727/// ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
728/// OptionalVisibility OptionalDLLStorageClass
729/// OptionalThreadLocal OptionalUnnamedAddr
730// 'alias|ifunc' IndirectSymbol
731///
732/// IndirectSymbol
733/// ::= TypeAndValue
734///
735/// Everything through OptionalUnnamedAddr has already been parsed.
736///
737bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
738 unsigned L, unsigned Visibility,
739 unsigned DLLStorageClass, bool DSOLocal,
740 GlobalVariable::ThreadLocalMode TLM,
741 GlobalVariable::UnnamedAddr UnnamedAddr) {
742 bool IsAlias;
743 if (Lex.getKind() == lltok::kw_alias)
744 IsAlias = true;
745 else if (Lex.getKind() == lltok::kw_ifunc)
746 IsAlias = false;
747 else
748 llvm_unreachable("Not an alias or ifunc!")::llvm::llvm_unreachable_internal("Not an alias or ifunc!", "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 748)
;
749 Lex.Lex();
750
751 GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
752
753 if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
754 return Error(NameLoc, "invalid linkage type for alias");
755
756 if (!isValidVisibilityForLinkage(Visibility, L))
757 return Error(NameLoc,
758 "symbol with local linkage must have default visibility");
759
760 Type *Ty;
761 LocTy ExplicitTypeLoc = Lex.getLoc();
762 if (ParseType(Ty) ||
763 ParseToken(lltok::comma, "expected comma after alias or ifunc's type"))
764 return true;
765
766 Constant *Aliasee;
767 LocTy AliaseeLoc = Lex.getLoc();
768 if (Lex.getKind() != lltok::kw_bitcast &&
769 Lex.getKind() != lltok::kw_getelementptr &&
770 Lex.getKind() != lltok::kw_addrspacecast &&
771 Lex.getKind() != lltok::kw_inttoptr) {
772 if (ParseGlobalTypeAndValue(Aliasee))
773 return true;
774 } else {
775 // The bitcast dest type is not present, it is implied by the dest type.
776 ValID ID;
777 if (ParseValID(ID))
778 return true;
779 if (ID.Kind != ValID::t_Constant)
780 return Error(AliaseeLoc, "invalid aliasee");
781 Aliasee = ID.ConstantVal;
782 }
783
784 Type *AliaseeType = Aliasee->getType();
785 auto *PTy = dyn_cast<PointerType>(AliaseeType);
786 if (!PTy)
787 return Error(AliaseeLoc, "An alias or ifunc must have pointer type");
788 unsigned AddrSpace = PTy->getAddressSpace();
789
790 if (IsAlias && Ty != PTy->getElementType())
791 return Error(
792 ExplicitTypeLoc,
793 "explicit pointee type doesn't match operand's pointee type");
794
795 if (!IsAlias && !PTy->getElementType()->isFunctionTy())
796 return Error(
797 ExplicitTypeLoc,
798 "explicit pointee type should be a function type");
799
800 GlobalValue *GVal = nullptr;
801
802 // See if the alias was forward referenced, if so, prepare to replace the
803 // forward reference.
804 if (!Name.empty()) {
805 GVal = M->getNamedValue(Name);
806 if (GVal) {
807 if (!ForwardRefVals.erase(Name))
808 return Error(NameLoc, "redefinition of global '@" + Name + "'");
809 }
810 } else {
811 auto I = ForwardRefValIDs.find(NumberedVals.size());
812 if (I != ForwardRefValIDs.end()) {
813 GVal = I->second.first;
814 ForwardRefValIDs.erase(I);
815 }
816 }
817
818 // Okay, create the alias but do not insert it into the module yet.
819 std::unique_ptr<GlobalIndirectSymbol> GA;
820 if (IsAlias)
821 GA.reset(GlobalAlias::create(Ty, AddrSpace,
822 (GlobalValue::LinkageTypes)Linkage, Name,
823 Aliasee, /*Parent*/ nullptr));
824 else
825 GA.reset(GlobalIFunc::create(Ty, AddrSpace,
826 (GlobalValue::LinkageTypes)Linkage, Name,
827 Aliasee, /*Parent*/ nullptr));
828 GA->setThreadLocalMode(TLM);
829 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
830 GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
831 GA->setUnnamedAddr(UnnamedAddr);
832 maybeSetDSOLocal(DSOLocal, *GA);
833
834 if (Name.empty())
835 NumberedVals.push_back(GA.get());
836
837 if (GVal) {
838 // Verify that types agree.
839 if (GVal->getType() != GA->getType())
840 return Error(
841 ExplicitTypeLoc,
842 "forward reference and definition of alias have different types");
843
844 // If they agree, just RAUW the old value with the alias and remove the
845 // forward ref info.
846 GVal->replaceAllUsesWith(GA.get());
847 GVal->eraseFromParent();
848 }
849
850 // Insert into the module, we know its name won't collide now.
851 if (IsAlias)
852 M->getAliasList().push_back(cast<GlobalAlias>(GA.get()));
853 else
854 M->getIFuncList().push_back(cast<GlobalIFunc>(GA.get()));
855 assert(GA->getName() == Name && "Should not be a name conflict!")(static_cast <bool> (GA->getName() == Name &&
"Should not be a name conflict!") ? void (0) : __assert_fail
("GA->getName() == Name && \"Should not be a name conflict!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 855, __extension__ __PRETTY_FUNCTION__))
;
856
857 // The module owns this now
858 GA.release();
859
860 return false;
861}
862
863/// ParseGlobal
864/// ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
865/// OptionalVisibility OptionalDLLStorageClass
866/// OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
867/// OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
868/// ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
869/// OptionalDLLStorageClass OptionalThreadLocal OptionalUnnamedAddr
870/// OptionalAddrSpace OptionalExternallyInitialized GlobalType Type
871/// Const OptionalAttrs
872///
873/// Everything up to and including OptionalUnnamedAddr has been parsed
874/// already.
875///
876bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
877 unsigned Linkage, bool HasLinkage,
878 unsigned Visibility, unsigned DLLStorageClass,
879 bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
880 GlobalVariable::UnnamedAddr UnnamedAddr) {
881 if (!isValidVisibilityForLinkage(Visibility, Linkage))
882 return Error(NameLoc,
883 "symbol with local linkage must have default visibility");
884
885 unsigned AddrSpace;
886 bool IsConstant, IsExternallyInitialized;
887 LocTy IsExternallyInitializedLoc;
888 LocTy TyLoc;
889
890 Type *Ty = nullptr;
891 if (ParseOptionalAddrSpace(AddrSpace) ||
892 ParseOptionalToken(lltok::kw_externally_initialized,
893 IsExternallyInitialized,
894 &IsExternallyInitializedLoc) ||
895 ParseGlobalType(IsConstant) ||
896 ParseType(Ty, TyLoc))
897 return true;
898
899 // If the linkage is specified and is external, then no initializer is
900 // present.
901 Constant *Init = nullptr;
902 if (!HasLinkage ||
903 !GlobalValue::isValidDeclarationLinkage(
904 (GlobalValue::LinkageTypes)Linkage)) {
905 if (ParseGlobalValue(Ty, Init))
906 return true;
907 }
908
909 if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
910 return Error(TyLoc, "invalid type for global variable");
911
912 GlobalValue *GVal = nullptr;
913
914 // See if the global was forward referenced, if so, use the global.
915 if (!Name.empty()) {
916 GVal = M->getNamedValue(Name);
917 if (GVal) {
918 if (!ForwardRefVals.erase(Name))
919 return Error(NameLoc, "redefinition of global '@" + Name + "'");
920 }
921 } else {
922 auto I = ForwardRefValIDs.find(NumberedVals.size());
923 if (I != ForwardRefValIDs.end()) {
924 GVal = I->second.first;
925 ForwardRefValIDs.erase(I);
926 }
927 }
928
929 GlobalVariable *GV;
930 if (!GVal) {
931 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, nullptr,
932 Name, nullptr, GlobalVariable::NotThreadLocal,
933 AddrSpace);
934 } else {
935 if (GVal->getValueType() != Ty)
936 return Error(TyLoc,
937 "forward reference and definition of global have different types");
938
939 GV = cast<GlobalVariable>(GVal);
940
941 // Move the forward-reference to the correct spot in the module.
942 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
943 }
944
945 if (Name.empty())
946 NumberedVals.push_back(GV);
947
948 // Set the parsed properties on the global.
949 if (Init)
950 GV->setInitializer(Init);
951 GV->setConstant(IsConstant);
952 GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
953 maybeSetDSOLocal(DSOLocal, *GV);
954 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
955 GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
956 GV->setExternallyInitialized(IsExternallyInitialized);
957 GV->setThreadLocalMode(TLM);
958 GV->setUnnamedAddr(UnnamedAddr);
959
960 // Parse attributes on the global.
961 while (Lex.getKind() == lltok::comma) {
962 Lex.Lex();
963
964 if (Lex.getKind() == lltok::kw_section) {
965 Lex.Lex();
966 GV->setSection(Lex.getStrVal());
967 if (ParseToken(lltok::StringConstant, "expected global section string"))
968 return true;
969 } else if (Lex.getKind() == lltok::kw_align) {
970 unsigned Alignment;
971 if (ParseOptionalAlignment(Alignment)) return true;
972 GV->setAlignment(Alignment);
973 } else if (Lex.getKind() == lltok::MetadataVar) {
974 if (ParseGlobalObjectMetadataAttachment(*GV))
975 return true;
976 } else {
977 Comdat *C;
978 if (parseOptionalComdat(Name, C))
979 return true;
980 if (C)
981 GV->setComdat(C);
982 else
983 return TokError("unknown global variable property!");
984 }
985 }
986
987 AttrBuilder Attrs;
988 LocTy BuiltinLoc;
989 std::vector<unsigned> FwdRefAttrGrps;
990 if (ParseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc))
991 return true;
992 if (Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
993 GV->setAttributes(AttributeSet::get(Context, Attrs));
994 ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
995 }
996
997 return false;
998}
999
1000/// ParseUnnamedAttrGrp
1001/// ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
1002bool LLParser::ParseUnnamedAttrGrp() {
1003 assert(Lex.getKind() == lltok::kw_attributes)(static_cast <bool> (Lex.getKind() == lltok::kw_attributes
) ? void (0) : __assert_fail ("Lex.getKind() == lltok::kw_attributes"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 1003, __extension__ __PRETTY_FUNCTION__))
;
1004 LocTy AttrGrpLoc = Lex.getLoc();
1005 Lex.Lex();
1006
1007 if (Lex.getKind() != lltok::AttrGrpID)
1008 return TokError("expected attribute group id");
1009
1010 unsigned VarID = Lex.getUIntVal();
1011 std::vector<unsigned> unused;
1012 LocTy BuiltinLoc;
1013 Lex.Lex();
1014
1015 if (ParseToken(lltok::equal, "expected '=' here") ||
1016 ParseToken(lltok::lbrace, "expected '{' here") ||
1017 ParseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true,
1018 BuiltinLoc) ||
1019 ParseToken(lltok::rbrace, "expected end of attribute group"))
1020 return true;
1021
1022 if (!NumberedAttrBuilders[VarID].hasAttributes())
1023 return Error(AttrGrpLoc, "attribute group has no attributes");
1024
1025 return false;
1026}
1027
1028/// ParseFnAttributeValuePairs
1029/// ::= <attr> | <attr> '=' <value>
1030bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
1031 std::vector<unsigned> &FwdRefAttrGrps,
1032 bool inAttrGrp, LocTy &BuiltinLoc) {
1033 bool HaveError = false;
1034
1035 B.clear();
1036
1037 while (true) {
1038 lltok::Kind Token = Lex.getKind();
1039 if (Token == lltok::kw_builtin)
1040 BuiltinLoc = Lex.getLoc();
1041 switch (Token) {
1042 default:
1043 if (!inAttrGrp) return HaveError;
1044 return Error(Lex.getLoc(), "unterminated attribute group");
1045 case lltok::rbrace:
1046 // Finished.
1047 return false;
1048
1049 case lltok::AttrGrpID: {
1050 // Allow a function to reference an attribute group:
1051 //
1052 // define void @foo() #1 { ... }
1053 if (inAttrGrp)
1054 HaveError |=
1055 Error(Lex.getLoc(),
1056 "cannot have an attribute group reference in an attribute group");
1057
1058 unsigned AttrGrpNum = Lex.getUIntVal();
1059 if (inAttrGrp) break;
1060
1061 // Save the reference to the attribute group. We'll fill it in later.
1062 FwdRefAttrGrps.push_back(AttrGrpNum);
1063 break;
1064 }
1065 // Target-dependent attributes:
1066 case lltok::StringConstant: {
1067 if (ParseStringAttribute(B))
1068 return true;
1069 continue;
1070 }
1071
1072 // Target-independent attributes:
1073 case lltok::kw_align: {
1074 // As a hack, we allow function alignment to be initially parsed as an
1075 // attribute on a function declaration/definition or added to an attribute
1076 // group and later moved to the alignment field.
1077 unsigned Alignment;
1078 if (inAttrGrp) {
1079 Lex.Lex();
1080 if (ParseToken(lltok::equal, "expected '=' here") ||
1081 ParseUInt32(Alignment))
1082 return true;
1083 } else {
1084 if (ParseOptionalAlignment(Alignment))
1085 return true;
1086 }
1087 B.addAlignmentAttr(Alignment);
1088 continue;
1089 }
1090 case lltok::kw_alignstack: {
1091 unsigned Alignment;
1092 if (inAttrGrp) {
1093 Lex.Lex();
1094 if (ParseToken(lltok::equal, "expected '=' here") ||
1095 ParseUInt32(Alignment))
1096 return true;
1097 } else {
1098 if (ParseOptionalStackAlignment(Alignment))
1099 return true;
1100 }
1101 B.addStackAlignmentAttr(Alignment);
1102 continue;
1103 }
1104 case lltok::kw_allocsize: {
1105 unsigned ElemSizeArg;
1106 Optional<unsigned> NumElemsArg;
1107 // inAttrGrp doesn't matter; we only support allocsize(a[, b])
1108 if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
1109 return true;
1110 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1111 continue;
1112 }
1113 case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
1114 case lltok::kw_argmemonly: B.addAttribute(Attribute::ArgMemOnly); break;
1115 case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
1116 case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;
1117 case lltok::kw_convergent: B.addAttribute(Attribute::Convergent); break;
1118 case lltok::kw_inaccessiblememonly:
1119 B.addAttribute(Attribute::InaccessibleMemOnly); break;
1120 case lltok::kw_inaccessiblemem_or_argmemonly:
1121 B.addAttribute(Attribute::InaccessibleMemOrArgMemOnly); break;
1122 case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
1123 case lltok::kw_jumptable: B.addAttribute(Attribute::JumpTable); break;
1124 case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
1125 case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
1126 case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
1127 case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
1128 case lltok::kw_noimplicitfloat:
1129 B.addAttribute(Attribute::NoImplicitFloat); break;
1130 case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
1131 case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
1132 case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
1133 case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
1134 case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;
1135 case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
1136 case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break;
1137 case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
1138 case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
1139 case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
1140 case lltok::kw_returns_twice:
1141 B.addAttribute(Attribute::ReturnsTwice); break;
1142 case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break;
1143 case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
1144 case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
1145 case lltok::kw_sspstrong:
1146 B.addAttribute(Attribute::StackProtectStrong); break;
1147 case lltok::kw_safestack: B.addAttribute(Attribute::SafeStack); break;
1148 case lltok::kw_sanitize_address:
1149 B.addAttribute(Attribute::SanitizeAddress); break;
1150 case lltok::kw_sanitize_hwaddress:
1151 B.addAttribute(Attribute::SanitizeHWAddress); break;
1152 case lltok::kw_sanitize_thread:
1153 B.addAttribute(Attribute::SanitizeThread); break;
1154 case lltok::kw_sanitize_memory:
1155 B.addAttribute(Attribute::SanitizeMemory); break;
1156 case lltok::kw_strictfp: B.addAttribute(Attribute::StrictFP); break;
1157 case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
1158 case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
1159
1160 // Error handling.
1161 case lltok::kw_inreg:
1162 case lltok::kw_signext:
1163 case lltok::kw_zeroext:
1164 HaveError |=
1165 Error(Lex.getLoc(),
1166 "invalid use of attribute on a function");
1167 break;
1168 case lltok::kw_byval:
1169 case lltok::kw_dereferenceable:
1170 case lltok::kw_dereferenceable_or_null:
1171 case lltok::kw_inalloca:
1172 case lltok::kw_nest:
1173 case lltok::kw_noalias:
1174 case lltok::kw_nocapture:
1175 case lltok::kw_nonnull:
1176 case lltok::kw_returned:
1177 case lltok::kw_sret:
1178 case lltok::kw_swifterror:
1179 case lltok::kw_swiftself:
1180 HaveError |=
1181 Error(Lex.getLoc(),
1182 "invalid use of parameter-only attribute on a function");
1183 break;
1184 }
1185
1186 Lex.Lex();
1187 }
1188}
1189
1190//===----------------------------------------------------------------------===//
1191// GlobalValue Reference/Resolution Routines.
1192//===----------------------------------------------------------------------===//
1193
1194static inline GlobalValue *createGlobalFwdRef(Module *M, PointerType *PTy,
1195 const std::string &Name) {
1196 if (auto *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1197 return Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
1198 else
1199 return new GlobalVariable(*M, PTy->getElementType(), false,
1200 GlobalValue::ExternalWeakLinkage, nullptr, Name,
1201 nullptr, GlobalVariable::NotThreadLocal,
1202 PTy->getAddressSpace());
1203}
1204
1205/// GetGlobalVal - Get a value with the specified name or ID, creating a
1206/// forward reference record if needed. This can return null if the value
1207/// exists but does not have the right type.
1208GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
1209 LocTy Loc) {
1210 PointerType *PTy = dyn_cast<PointerType>(Ty);
1211 if (!PTy) {
1212 Error(Loc, "global variable reference must have pointer type");
1213 return nullptr;
1214 }
1215
1216 // Look this name up in the normal function symbol table.
1217 GlobalValue *Val =
1218 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
1219
1220 // If this is a forward reference for the value, see if we already created a
1221 // forward ref record.
1222 if (!Val) {
1223 auto I = ForwardRefVals.find(Name);
1224 if (I != ForwardRefVals.end())
1225 Val = I->second.first;
1226 }
1227
1228 // If we have the value in the symbol table or fwd-ref table, return it.
1229 if (Val) {
1230 if (Val->getType() == Ty) return Val;
1231 Error(Loc, "'@" + Name + "' defined with type '" +
1232 getTypeString(Val->getType()) + "'");
1233 return nullptr;
1234 }
1235
1236 // Otherwise, create a new forward reference for this value and remember it.
1237 GlobalValue *FwdVal = createGlobalFwdRef(M, PTy, Name);
1238 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1239 return FwdVal;
1240}
1241
1242GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
1243 PointerType *PTy = dyn_cast<PointerType>(Ty);
1244 if (!PTy) {
1245 Error(Loc, "global variable reference must have pointer type");
1246 return nullptr;
1247 }
1248
1249 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
1250
1251 // If this is a forward reference for the value, see if we already created a
1252 // forward ref record.
1253 if (!Val) {
1254 auto I = ForwardRefValIDs.find(ID);
1255 if (I != ForwardRefValIDs.end())
1256 Val = I->second.first;
1257 }
1258
1259 // If we have the value in the symbol table or fwd-ref table, return it.
1260 if (Val) {
1261 if (Val->getType() == Ty) return Val;
1262 Error(Loc, "'@" + Twine(ID) + "' defined with type '" +
1263 getTypeString(Val->getType()) + "'");
1264 return nullptr;
1265 }
1266
1267 // Otherwise, create a new forward reference for this value and remember it.
1268 GlobalValue *FwdVal = createGlobalFwdRef(M, PTy, "");
1269 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1270 return FwdVal;
1271}
1272
1273//===----------------------------------------------------------------------===//
1274// Comdat Reference/Resolution Routines.
1275//===----------------------------------------------------------------------===//
1276
1277Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
1278 // Look this name up in the comdat symbol table.
1279 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
1280 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
1281 if (I != ComdatSymTab.end())
1282 return &I->second;
1283
1284 // Otherwise, create a new forward reference for this value and remember it.
1285 Comdat *C = M->getOrInsertComdat(Name);
1286 ForwardRefComdats[Name] = Loc;
1287 return C;
1288}
1289
1290//===----------------------------------------------------------------------===//
1291// Helper Routines.
1292//===----------------------------------------------------------------------===//
1293
1294/// ParseToken - If the current token has the specified kind, eat it and return
1295/// success. Otherwise, emit the specified error and return failure.
1296bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
1297 if (Lex.getKind() != T)
1298 return TokError(ErrMsg);
1299 Lex.Lex();
1300 return false;
1301}
1302
1303/// ParseStringConstant
1304/// ::= StringConstant
1305bool LLParser::ParseStringConstant(std::string &Result) {
1306 if (Lex.getKind() != lltok::StringConstant)
1307 return TokError("expected string constant");
1308 Result = Lex.getStrVal();
1309 Lex.Lex();
1310 return false;
1311}
1312
1313/// ParseUInt32
1314/// ::= uint32
1315bool LLParser::ParseUInt32(uint32_t &Val) {
1316 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1317 return TokError("expected integer");
1318 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
1319 if (Val64 != unsigned(Val64))
1320 return TokError("expected 32-bit integer (too large)");
1321 Val = Val64;
1322 Lex.Lex();
1323 return false;
1324}
1325
1326/// ParseUInt64
1327/// ::= uint64
1328bool LLParser::ParseUInt64(uint64_t &Val) {
1329 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1330 return TokError("expected integer");
1331 Val = Lex.getAPSIntVal().getLimitedValue();
1332 Lex.Lex();
1333 return false;
1334}
1335
1336/// ParseTLSModel
1337/// := 'localdynamic'
1338/// := 'initialexec'
1339/// := 'localexec'
1340bool LLParser::ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
1341 switch (Lex.getKind()) {
1342 default:
1343 return TokError("expected localdynamic, initialexec or localexec");
1344 case lltok::kw_localdynamic:
1345 TLM = GlobalVariable::LocalDynamicTLSModel;
1346 break;
1347 case lltok::kw_initialexec:
1348 TLM = GlobalVariable::InitialExecTLSModel;
1349 break;
1350 case lltok::kw_localexec:
1351 TLM = GlobalVariable::LocalExecTLSModel;
1352 break;
1353 }
1354
1355 Lex.Lex();
1356 return false;
1357}
1358
1359/// ParseOptionalThreadLocal
1360/// := /*empty*/
1361/// := 'thread_local'
1362/// := 'thread_local' '(' tlsmodel ')'
1363bool LLParser::ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
1364 TLM = GlobalVariable::NotThreadLocal;
1365 if (!EatIfPresent(lltok::kw_thread_local))
1366 return false;
1367
1368 TLM = GlobalVariable::GeneralDynamicTLSModel;
1369 if (Lex.getKind() == lltok::lparen) {
1370 Lex.Lex();
1371 return ParseTLSModel(TLM) ||
1372 ParseToken(lltok::rparen, "expected ')' after thread local model");
1373 }
1374 return false;
1375}
1376
1377/// ParseOptionalAddrSpace
1378/// := /*empty*/
1379/// := 'addrspace' '(' uint32 ')'
1380bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
1381 AddrSpace = 0;
1382 if (!EatIfPresent(lltok::kw_addrspace))
1383 return false;
1384 return ParseToken(lltok::lparen, "expected '(' in address space") ||
1385 ParseUInt32(AddrSpace) ||
1386 ParseToken(lltok::rparen, "expected ')' in address space");
1387}
1388
1389/// ParseStringAttribute
1390/// := StringConstant
1391/// := StringConstant '=' StringConstant
1392bool LLParser::ParseStringAttribute(AttrBuilder &B) {
1393 std::string Attr = Lex.getStrVal();
1394 Lex.Lex();
1395 std::string Val;
1396 if (EatIfPresent(lltok::equal) && ParseStringConstant(Val))
1397 return true;
1398 B.addAttribute(Attr, Val);
1399 return false;
1400}
1401
1402/// ParseOptionalParamAttrs - Parse a potentially empty list of parameter attributes.
1403bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
1404 bool HaveError = false;
1405
1406 B.clear();
1407
1408 while (true) {
1409 lltok::Kind Token = Lex.getKind();
1410 switch (Token) {
1411 default: // End of attributes.
1412 return HaveError;
1413 case lltok::StringConstant: {
1414 if (ParseStringAttribute(B))
1415 return true;
1416 continue;
1417 }
1418 case lltok::kw_align: {
1419 unsigned Alignment;
1420 if (ParseOptionalAlignment(Alignment))
1421 return true;
1422 B.addAlignmentAttr(Alignment);
1423 continue;
1424 }
1425 case lltok::kw_byval: B.addAttribute(Attribute::ByVal); break;
1426 case lltok::kw_dereferenceable: {
1427 uint64_t Bytes;
1428 if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1429 return true;
1430 B.addDereferenceableAttr(Bytes);
1431 continue;
1432 }
1433 case lltok::kw_dereferenceable_or_null: {
1434 uint64_t Bytes;
1435 if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1436 return true;
1437 B.addDereferenceableOrNullAttr(Bytes);
1438 continue;
1439 }
1440 case lltok::kw_inalloca: B.addAttribute(Attribute::InAlloca); break;
1441 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1442 case lltok::kw_nest: B.addAttribute(Attribute::Nest); break;
1443 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1444 case lltok::kw_nocapture: B.addAttribute(Attribute::NoCapture); break;
1445 case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
1446 case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
1447 case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
1448 case lltok::kw_returned: B.addAttribute(Attribute::Returned); break;
1449 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1450 case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break;
1451 case lltok::kw_swifterror: B.addAttribute(Attribute::SwiftError); break;
1452 case lltok::kw_swiftself: B.addAttribute(Attribute::SwiftSelf); break;
1453 case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
1454 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1455
1456 case lltok::kw_alignstack:
1457 case lltok::kw_alwaysinline:
1458 case lltok::kw_argmemonly:
1459 case lltok::kw_builtin:
1460 case lltok::kw_inlinehint:
1461 case lltok::kw_jumptable:
1462 case lltok::kw_minsize:
1463 case lltok::kw_naked:
1464 case lltok::kw_nobuiltin:
1465 case lltok::kw_noduplicate:
1466 case lltok::kw_noimplicitfloat:
1467 case lltok::kw_noinline:
1468 case lltok::kw_nonlazybind:
1469 case lltok::kw_noredzone:
1470 case lltok::kw_noreturn:
1471 case lltok::kw_nounwind:
1472 case lltok::kw_optnone:
1473 case lltok::kw_optsize:
1474 case lltok::kw_returns_twice:
1475 case lltok::kw_sanitize_address:
1476 case lltok::kw_sanitize_hwaddress:
1477 case lltok::kw_sanitize_memory:
1478 case lltok::kw_sanitize_thread:
1479 case lltok::kw_ssp:
1480 case lltok::kw_sspreq:
1481 case lltok::kw_sspstrong:
1482 case lltok::kw_safestack:
1483 case lltok::kw_strictfp:
1484 case lltok::kw_uwtable:
1485 HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1486 break;
1487 }
1488
1489 Lex.Lex();
1490 }
1491}
1492
1493/// ParseOptionalReturnAttrs - Parse a potentially empty list of return attributes.
1494bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
1495 bool HaveError = false;
1496
1497 B.clear();
1498
1499 while (true) {
1500 lltok::Kind Token = Lex.getKind();
1501 switch (Token) {
1502 default: // End of attributes.
1503 return HaveError;
1504 case lltok::StringConstant: {
1505 if (ParseStringAttribute(B))
1506 return true;
1507 continue;
1508 }
1509 case lltok::kw_dereferenceable: {
1510 uint64_t Bytes;
1511 if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1512 return true;
1513 B.addDereferenceableAttr(Bytes);
1514 continue;
1515 }
1516 case lltok::kw_dereferenceable_or_null: {
1517 uint64_t Bytes;
1518 if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1519 return true;
1520 B.addDereferenceableOrNullAttr(Bytes);
1521 continue;
1522 }
1523 case lltok::kw_align: {
1524 unsigned Alignment;
1525 if (ParseOptionalAlignment(Alignment))
1526 return true;
1527 B.addAlignmentAttr(Alignment);
1528 continue;
1529 }
1530 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1531 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1532 case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
1533 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1534 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1535
1536 // Error handling.
1537 case lltok::kw_byval:
1538 case lltok::kw_inalloca:
1539 case lltok::kw_nest:
1540 case lltok::kw_nocapture:
1541 case lltok::kw_returned:
1542 case lltok::kw_sret:
1543 case lltok::kw_swifterror:
1544 case lltok::kw_swiftself:
1545 HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
1546 break;
1547
1548 case lltok::kw_alignstack:
1549 case lltok::kw_alwaysinline:
1550 case lltok::kw_argmemonly:
1551 case lltok::kw_builtin:
1552 case lltok::kw_cold:
1553 case lltok::kw_inlinehint:
1554 case lltok::kw_jumptable:
1555 case lltok::kw_minsize:
1556 case lltok::kw_naked:
1557 case lltok::kw_nobuiltin:
1558 case lltok::kw_noduplicate:
1559 case lltok::kw_noimplicitfloat:
1560 case lltok::kw_noinline:
1561 case lltok::kw_nonlazybind:
1562 case lltok::kw_noredzone:
1563 case lltok::kw_noreturn:
1564 case lltok::kw_nounwind:
1565 case lltok::kw_optnone:
1566 case lltok::kw_optsize:
1567 case lltok::kw_returns_twice:
1568 case lltok::kw_sanitize_address:
1569 case lltok::kw_sanitize_hwaddress:
1570 case lltok::kw_sanitize_memory:
1571 case lltok::kw_sanitize_thread:
1572 case lltok::kw_ssp:
1573 case lltok::kw_sspreq:
1574 case lltok::kw_sspstrong:
1575 case lltok::kw_safestack:
1576 case lltok::kw_strictfp:
1577 case lltok::kw_uwtable:
1578 HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1579 break;
1580
1581 case lltok::kw_readnone:
1582 case lltok::kw_readonly:
1583 HaveError |= Error(Lex.getLoc(), "invalid use of attribute on return type");
1584 }
1585
1586 Lex.Lex();
1587 }
1588}
1589
1590static unsigned parseOptionalLinkageAux(lltok::Kind Kind, bool &HasLinkage) {
1591 HasLinkage = true;
1592 switch (Kind) {
1593 default:
1594 HasLinkage = false;
1595 return GlobalValue::ExternalLinkage;
1596 case lltok::kw_private:
1597 return GlobalValue::PrivateLinkage;
1598 case lltok::kw_internal:
1599 return GlobalValue::InternalLinkage;
1600 case lltok::kw_weak:
1601 return GlobalValue::WeakAnyLinkage;
1602 case lltok::kw_weak_odr:
1603 return GlobalValue::WeakODRLinkage;
1604 case lltok::kw_linkonce:
1605 return GlobalValue::LinkOnceAnyLinkage;
1606 case lltok::kw_linkonce_odr:
1607 return GlobalValue::LinkOnceODRLinkage;
1608 case lltok::kw_available_externally:
1609 return GlobalValue::AvailableExternallyLinkage;
1610 case lltok::kw_appending:
1611 return GlobalValue::AppendingLinkage;
1612 case lltok::kw_common:
1613 return GlobalValue::CommonLinkage;
1614 case lltok::kw_extern_weak:
1615 return GlobalValue::ExternalWeakLinkage;
1616 case lltok::kw_external:
1617 return GlobalValue::ExternalLinkage;
1618 }
1619}
1620
1621/// ParseOptionalLinkage
1622/// ::= /*empty*/
1623/// ::= 'private'
1624/// ::= 'internal'
1625/// ::= 'weak'
1626/// ::= 'weak_odr'
1627/// ::= 'linkonce'
1628/// ::= 'linkonce_odr'
1629/// ::= 'available_externally'
1630/// ::= 'appending'
1631/// ::= 'common'
1632/// ::= 'extern_weak'
1633/// ::= 'external'
1634bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
1635 unsigned &Visibility,
1636 unsigned &DLLStorageClass,
1637 bool &DSOLocal) {
1638 Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
1639 if (HasLinkage)
1640 Lex.Lex();
1641 ParseOptionalDSOLocal(DSOLocal);
1642 ParseOptionalVisibility(Visibility);
1643 ParseOptionalDLLStorageClass(DLLStorageClass);
1644
1645 if (DSOLocal && DLLStorageClass == GlobalValue::DLLImportStorageClass) {
1646 return Error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch");
1647 }
1648
1649 return false;
1650}
1651
1652void LLParser::ParseOptionalDSOLocal(bool &DSOLocal) {
1653 switch (Lex.getKind()) {
1654 default:
1655 DSOLocal = false;
1656 break;
1657 case lltok::kw_dso_local:
1658 DSOLocal = true;
1659 Lex.Lex();
1660 break;
1661 case lltok::kw_dso_preemptable:
1662 DSOLocal = false;
1663 Lex.Lex();
1664 break;
1665 }
1666}
1667
1668/// ParseOptionalVisibility
1669/// ::= /*empty*/
1670/// ::= 'default'
1671/// ::= 'hidden'
1672/// ::= 'protected'
1673///
1674void LLParser::ParseOptionalVisibility(unsigned &Res) {
1675 switch (Lex.getKind()) {
1676 default:
1677 Res = GlobalValue::DefaultVisibility;
1678 return;
1679 case lltok::kw_default:
1680 Res = GlobalValue::DefaultVisibility;
1681 break;
1682 case lltok::kw_hidden:
1683 Res = GlobalValue::HiddenVisibility;
1684 break;
1685 case lltok::kw_protected:
1686 Res = GlobalValue::ProtectedVisibility;
1687 break;
1688 }
1689 Lex.Lex();
1690}
1691
1692/// ParseOptionalDLLStorageClass
1693/// ::= /*empty*/
1694/// ::= 'dllimport'
1695/// ::= 'dllexport'
1696///
1697void LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
1698 switch (Lex.getKind()) {
1699 default:
1700 Res = GlobalValue::DefaultStorageClass;
1701 return;
1702 case lltok::kw_dllimport:
1703 Res = GlobalValue::DLLImportStorageClass;
1704 break;
1705 case lltok::kw_dllexport:
1706 Res = GlobalValue::DLLExportStorageClass;
1707 break;
1708 }
1709 Lex.Lex();
1710}
1711
1712/// ParseOptionalCallingConv
1713/// ::= /*empty*/
1714/// ::= 'ccc'
1715/// ::= 'fastcc'
1716/// ::= 'intel_ocl_bicc'
1717/// ::= 'coldcc'
1718/// ::= 'x86_stdcallcc'
1719/// ::= 'x86_fastcallcc'
1720/// ::= 'x86_thiscallcc'
1721/// ::= 'x86_vectorcallcc'
1722/// ::= 'arm_apcscc'
1723/// ::= 'arm_aapcscc'
1724/// ::= 'arm_aapcs_vfpcc'
1725/// ::= 'msp430_intrcc'
1726/// ::= 'avr_intrcc'
1727/// ::= 'avr_signalcc'
1728/// ::= 'ptx_kernel'
1729/// ::= 'ptx_device'
1730/// ::= 'spir_func'
1731/// ::= 'spir_kernel'
1732/// ::= 'x86_64_sysvcc'
1733/// ::= 'win64cc'
1734/// ::= 'webkit_jscc'
1735/// ::= 'anyregcc'
1736/// ::= 'preserve_mostcc'
1737/// ::= 'preserve_allcc'
1738/// ::= 'ghccc'
1739/// ::= 'swiftcc'
1740/// ::= 'x86_intrcc'
1741/// ::= 'hhvmcc'
1742/// ::= 'hhvm_ccc'
1743/// ::= 'cxx_fast_tlscc'
1744/// ::= 'amdgpu_vs'
1745/// ::= 'amdgpu_ls'
1746/// ::= 'amdgpu_hs'
1747/// ::= 'amdgpu_es'
1748/// ::= 'amdgpu_gs'
1749/// ::= 'amdgpu_ps'
1750/// ::= 'amdgpu_cs'
1751/// ::= 'amdgpu_kernel'
1752/// ::= 'cc' UINT
1753///
1754bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
1755 switch (Lex.getKind()) {
1756 default: CC = CallingConv::C; return false;
1757 case lltok::kw_ccc: CC = CallingConv::C; break;
1758 case lltok::kw_fastcc: CC = CallingConv::Fast; break;
1759 case lltok::kw_coldcc: CC = CallingConv::Cold; break;
1760 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break;
1761 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1762 case lltok::kw_x86_regcallcc: CC = CallingConv::X86_RegCall; break;
1763 case lltok::kw_x86_thiscallcc: CC = CallingConv::X86_ThisCall; break;
1764 case lltok::kw_x86_vectorcallcc:CC = CallingConv::X86_VectorCall; break;
1765 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
1766 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
1767 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1768 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
1769 case lltok::kw_avr_intrcc: CC = CallingConv::AVR_INTR; break;
1770 case lltok::kw_avr_signalcc: CC = CallingConv::AVR_SIGNAL; break;
1771 case lltok::kw_ptx_kernel: CC = CallingConv::PTX_Kernel; break;
1772 case lltok::kw_ptx_device: CC = CallingConv::PTX_Device; break;
1773 case lltok::kw_spir_kernel: CC = CallingConv::SPIR_KERNEL; break;
1774 case lltok::kw_spir_func: CC = CallingConv::SPIR_FUNC; break;
1775 case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break;
1776 case lltok::kw_x86_64_sysvcc: CC = CallingConv::X86_64_SysV; break;
1777 case lltok::kw_win64cc: CC = CallingConv::Win64; break;
1778 case lltok::kw_webkit_jscc: CC = CallingConv::WebKit_JS; break;
1779 case lltok::kw_anyregcc: CC = CallingConv::AnyReg; break;
1780 case lltok::kw_preserve_mostcc:CC = CallingConv::PreserveMost; break;
1781 case lltok::kw_preserve_allcc: CC = CallingConv::PreserveAll; break;
1782 case lltok::kw_ghccc: CC = CallingConv::GHC; break;
1783 case lltok::kw_swiftcc: CC = CallingConv::Swift; break;
1784 case lltok::kw_x86_intrcc: CC = CallingConv::X86_INTR; break;
1785 case lltok::kw_hhvmcc: CC = CallingConv::HHVM; break;
1786 case lltok::kw_hhvm_ccc: CC = CallingConv::HHVM_C; break;
1787 case lltok::kw_cxx_fast_tlscc: CC = CallingConv::CXX_FAST_TLS; break;
1788 case lltok::kw_amdgpu_vs: CC = CallingConv::AMDGPU_VS; break;
1789 case lltok::kw_amdgpu_ls: CC = CallingConv::AMDGPU_LS; break;
1790 case lltok::kw_amdgpu_hs: CC = CallingConv::AMDGPU_HS; break;
1791 case lltok::kw_amdgpu_es: CC = CallingConv::AMDGPU_ES; break;
1792 case lltok::kw_amdgpu_gs: CC = CallingConv::AMDGPU_GS; break;
1793 case lltok::kw_amdgpu_ps: CC = CallingConv::AMDGPU_PS; break;
1794 case lltok::kw_amdgpu_cs: CC = CallingConv::AMDGPU_CS; break;
1795 case lltok::kw_amdgpu_kernel: CC = CallingConv::AMDGPU_KERNEL; break;
1796 case lltok::kw_cc: {
1797 Lex.Lex();
1798 return ParseUInt32(CC);
1799 }
1800 }
1801
1802 Lex.Lex();
1803 return false;
1804}
1805
1806/// ParseMetadataAttachment
1807/// ::= !dbg !42
1808bool LLParser::ParseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
1809 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment")(static_cast <bool> (Lex.getKind() == lltok::MetadataVar
&& "Expected metadata attachment") ? void (0) : __assert_fail
("Lex.getKind() == lltok::MetadataVar && \"Expected metadata attachment\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 1809, __extension__ __PRETTY_FUNCTION__))
;
1810
1811 std::string Name = Lex.getStrVal();
1812 Kind = M->getMDKindID(Name);
1813 Lex.Lex();
1814
1815 return ParseMDNode(MD);
1816}
1817
1818/// ParseInstructionMetadata
1819/// ::= !dbg !42 (',' !dbg !57)*
1820bool LLParser::ParseInstructionMetadata(Instruction &Inst) {
1821 do {
1822 if (Lex.getKind() != lltok::MetadataVar)
1823 return TokError("expected metadata after comma");
1824
1825 unsigned MDK;
1826 MDNode *N;
1827 if (ParseMetadataAttachment(MDK, N))
1828 return true;
1829
1830 Inst.setMetadata(MDK, N);
1831 if (MDK == LLVMContext::MD_tbaa)
1832 InstsWithTBAATag.push_back(&Inst);
1833
1834 // If this is the end of the list, we're done.
1835 } while (EatIfPresent(lltok::comma));
1836 return false;
1837}
1838
1839/// ParseGlobalObjectMetadataAttachment
1840/// ::= !dbg !57
1841bool LLParser::ParseGlobalObjectMetadataAttachment(GlobalObject &GO) {
1842 unsigned MDK;
1843 MDNode *N;
1844 if (ParseMetadataAttachment(MDK, N))
1845 return true;
1846
1847 GO.addMetadata(MDK, *N);
1848 return false;
1849}
1850
1851/// ParseOptionalFunctionMetadata
1852/// ::= (!dbg !57)*
1853bool LLParser::ParseOptionalFunctionMetadata(Function &F) {
1854 while (Lex.getKind() == lltok::MetadataVar)
1855 if (ParseGlobalObjectMetadataAttachment(F))
1856 return true;
1857 return false;
1858}
1859
1860/// ParseOptionalAlignment
1861/// ::= /* empty */
1862/// ::= 'align' 4
1863bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1864 Alignment = 0;
1865 if (!EatIfPresent(lltok::kw_align))
1866 return false;
1867 LocTy AlignLoc = Lex.getLoc();
1868 if (ParseUInt32(Alignment)) return true;
1869 if (!isPowerOf2_32(Alignment))
1870 return Error(AlignLoc, "alignment is not a power of two");
1871 if (Alignment > Value::MaximumAlignment)
1872 return Error(AlignLoc, "huge alignments are not supported yet");
1873 return false;
1874}
1875
1876/// ParseOptionalDerefAttrBytes
1877/// ::= /* empty */
1878/// ::= AttrKind '(' 4 ')'
1879///
1880/// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
1881bool LLParser::ParseOptionalDerefAttrBytes(lltok::Kind AttrKind,
1882 uint64_t &Bytes) {
1883 assert((AttrKind == lltok::kw_dereferenceable ||(static_cast <bool> ((AttrKind == lltok::kw_dereferenceable
|| AttrKind == lltok::kw_dereferenceable_or_null) &&
"contract!") ? void (0) : __assert_fail ("(AttrKind == lltok::kw_dereferenceable || AttrKind == lltok::kw_dereferenceable_or_null) && \"contract!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 1885, __extension__ __PRETTY_FUNCTION__))
1884 AttrKind == lltok::kw_dereferenceable_or_null) &&(static_cast <bool> ((AttrKind == lltok::kw_dereferenceable
|| AttrKind == lltok::kw_dereferenceable_or_null) &&
"contract!") ? void (0) : __assert_fail ("(AttrKind == lltok::kw_dereferenceable || AttrKind == lltok::kw_dereferenceable_or_null) && \"contract!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 1885, __extension__ __PRETTY_FUNCTION__))
1885 "contract!")(static_cast <bool> ((AttrKind == lltok::kw_dereferenceable
|| AttrKind == lltok::kw_dereferenceable_or_null) &&
"contract!") ? void (0) : __assert_fail ("(AttrKind == lltok::kw_dereferenceable || AttrKind == lltok::kw_dereferenceable_or_null) && \"contract!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 1885, __extension__ __PRETTY_FUNCTION__))
;
1886
1887 Bytes = 0;
1888 if (!EatIfPresent(AttrKind))
1889 return false;
1890 LocTy ParenLoc = Lex.getLoc();
1891 if (!EatIfPresent(lltok::lparen))
1892 return Error(ParenLoc, "expected '('");
1893 LocTy DerefLoc = Lex.getLoc();
1894 if (ParseUInt64(Bytes)) return true;
1895 ParenLoc = Lex.getLoc();
1896 if (!EatIfPresent(lltok::rparen))
1897 return Error(ParenLoc, "expected ')'");
1898 if (!Bytes)
1899 return Error(DerefLoc, "dereferenceable bytes must be non-zero");
1900 return false;
1901}
1902
1903/// ParseOptionalCommaAlign
1904/// ::=
1905/// ::= ',' align 4
1906///
1907/// This returns with AteExtraComma set to true if it ate an excess comma at the
1908/// end.
1909bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
1910 bool &AteExtraComma) {
1911 AteExtraComma = false;
1912 while (EatIfPresent(lltok::comma)) {
1913 // Metadata at the end is an early exit.
1914 if (Lex.getKind() == lltok::MetadataVar) {
1915 AteExtraComma = true;
1916 return false;
1917 }
1918
1919 if (Lex.getKind() != lltok::kw_align)
1920 return Error(Lex.getLoc(), "expected metadata or 'align'");
1921
1922 if (ParseOptionalAlignment(Alignment)) return true;
1923 }
1924
1925 return false;
1926}
1927
1928/// ParseOptionalCommaAddrSpace
1929/// ::=
1930/// ::= ',' addrspace(1)
1931///
1932/// This returns with AteExtraComma set to true if it ate an excess comma at the
1933/// end.
1934bool LLParser::ParseOptionalCommaAddrSpace(unsigned &AddrSpace,
1935 LocTy &Loc,
1936 bool &AteExtraComma) {
1937 AteExtraComma = false;
1938 while (EatIfPresent(lltok::comma)) {
1939 // Metadata at the end is an early exit.
1940 if (Lex.getKind() == lltok::MetadataVar) {
1941 AteExtraComma = true;
1942 return false;
1943 }
1944
1945 Loc = Lex.getLoc();
1946 if (Lex.getKind() != lltok::kw_addrspace)
1947 return Error(Lex.getLoc(), "expected metadata or 'addrspace'");
1948
1949 if (ParseOptionalAddrSpace(AddrSpace))
1950 return true;
1951 }
1952
1953 return false;
1954}
1955
1956bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
1957 Optional<unsigned> &HowManyArg) {
1958 Lex.Lex();
1959
1960 auto StartParen = Lex.getLoc();
1961 if (!EatIfPresent(lltok::lparen))
1962 return Error(StartParen, "expected '('");
1963
1964 if (ParseUInt32(BaseSizeArg))
1965 return true;
1966
1967 if (EatIfPresent(lltok::comma)) {
1968 auto HowManyAt = Lex.getLoc();
1969 unsigned HowMany;
1970 if (ParseUInt32(HowMany))
1971 return true;
1972 if (HowMany == BaseSizeArg)
1973 return Error(HowManyAt,
1974 "'allocsize' indices can't refer to the same parameter");
1975 HowManyArg = HowMany;
1976 } else
1977 HowManyArg = None;
1978
1979 auto EndParen = Lex.getLoc();
1980 if (!EatIfPresent(lltok::rparen))
1981 return Error(EndParen, "expected ')'");
1982 return false;
1983}
1984
1985/// ParseScopeAndOrdering
1986/// if isAtomic: ::= SyncScope? AtomicOrdering
1987/// else: ::=
1988///
1989/// This sets Scope and Ordering to the parsed values.
1990bool LLParser::ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
1991 AtomicOrdering &Ordering) {
1992 if (!isAtomic)
1993 return false;
1994
1995 return ParseScope(SSID) || ParseOrdering(Ordering);
1996}
1997
1998/// ParseScope
1999/// ::= syncscope("singlethread" | "<target scope>")?
2000///
2001/// This sets synchronization scope ID to the ID of the parsed value.
2002bool LLParser::ParseScope(SyncScope::ID &SSID) {
2003 SSID = SyncScope::System;
2004 if (EatIfPresent(lltok::kw_syncscope)) {
2005 auto StartParenAt = Lex.getLoc();
2006 if (!EatIfPresent(lltok::lparen))
2007 return Error(StartParenAt, "Expected '(' in syncscope");
2008
2009 std::string SSN;
2010 auto SSNAt = Lex.getLoc();
2011 if (ParseStringConstant(SSN))
2012 return Error(SSNAt, "Expected synchronization scope name");
2013
2014 auto EndParenAt = Lex.getLoc();
2015 if (!EatIfPresent(lltok::rparen))
2016 return Error(EndParenAt, "Expected ')' in syncscope");
2017
2018 SSID = Context.getOrInsertSyncScopeID(SSN);
2019 }
2020
2021 return false;
2022}
2023
2024/// ParseOrdering
2025/// ::= AtomicOrdering
2026///
2027/// This sets Ordering to the parsed value.
2028bool LLParser::ParseOrdering(AtomicOrdering &Ordering) {
2029 switch (Lex.getKind()) {
2030 default: return TokError("Expected ordering on atomic instruction");
2031 case lltok::kw_unordered: Ordering = AtomicOrdering::Unordered; break;
2032 case lltok::kw_monotonic: Ordering = AtomicOrdering::Monotonic; break;
2033 // Not specified yet:
2034 // case lltok::kw_consume: Ordering = AtomicOrdering::Consume; break;
2035 case lltok::kw_acquire: Ordering = AtomicOrdering::Acquire; break;
2036 case lltok::kw_release: Ordering = AtomicOrdering::Release; break;
2037 case lltok::kw_acq_rel: Ordering = AtomicOrdering::AcquireRelease; break;
2038 case lltok::kw_seq_cst:
2039 Ordering = AtomicOrdering::SequentiallyConsistent;
2040 break;
2041 }
2042 Lex.Lex();
2043 return false;
2044}
2045
2046/// ParseOptionalStackAlignment
2047/// ::= /* empty */
2048/// ::= 'alignstack' '(' 4 ')'
2049bool LLParser::ParseOptionalStackAlignment(unsigned &Alignment) {
2050 Alignment = 0;
2051 if (!EatIfPresent(lltok::kw_alignstack))
2052 return false;
2053 LocTy ParenLoc = Lex.getLoc();
2054 if (!EatIfPresent(lltok::lparen))
2055 return Error(ParenLoc, "expected '('");
2056 LocTy AlignLoc = Lex.getLoc();
2057 if (ParseUInt32(Alignment)) return true;
2058 ParenLoc = Lex.getLoc();
2059 if (!EatIfPresent(lltok::rparen))
2060 return Error(ParenLoc, "expected ')'");
2061 if (!isPowerOf2_32(Alignment))
2062 return Error(AlignLoc, "stack alignment is not a power of two");
2063 return false;
2064}
2065
2066/// ParseIndexList - This parses the index list for an insert/extractvalue
2067/// instruction. This sets AteExtraComma in the case where we eat an extra
2068/// comma at the end of the line and find that it is followed by metadata.
2069/// Clients that don't allow metadata can call the version of this function that
2070/// only takes one argument.
2071///
2072/// ParseIndexList
2073/// ::= (',' uint32)+
2074///
2075bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices,
2076 bool &AteExtraComma) {
2077 AteExtraComma = false;
2078
2079 if (Lex.getKind() != lltok::comma)
2080 return TokError("expected ',' as start of index list");
2081
2082 while (EatIfPresent(lltok::comma)) {
2083 if (Lex.getKind() == lltok::MetadataVar) {
2084 if (Indices.empty()) return TokError("expected index");
2085 AteExtraComma = true;
2086 return false;
2087 }
2088 unsigned Idx = 0;
2089 if (ParseUInt32(Idx)) return true;
2090 Indices.push_back(Idx);
2091 }
2092
2093 return false;
2094}
2095
2096//===----------------------------------------------------------------------===//
2097// Type Parsing.
2098//===----------------------------------------------------------------------===//
2099
2100/// ParseType - Parse a type.
2101bool LLParser::ParseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
2102 SMLoc TypeLoc = Lex.getLoc();
2103 switch (Lex.getKind()) {
2104 default:
2105 return TokError(Msg);
2106 case lltok::Type:
2107 // Type ::= 'float' | 'void' (etc)
2108 Result = Lex.getTyVal();
2109 Lex.Lex();
2110 break;
2111 case lltok::lbrace:
2112 // Type ::= StructType
2113 if (ParseAnonStructType(Result, false))
2114 return true;
2115 break;
2116 case lltok::lsquare:
2117 // Type ::= '[' ... ']'
2118 Lex.Lex(); // eat the lsquare.
2119 if (ParseArrayVectorType(Result, false))
2120 return true;
2121 break;
2122 case lltok::less: // Either vector or packed struct.
2123 // Type ::= '<' ... '>'
2124 Lex.Lex();
2125 if (Lex.getKind() == lltok::lbrace) {
2126 if (ParseAnonStructType(Result, true) ||
2127 ParseToken(lltok::greater, "expected '>' at end of packed struct"))
2128 return true;
2129 } else if (ParseArrayVectorType(Result, true))
2130 return true;
2131 break;
2132 case lltok::LocalVar: {
2133 // Type ::= %foo
2134 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
2135
2136 // If the type hasn't been defined yet, create a forward definition and
2137 // remember where that forward def'n was seen (in case it never is defined).
2138 if (!Entry.first) {
2139 Entry.first = StructType::create(Context, Lex.getStrVal());
2140 Entry.second = Lex.getLoc();
2141 }
2142 Result = Entry.first;
2143 Lex.Lex();
2144 break;
2145 }
2146
2147 case lltok::LocalVarID: {
2148 // Type ::= %4
2149 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
2150
2151 // If the type hasn't been defined yet, create a forward definition and
2152 // remember where that forward def'n was seen (in case it never is defined).
2153 if (!Entry.first) {
2154 Entry.first = StructType::create(Context);
2155 Entry.second = Lex.getLoc();
2156 }
2157 Result = Entry.first;
2158 Lex.Lex();
2159 break;
2160 }
2161 }
2162
2163 // Parse the type suffixes.
2164 while (true) {
2165 switch (Lex.getKind()) {
2166 // End of type.
2167 default:
2168 if (!AllowVoid && Result->isVoidTy())
2169 return Error(TypeLoc, "void type only allowed for function results");
2170 return false;
2171
2172 // Type ::= Type '*'
2173 case lltok::star:
2174 if (Result->isLabelTy())
2175 return TokError("basic block pointers are invalid");
2176 if (Result->isVoidTy())
2177 return TokError("pointers to void are invalid - use i8* instead");
2178 if (!PointerType::isValidElementType(Result))
2179 return TokError("pointer to this type is invalid");
2180 Result = PointerType::getUnqual(Result);
2181 Lex.Lex();
2182 break;
2183
2184 // Type ::= Type 'addrspace' '(' uint32 ')' '*'
2185 case lltok::kw_addrspace: {
2186 if (Result->isLabelTy())
2187 return TokError("basic block pointers are invalid");
2188 if (Result->isVoidTy())
2189 return TokError("pointers to void are invalid; use i8* instead");
2190 if (!PointerType::isValidElementType(Result))
2191 return TokError("pointer to this type is invalid");
2192 unsigned AddrSpace;
2193 if (ParseOptionalAddrSpace(AddrSpace) ||
2194 ParseToken(lltok::star, "expected '*' in address space"))
2195 return true;
2196
2197 Result = PointerType::get(Result, AddrSpace);
2198 break;
2199 }
2200
2201 /// Types '(' ArgTypeListI ')' OptFuncAttrs
2202 case lltok::lparen:
2203 if (ParseFunctionType(Result))
2204 return true;
2205 break;
2206 }
2207 }
2208}
2209
2210/// ParseParameterList
2211/// ::= '(' ')'
2212/// ::= '(' Arg (',' Arg)* ')'
2213/// Arg
2214/// ::= Type OptionalAttributes Value OptionalAttributes
2215bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
2216 PerFunctionState &PFS, bool IsMustTailCall,
2217 bool InVarArgsFunc) {
2218 if (ParseToken(lltok::lparen, "expected '(' in call"))
2219 return true;
2220
2221 while (Lex.getKind() != lltok::rparen) {
2222 // If this isn't the first argument, we need a comma.
2223 if (!ArgList.empty() &&
2224 ParseToken(lltok::comma, "expected ',' in argument list"))
2225 return true;
2226
2227 // Parse an ellipsis if this is a musttail call in a variadic function.
2228 if (Lex.getKind() == lltok::dotdotdot) {
2229 const char *Msg = "unexpected ellipsis in argument list for ";
2230 if (!IsMustTailCall)
2231 return TokError(Twine(Msg) + "non-musttail call");
2232 if (!InVarArgsFunc)
2233 return TokError(Twine(Msg) + "musttail call in non-varargs function");
2234 Lex.Lex(); // Lex the '...', it is purely for readability.
2235 return ParseToken(lltok::rparen, "expected ')' at end of argument list");
2236 }
2237
2238 // Parse the argument.
2239 LocTy ArgLoc;
2240 Type *ArgTy = nullptr;
2241 AttrBuilder ArgAttrs;
2242 Value *V;
2243 if (ParseType(ArgTy, ArgLoc))
2244 return true;
2245
2246 if (ArgTy->isMetadataTy()) {
2247 if (ParseMetadataAsValue(V, PFS))
2248 return true;
2249 } else {
2250 // Otherwise, handle normal operands.
2251 if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS))
2252 return true;
2253 }
2254 ArgList.push_back(ParamInfo(
2255 ArgLoc, V, AttributeSet::get(V->getContext(), ArgAttrs)));
2256 }
2257
2258 if (IsMustTailCall && InVarArgsFunc)
2259 return TokError("expected '...' at end of argument list for musttail call "
2260 "in varargs function");
2261
2262 Lex.Lex(); // Lex the ')'.
2263 return false;
2264}
2265
2266/// ParseOptionalOperandBundles
2267/// ::= /*empty*/
2268/// ::= '[' OperandBundle [, OperandBundle ]* ']'
2269///
2270/// OperandBundle
2271/// ::= bundle-tag '(' ')'
2272/// ::= bundle-tag '(' Type Value [, Type Value ]* ')'
2273///
2274/// bundle-tag ::= String Constant
2275bool LLParser::ParseOptionalOperandBundles(
2276 SmallVectorImpl<OperandBundleDef> &BundleList, PerFunctionState &PFS) {
2277 LocTy BeginLoc = Lex.getLoc();
2278 if (!EatIfPresent(lltok::lsquare))
2279 return false;
2280
2281 while (Lex.getKind() != lltok::rsquare) {
2282 // If this isn't the first operand bundle, we need a comma.
2283 if (!BundleList.empty() &&
2284 ParseToken(lltok::comma, "expected ',' in input list"))
2285 return true;
2286
2287 std::string Tag;
2288 if (ParseStringConstant(Tag))
2289 return true;
2290
2291 if (ParseToken(lltok::lparen, "expected '(' in operand bundle"))
2292 return true;
2293
2294 std::vector<Value *> Inputs;
2295 while (Lex.getKind() != lltok::rparen) {
2296 // If this isn't the first input, we need a comma.
2297 if (!Inputs.empty() &&
2298 ParseToken(lltok::comma, "expected ',' in input list"))
2299 return true;
2300
2301 Type *Ty = nullptr;
2302 Value *Input = nullptr;
2303 if (ParseType(Ty) || ParseValue(Ty, Input, PFS))
2304 return true;
2305 Inputs.push_back(Input);
2306 }
2307
2308 BundleList.emplace_back(std::move(Tag), std::move(Inputs));
2309
2310 Lex.Lex(); // Lex the ')'.
2311 }
2312
2313 if (BundleList.empty())
2314 return Error(BeginLoc, "operand bundle set must not be empty");
2315
2316 Lex.Lex(); // Lex the ']'.
2317 return false;
2318}
2319
2320/// ParseArgumentList - Parse the argument list for a function type or function
2321/// prototype.
2322/// ::= '(' ArgTypeListI ')'
2323/// ArgTypeListI
2324/// ::= /*empty*/
2325/// ::= '...'
2326/// ::= ArgTypeList ',' '...'
2327/// ::= ArgType (',' ArgType)*
2328///
2329bool LLParser::ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
2330 bool &isVarArg){
2331 isVarArg = false;
2332 assert(Lex.getKind() == lltok::lparen)(static_cast <bool> (Lex.getKind() == lltok::lparen) ? void
(0) : __assert_fail ("Lex.getKind() == lltok::lparen", "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 2332, __extension__ __PRETTY_FUNCTION__))
;
2333 Lex.Lex(); // eat the (.
2334
2335 if (Lex.getKind() == lltok::rparen) {
2336 // empty
2337 } else if (Lex.getKind() == lltok::dotdotdot) {
2338 isVarArg = true;
2339 Lex.Lex();
2340 } else {
2341 LocTy TypeLoc = Lex.getLoc();
2342 Type *ArgTy = nullptr;
2343 AttrBuilder Attrs;
2344 std::string Name;
2345
2346 if (ParseType(ArgTy) ||
2347 ParseOptionalParamAttrs(Attrs)) return true;
2348
2349 if (ArgTy->isVoidTy())
2350 return Error(TypeLoc, "argument can not have void type");
2351
2352 if (Lex.getKind() == lltok::LocalVar) {
2353 Name = Lex.getStrVal();
2354 Lex.Lex();
2355 }
2356
2357 if (!FunctionType::isValidArgumentType(ArgTy))
2358 return Error(TypeLoc, "invalid type for function argument");
2359
2360 ArgList.emplace_back(TypeLoc, ArgTy,
2361 AttributeSet::get(ArgTy->getContext(), Attrs),
2362 std::move(Name));
2363
2364 while (EatIfPresent(lltok::comma)) {
2365 // Handle ... at end of arg list.
2366 if (EatIfPresent(lltok::dotdotdot)) {
2367 isVarArg = true;
2368 break;
2369 }
2370
2371 // Otherwise must be an argument type.
2372 TypeLoc = Lex.getLoc();
2373 if (ParseType(ArgTy) || ParseOptionalParamAttrs(Attrs)) return true;
2374
2375 if (ArgTy->isVoidTy())
2376 return Error(TypeLoc, "argument can not have void type");
2377
2378 if (Lex.getKind() == lltok::LocalVar) {
2379 Name = Lex.getStrVal();
2380 Lex.Lex();
2381 } else {
2382 Name = "";
2383 }
2384
2385 if (!ArgTy->isFirstClassType())
2386 return Error(TypeLoc, "invalid type for function argument");
2387
2388 ArgList.emplace_back(TypeLoc, ArgTy,
2389 AttributeSet::get(ArgTy->getContext(), Attrs),
2390 std::move(Name));
2391 }
2392 }
2393
2394 return ParseToken(lltok::rparen, "expected ')' at end of argument list");
2395}
2396
2397/// ParseFunctionType
2398/// ::= Type ArgumentList OptionalAttrs
2399bool LLParser::ParseFunctionType(Type *&Result) {
2400 assert(Lex.getKind() == lltok::lparen)(static_cast <bool> (Lex.getKind() == lltok::lparen) ? void
(0) : __assert_fail ("Lex.getKind() == lltok::lparen", "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 2400, __extension__ __PRETTY_FUNCTION__))
;
2401
2402 if (!FunctionType::isValidReturnType(Result))
2403 return TokError("invalid function return type");
2404
2405 SmallVector<ArgInfo, 8> ArgList;
2406 bool isVarArg;
2407 if (ParseArgumentList(ArgList, isVarArg))
2408 return true;
2409
2410 // Reject names on the arguments lists.
2411 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2412 if (!ArgList[i].Name.empty())
2413 return Error(ArgList[i].Loc, "argument name invalid in function type");
2414 if (ArgList[i].Attrs.hasAttributes())
2415 return Error(ArgList[i].Loc,
2416 "argument attributes invalid in function type");
2417 }
2418
2419 SmallVector<Type*, 16> ArgListTy;
2420 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
2421 ArgListTy.push_back(ArgList[i].Ty);
2422
2423 Result = FunctionType::get(Result, ArgListTy, isVarArg);
2424 return false;
2425}
2426
2427/// ParseAnonStructType - Parse an anonymous struct type, which is inlined into
2428/// other structs.
2429bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
2430 SmallVector<Type*, 8> Elts;
2431 if (ParseStructBody(Elts)) return true;
2432
2433 Result = StructType::get(Context, Elts, Packed);
2434 return false;
2435}
2436
2437/// ParseStructDefinition - Parse a struct in a 'type' definition.
2438bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
2439 std::pair<Type*, LocTy> &Entry,
2440 Type *&ResultTy) {
2441 // If the type was already defined, diagnose the redefinition.
2442 if (Entry.first && !Entry.second.isValid())
2443 return Error(TypeLoc, "redefinition of type");
2444
2445 // If we have opaque, just return without filling in the definition for the
2446 // struct. This counts as a definition as far as the .ll file goes.
2447 if (EatIfPresent(lltok::kw_opaque)) {
2448 // This type is being defined, so clear the location to indicate this.
2449 Entry.second = SMLoc();
2450
2451 // If this type number has never been uttered, create it.
2452 if (!Entry.first)
2453 Entry.first = StructType::create(Context, Name);
2454 ResultTy = Entry.first;
2455 return false;
2456 }
2457
2458 // If the type starts with '<', then it is either a packed struct or a vector.
2459 bool isPacked = EatIfPresent(lltok::less);
2460
2461 // If we don't have a struct, then we have a random type alias, which we
2462 // accept for compatibility with old files. These types are not allowed to be
2463 // forward referenced and not allowed to be recursive.
2464 if (Lex.getKind() != lltok::lbrace) {
2465 if (Entry.first)
2466 return Error(TypeLoc, "forward references to non-struct type");
2467
2468 ResultTy = nullptr;
2469 if (isPacked)
2470 return ParseArrayVectorType(ResultTy, true);
2471 return ParseType(ResultTy);
2472 }
2473
2474 // This type is being defined, so clear the location to indicate this.
2475 Entry.second = SMLoc();
2476
2477 // If this type number has never been uttered, create it.
2478 if (!Entry.first)
2479 Entry.first = StructType::create(Context, Name);
2480
2481 StructType *STy = cast<StructType>(Entry.first);
2482
2483 SmallVector<Type*, 8> Body;
2484 if (ParseStructBody(Body) ||
2485 (isPacked && ParseToken(lltok::greater, "expected '>' in packed struct")))
2486 return true;
2487
2488 STy->setBody(Body, isPacked);
2489 ResultTy = STy;
2490 return false;
2491}
2492
2493/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere.
2494/// StructType
2495/// ::= '{' '}'
2496/// ::= '{' Type (',' Type)* '}'
2497/// ::= '<' '{' '}' '>'
2498/// ::= '<' '{' Type (',' Type)* '}' '>'
2499bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
2500 assert(Lex.getKind() == lltok::lbrace)(static_cast <bool> (Lex.getKind() == lltok::lbrace) ? void
(0) : __assert_fail ("Lex.getKind() == lltok::lbrace", "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 2500, __extension__ __PRETTY_FUNCTION__))
;
2501 Lex.Lex(); // Consume the '{'
2502
2503 // Handle the empty struct.
2504 if (EatIfPresent(lltok::rbrace))
2505 return false;
2506
2507 LocTy EltTyLoc = Lex.getLoc();
2508 Type *Ty = nullptr;
2509 if (ParseType(Ty)) return true;
2510 Body.push_back(Ty);
2511
2512 if (!StructType::isValidElementType(Ty))
2513 return Error(EltTyLoc, "invalid element type for struct");
2514
2515 while (EatIfPresent(lltok::comma)) {
2516 EltTyLoc = Lex.getLoc();
2517 if (ParseType(Ty)) return true;
2518
2519 if (!StructType::isValidElementType(Ty))
2520 return Error(EltTyLoc, "invalid element type for struct");
2521
2522 Body.push_back(Ty);
2523 }
2524
2525 return ParseToken(lltok::rbrace, "expected '}' at end of struct");
2526}
2527
2528/// ParseArrayVectorType - Parse an array or vector type, assuming the first
2529/// token has already been consumed.
2530/// Type
2531/// ::= '[' APSINTVAL 'x' Types ']'
2532/// ::= '<' APSINTVAL 'x' Types '>'
2533bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
2534 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
2535 Lex.getAPSIntVal().getBitWidth() > 64)
2536 return TokError("expected number in address space");
2537
2538 LocTy SizeLoc = Lex.getLoc();
2539 uint64_t Size = Lex.getAPSIntVal().getZExtValue();
2540 Lex.Lex();
2541
2542 if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
2543 return true;
2544
2545 LocTy TypeLoc = Lex.getLoc();
2546 Type *EltTy = nullptr;
2547 if (ParseType(EltTy)) return true;
2548
2549 if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
2550 "expected end of sequential type"))
2551 return true;
2552
2553 if (isVector) {
2554 if (Size == 0)
2555 return Error(SizeLoc, "zero element vector is illegal");
2556 if ((unsigned)Size != Size)
2557 return Error(SizeLoc, "size too large for vector");
2558 if (!VectorType::isValidElementType(EltTy))
2559 return Error(TypeLoc, "invalid vector element type");
2560 Result = VectorType::get(EltTy, unsigned(Size));
2561 } else {
2562 if (!ArrayType::isValidElementType(EltTy))
2563 return Error(TypeLoc, "invalid array element type");
2564 Result = ArrayType::get(EltTy, Size);
2565 }
2566 return false;
2567}
2568
2569//===----------------------------------------------------------------------===//
2570// Function Semantic Analysis.
2571//===----------------------------------------------------------------------===//
2572
2573LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
2574 int functionNumber)
2575 : P(p), F(f), FunctionNumber(functionNumber) {
2576
2577 // Insert unnamed arguments into the NumberedVals list.
2578 for (Argument &A : F.args())
2579 if (!A.hasName())
2580 NumberedVals.push_back(&A);
2581}
2582
2583LLParser::PerFunctionState::~PerFunctionState() {
2584 // If there were any forward referenced non-basicblock values, delete them.
2585
2586 for (const auto &P : ForwardRefVals) {
2587 if (isa<BasicBlock>(P.second.first))
2588 continue;
2589 P.second.first->replaceAllUsesWith(
2590 UndefValue::get(P.second.first->getType()));
2591 P.second.first->deleteValue();
2592 }
2593
2594 for (const auto &P : ForwardRefValIDs) {
2595 if (isa<BasicBlock>(P.second.first))
2596 continue;
2597 P.second.first->replaceAllUsesWith(
2598 UndefValue::get(P.second.first->getType()));
2599 P.second.first->deleteValue();
2600 }
2601}
2602
2603bool LLParser::PerFunctionState::FinishFunction() {
2604 if (!ForwardRefVals.empty())
2605 return P.Error(ForwardRefVals.begin()->second.second,
2606 "use of undefined value '%" + ForwardRefVals.begin()->first +
2607 "'");
2608 if (!ForwardRefValIDs.empty())
2609 return P.Error(ForwardRefValIDs.begin()->second.second,
2610 "use of undefined value '%" +
2611 Twine(ForwardRefValIDs.begin()->first) + "'");
2612 return false;
2613}
2614
2615static bool isValidVariableType(Module *M, Type *Ty, Value *Val, bool IsCall) {
2616 if (Val->getType() == Ty)
2617 return true;
2618 // For calls we also accept variables in the program address space
2619 if (IsCall && isa<PointerType>(Ty)) {
2620 Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
2621 M->getDataLayout().getProgramAddressSpace());
2622 if (Val->getType() == TyInProgAS)
2623 return true;
2624 }
2625 return false;
2626}
2627
2628/// GetVal - Get a value with the specified name or ID, creating a
2629/// forward reference record if needed. This can return null if the value
2630/// exists but does not have the right type.
2631Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
2632 LocTy Loc, bool IsCall) {
2633 // Look this name up in the normal function symbol table.
2634 Value *Val = F.getValueSymbolTable()->lookup(Name);
2635
2636 // If this is a forward reference for the value, see if we already created a
2637 // forward ref record.
2638 if (!Val) {
2639 auto I = ForwardRefVals.find(Name);
2640 if (I != ForwardRefVals.end())
2641 Val = I->second.first;
2642 }
2643
2644 // If we have the value in the symbol table or fwd-ref table, return it.
2645 if (Val) {
2646 if (isValidVariableType(P.M, Ty, Val, IsCall))
2647 return Val;
2648 if (Ty->isLabelTy())
2649 P.Error(Loc, "'%" + Name + "' is not a basic block");
2650 else
2651 P.Error(Loc, "'%" + Name + "' defined with type '" +
2652 getTypeString(Val->getType()) + "'");
2653 return nullptr;
2654 }
2655
2656 // Don't make placeholders with invalid type.
2657 if (!Ty->isFirstClassType()) {
2658 P.Error(Loc, "invalid use of a non-first-class type");
2659 return nullptr;
2660 }
2661
2662 // Otherwise, create a new forward reference for this value and remember it.
2663 Value *FwdVal;
2664 if (Ty->isLabelTy()) {
2665 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
2666 } else {
2667 FwdVal = new Argument(Ty, Name);
2668 }
2669
2670 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
2671 return FwdVal;
2672}
2673
2674Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc,
2675 bool IsCall) {
2676 // Look this name up in the normal function symbol table.
2677 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
2678
2679 // If this is a forward reference for the value, see if we already created a
2680 // forward ref record.
2681 if (!Val) {
2682 auto I = ForwardRefValIDs.find(ID);
2683 if (I != ForwardRefValIDs.end())
2684 Val = I->second.first;
2685 }
2686
2687 // If we have the value in the symbol table or fwd-ref table, return it.
2688 if (Val) {
2689 if (isValidVariableType(P.M, Ty, Val, IsCall))
2690 return Val;
2691 if (Ty->isLabelTy())
2692 P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
2693 else
2694 P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
2695 getTypeString(Val->getType()) + "'");
2696 return nullptr;
2697 }
2698
2699 if (!Ty->isFirstClassType()) {
2700 P.Error(Loc, "invalid use of a non-first-class type");
2701 return nullptr;
2702 }
2703
2704 // Otherwise, create a new forward reference for this value and remember it.
2705 Value *FwdVal;
2706 if (Ty->isLabelTy()) {
2707 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
2708 } else {
2709 FwdVal = new Argument(Ty);
2710 }
2711
2712 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2713 return FwdVal;
2714}
2715
2716/// SetInstName - After an instruction is parsed and inserted into its
2717/// basic block, this installs its name.
2718bool LLParser::PerFunctionState::SetInstName(int NameID,
2719 const std::string &NameStr,
2720 LocTy NameLoc, Instruction *Inst) {
2721 // If this instruction has void type, it cannot have a name or ID specified.
2722 if (Inst->getType()->isVoidTy()) {
2723 if (NameID != -1 || !NameStr.empty())
2724 return P.Error(NameLoc, "instructions returning void cannot have a name");
2725 return false;
2726 }
2727
2728 // If this was a numbered instruction, verify that the instruction is the
2729 // expected value and resolve any forward references.
2730 if (NameStr.empty()) {
2731 // If neither a name nor an ID was specified, just use the next ID.
2732 if (NameID == -1)
2733 NameID = NumberedVals.size();
2734
2735 if (unsigned(NameID) != NumberedVals.size())
2736 return P.Error(NameLoc, "instruction expected to be numbered '%" +
2737 Twine(NumberedVals.size()) + "'");
2738
2739 auto FI = ForwardRefValIDs.find(NameID);
2740 if (FI != ForwardRefValIDs.end()) {
2741 Value *Sentinel = FI->second.first;
2742 if (Sentinel->getType() != Inst->getType())
2743 return P.Error(NameLoc, "instruction forward referenced with type '" +
2744 getTypeString(FI->second.first->getType()) + "'");
2745
2746 Sentinel->replaceAllUsesWith(Inst);
2747 Sentinel->deleteValue();
2748 ForwardRefValIDs.erase(FI);
2749 }
2750
2751 NumberedVals.push_back(Inst);
2752 return false;
2753 }
2754
2755 // Otherwise, the instruction had a name. Resolve forward refs and set it.
2756 auto FI = ForwardRefVals.find(NameStr);
2757 if (FI != ForwardRefVals.end()) {
2758 Value *Sentinel = FI->second.first;
2759 if (Sentinel->getType() != Inst->getType())
2760 return P.Error(NameLoc, "instruction forward referenced with type '" +
2761 getTypeString(FI->second.first->getType()) + "'");
2762
2763 Sentinel->replaceAllUsesWith(Inst);
2764 Sentinel->deleteValue();
2765 ForwardRefVals.erase(FI);
2766 }
2767
2768 // Set the name on the instruction.
2769 Inst->setName(NameStr);
2770
2771 if (Inst->getName() != NameStr)
2772 return P.Error(NameLoc, "multiple definition of local value named '" +
2773 NameStr + "'");
2774 return false;
2775}
2776
2777/// GetBB - Get a basic block with the specified name or ID, creating a
2778/// forward reference record if needed.
2779BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
2780 LocTy Loc) {
2781 return dyn_cast_or_null<BasicBlock>(
2782 GetVal(Name, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
2783}
2784
2785BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2786 return dyn_cast_or_null<BasicBlock>(
2787 GetVal(ID, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
2788}
2789
2790/// DefineBB - Define the specified basic block, which is either named or
2791/// unnamed. If there is an error, this returns null otherwise it returns
2792/// the block being defined.
2793BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
2794 LocTy Loc) {
2795 BasicBlock *BB;
2796 if (Name.empty())
2797 BB = GetBB(NumberedVals.size(), Loc);
2798 else
2799 BB = GetBB(Name, Loc);
2800 if (!BB) return nullptr; // Already diagnosed error.
2801
2802 // Move the block to the end of the function. Forward ref'd blocks are
2803 // inserted wherever they happen to be referenced.
2804 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
2805
2806 // Remove the block from forward ref sets.
2807 if (Name.empty()) {
2808 ForwardRefValIDs.erase(NumberedVals.size());
2809 NumberedVals.push_back(BB);
2810 } else {
2811 // BB forward references are already in the function symbol table.
2812 ForwardRefVals.erase(Name);
2813 }
2814
2815 return BB;
2816}
2817
2818//===----------------------------------------------------------------------===//
2819// Constants.
2820//===----------------------------------------------------------------------===//
2821
2822/// ParseValID - Parse an abstract value that doesn't necessarily have a
2823/// type implied. For example, if we parse "4" we don't know what integer type
2824/// it has. The value will later be combined with its type and checked for
2825/// sanity. PFS is used to convert function-local operands of metadata (since
2826/// metadata operands are not just parsed here but also converted to values).
2827/// PFS can be null when we are not parsing metadata values inside a function.
2828bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2829 ID.Loc = Lex.getLoc();
2830 switch (Lex.getKind()) {
2831 default: return TokError("expected value token");
2832 case lltok::GlobalID: // @42
2833 ID.UIntVal = Lex.getUIntVal();
2834 ID.Kind = ValID::t_GlobalID;
2835 break;
2836 case lltok::GlobalVar: // @foo
2837 ID.StrVal = Lex.getStrVal();
2838 ID.Kind = ValID::t_GlobalName;
2839 break;
2840 case lltok::LocalVarID: // %42
2841 ID.UIntVal = Lex.getUIntVal();
2842 ID.Kind = ValID::t_LocalID;
2843 break;
2844 case lltok::LocalVar: // %foo
2845 ID.StrVal = Lex.getStrVal();
2846 ID.Kind = ValID::t_LocalName;
2847 break;
2848 case lltok::APSInt:
2849 ID.APSIntVal = Lex.getAPSIntVal();
2850 ID.Kind = ValID::t_APSInt;
2851 break;
2852 case lltok::APFloat:
2853 ID.APFloatVal = Lex.getAPFloatVal();
2854 ID.Kind = ValID::t_APFloat;
2855 break;
2856 case lltok::kw_true:
2857 ID.ConstantVal = ConstantInt::getTrue(Context);
2858 ID.Kind = ValID::t_Constant;
2859 break;
2860 case lltok::kw_false:
2861 ID.ConstantVal = ConstantInt::getFalse(Context);
2862 ID.Kind = ValID::t_Constant;
2863 break;
2864 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2865 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2866 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2867 case lltok::kw_none: ID.Kind = ValID::t_None; break;
2868
2869 case lltok::lbrace: {
2870 // ValID ::= '{' ConstVector '}'
2871 Lex.Lex();
2872 SmallVector<Constant*, 16> Elts;
2873 if (ParseGlobalValueVector(Elts) ||
2874 ParseToken(lltok::rbrace, "expected end of struct constant"))
2875 return true;
2876
2877 ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2878 ID.UIntVal = Elts.size();
2879 memcpy(ID.ConstantStructElts.get(), Elts.data(),
2880 Elts.size() * sizeof(Elts[0]));
2881 ID.Kind = ValID::t_ConstantStruct;
2882 return false;
2883 }
2884 case lltok::less: {
2885 // ValID ::= '<' ConstVector '>' --> Vector.
2886 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
2887 Lex.Lex();
2888 bool isPackedStruct = EatIfPresent(lltok::lbrace);
2889
2890 SmallVector<Constant*, 16> Elts;
2891 LocTy FirstEltLoc = Lex.getLoc();
2892 if (ParseGlobalValueVector(Elts) ||
2893 (isPackedStruct &&
2894 ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2895 ParseToken(lltok::greater, "expected end of constant"))
2896 return true;
2897
2898 if (isPackedStruct) {
2899 ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2900 memcpy(ID.ConstantStructElts.get(), Elts.data(),
2901 Elts.size() * sizeof(Elts[0]));
2902 ID.UIntVal = Elts.size();
2903 ID.Kind = ValID::t_PackedConstantStruct;
2904 return false;
2905 }
2906
2907 if (Elts.empty())
2908 return Error(ID.Loc, "constant vector must not be empty");
2909
2910 if (!Elts[0]->getType()->isIntegerTy() &&
2911 !Elts[0]->getType()->isFloatingPointTy() &&
2912 !Elts[0]->getType()->isPointerTy())
2913 return Error(FirstEltLoc,
2914 "vector elements must have integer, pointer or floating point type");
2915
2916 // Verify that all the vector elements have the same type.
2917 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2918 if (Elts[i]->getType() != Elts[0]->getType())
2919 return Error(FirstEltLoc,
2920 "vector element #" + Twine(i) +
2921 " is not of type '" + getTypeString(Elts[0]->getType()));
2922
2923 ID.ConstantVal = ConstantVector::get(Elts);
2924 ID.Kind = ValID::t_Constant;
2925 return false;
2926 }
2927 case lltok::lsquare: { // Array Constant
2928 Lex.Lex();
2929 SmallVector<Constant*, 16> Elts;
2930 LocTy FirstEltLoc = Lex.getLoc();
2931 if (ParseGlobalValueVector(Elts) ||
2932 ParseToken(lltok::rsquare, "expected end of array constant"))
2933 return true;
2934
2935 // Handle empty element.
2936 if (Elts.empty()) {
2937 // Use undef instead of an array because it's inconvenient to determine
2938 // the element type at this point, there being no elements to examine.
2939 ID.Kind = ValID::t_EmptyArray;
2940 return false;
2941 }
2942
2943 if (!Elts[0]->getType()->isFirstClassType())
2944 return Error(FirstEltLoc, "invalid array element type: " +
2945 getTypeString(Elts[0]->getType()));
2946
2947 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2948
2949 // Verify all elements are correct type!
2950 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2951 if (Elts[i]->getType() != Elts[0]->getType())
2952 return Error(FirstEltLoc,
2953 "array element #" + Twine(i) +
2954 " is not of type '" + getTypeString(Elts[0]->getType()));
2955 }
2956
2957 ID.ConstantVal = ConstantArray::get(ATy, Elts);
2958 ID.Kind = ValID::t_Constant;
2959 return false;
2960 }
2961 case lltok::kw_c: // c "foo"
2962 Lex.Lex();
2963 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
2964 false);
2965 if (ParseToken(lltok::StringConstant, "expected string")) return true;
2966 ID.Kind = ValID::t_Constant;
2967 return false;
2968
2969 case lltok::kw_asm: {
2970 // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ','
2971 // STRINGCONSTANT
2972 bool HasSideEffect, AlignStack, AsmDialect;
2973 Lex.Lex();
2974 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2975 ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2976 ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
2977 ParseStringConstant(ID.StrVal) ||
2978 ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2979 ParseToken(lltok::StringConstant, "expected constraint string"))
2980 return true;
2981 ID.StrVal2 = Lex.getStrVal();
2982 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2983 (unsigned(AsmDialect)<<2);
2984 ID.Kind = ValID::t_InlineAsm;
2985 return false;
2986 }
2987
2988 case lltok::kw_blockaddress: {
2989 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2990 Lex.Lex();
2991
2992 ValID Fn, Label;
2993
2994 if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2995 ParseValID(Fn) ||
2996 ParseToken(lltok::comma, "expected comma in block address expression")||
2997 ParseValID(Label) ||
2998 ParseToken(lltok::rparen, "expected ')' in block address expression"))
2999 return true;
3000
3001 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
3002 return Error(Fn.Loc, "expected function name in blockaddress");
3003 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
3004 return Error(Label.Loc, "expected basic block name in blockaddress");
3005
3006 // Try to find the function (but skip it if it's forward-referenced).
3007 GlobalValue *GV = nullptr;
3008 if (Fn.Kind == ValID::t_GlobalID) {
3009 if (Fn.UIntVal < NumberedVals.size())
3010 GV = NumberedVals[Fn.UIntVal];
3011 } else if (!ForwardRefVals.count(Fn.StrVal)) {
3012 GV = M->getNamedValue(Fn.StrVal);
3013 }
3014 Function *F = nullptr;
3015 if (GV) {
3016 // Confirm that it's actually a function with a definition.
3017 if (!isa<Function>(GV))
3018 return Error(Fn.Loc, "expected function name in blockaddress");
3019 F = cast<Function>(GV);
3020 if (F->isDeclaration())
3021 return Error(Fn.Loc, "cannot take blockaddress inside a declaration");
3022 }
3023
3024 if (!F) {
3025 // Make a global variable as a placeholder for this reference.
3026 GlobalValue *&FwdRef =
3027 ForwardRefBlockAddresses.insert(std::make_pair(
3028 std::move(Fn),
3029 std::map<ValID, GlobalValue *>()))
3030 .first->second.insert(std::make_pair(std::move(Label), nullptr))
3031 .first->second;
3032 if (!FwdRef)
3033 FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
3034 GlobalValue::InternalLinkage, nullptr, "");
3035 ID.ConstantVal = FwdRef;
3036 ID.Kind = ValID::t_Constant;
3037 return false;
3038 }
3039
3040 // We found the function; now find the basic block. Don't use PFS, since we
3041 // might be inside a constant expression.
3042 BasicBlock *BB;
3043 if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
3044 if (Label.Kind == ValID::t_LocalID)
3045 BB = BlockAddressPFS->GetBB(Label.UIntVal, Label.Loc);
3046 else
3047 BB = BlockAddressPFS->GetBB(Label.StrVal, Label.Loc);
3048 if (!BB)
3049 return Error(Label.Loc, "referenced value is not a basic block");
3050 } else {
3051 if (Label.Kind == ValID::t_LocalID)
3052 return Error(Label.Loc, "cannot take address of numeric label after "
3053 "the function is defined");
3054 BB = dyn_cast_or_null<BasicBlock>(
3055 F->getValueSymbolTable()->lookup(Label.StrVal));
3056 if (!BB)
3057 return Error(Label.Loc, "referenced value is not a basic block");
3058 }
3059
3060 ID.ConstantVal = BlockAddress::get(F, BB);
3061 ID.Kind = ValID::t_Constant;
3062 return false;
3063 }
3064
3065 case lltok::kw_trunc:
3066 case lltok::kw_zext:
3067 case lltok::kw_sext:
3068 case lltok::kw_fptrunc:
3069 case lltok::kw_fpext:
3070 case lltok::kw_bitcast:
3071 case lltok::kw_addrspacecast:
3072 case lltok::kw_uitofp:
3073 case lltok::kw_sitofp:
3074 case lltok::kw_fptoui:
3075 case lltok::kw_fptosi:
3076 case lltok::kw_inttoptr:
3077 case lltok::kw_ptrtoint: {
3078 unsigned Opc = Lex.getUIntVal();
3079 Type *DestTy = nullptr;
3080 Constant *SrcVal;
3081 Lex.Lex();
3082 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
3083 ParseGlobalTypeAndValue(SrcVal) ||
3084 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
3085 ParseType(DestTy) ||
3086 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
3087 return true;
3088 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
3089 return Error(ID.Loc, "invalid cast opcode for cast from '" +
3090 getTypeString(SrcVal->getType()) + "' to '" +
3091 getTypeString(DestTy) + "'");
3092 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
3093 SrcVal, DestTy);
3094 ID.Kind = ValID::t_Constant;
3095 return false;
3096 }
3097 case lltok::kw_extractvalue: {
3098 Lex.Lex();
3099 Constant *Val;
3100 SmallVector<unsigned, 4> Indices;
3101 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
3102 ParseGlobalTypeAndValue(Val) ||
3103 ParseIndexList(Indices) ||
3104 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
3105 return true;
3106
3107 if (!Val->getType()->isAggregateType())
3108 return Error(ID.Loc, "extractvalue operand must be aggregate type");
3109 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
3110 return Error(ID.Loc, "invalid indices for extractvalue");
3111 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
3112 ID.Kind = ValID::t_Constant;
3113 return false;
3114 }
3115 case lltok::kw_insertvalue: {
3116 Lex.Lex();
3117 Constant *Val0, *Val1;
3118 SmallVector<unsigned, 4> Indices;
3119 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
3120 ParseGlobalTypeAndValue(Val0) ||
3121 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
3122 ParseGlobalTypeAndValue(Val1) ||
3123 ParseIndexList(Indices) ||
3124 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
3125 return true;
3126 if (!Val0->getType()->isAggregateType())
3127 return Error(ID.Loc, "insertvalue operand must be aggregate type");
3128 Type *IndexedType =
3129 ExtractValueInst::getIndexedType(Val0->getType(), Indices);
3130 if (!IndexedType)
3131 return Error(ID.Loc, "invalid indices for insertvalue");
3132 if (IndexedType != Val1->getType())
3133 return Error(ID.Loc, "insertvalue operand and field disagree in type: '" +
3134 getTypeString(Val1->getType()) +
3135 "' instead of '" + getTypeString(IndexedType) +
3136 "'");
3137 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
3138 ID.Kind = ValID::t_Constant;
3139 return false;
3140 }
3141 case lltok::kw_icmp:
3142 case lltok::kw_fcmp: {
3143 unsigned PredVal, Opc = Lex.getUIntVal();
3144 Constant *Val0, *Val1;
3145 Lex.Lex();
3146 if (ParseCmpPredicate(PredVal, Opc) ||
3147 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
3148 ParseGlobalTypeAndValue(Val0) ||
3149 ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
3150 ParseGlobalTypeAndValue(Val1) ||
3151 ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
3152 return true;
3153
3154 if (Val0->getType() != Val1->getType())
3155 return Error(ID.Loc, "compare operands must have the same type");
3156
3157 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
3158
3159 if (Opc == Instruction::FCmp) {
3160 if (!Val0->getType()->isFPOrFPVectorTy())
3161 return Error(ID.Loc, "fcmp requires floating point operands");
3162 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
3163 } else {
3164 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!")(static_cast <bool> (Opc == Instruction::ICmp &&
"Unexpected opcode for CmpInst!") ? void (0) : __assert_fail
("Opc == Instruction::ICmp && \"Unexpected opcode for CmpInst!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3164, __extension__ __PRETTY_FUNCTION__))
;
3165 if (!Val0->getType()->isIntOrIntVectorTy() &&
3166 !Val0->getType()->isPtrOrPtrVectorTy())
3167 return Error(ID.Loc, "icmp requires pointer or integer operands");
3168 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
3169 }
3170 ID.Kind = ValID::t_Constant;
3171 return false;
3172 }
3173
3174 // Binary Operators.
3175 case lltok::kw_add:
3176 case lltok::kw_fadd:
3177 case lltok::kw_sub:
3178 case lltok::kw_fsub:
3179 case lltok::kw_mul:
3180 case lltok::kw_fmul:
3181 case lltok::kw_udiv:
3182 case lltok::kw_sdiv:
3183 case lltok::kw_fdiv:
3184 case lltok::kw_urem:
3185 case lltok::kw_srem:
3186 case lltok::kw_frem:
3187 case lltok::kw_shl:
3188 case lltok::kw_lshr:
3189 case lltok::kw_ashr: {
3190 bool NUW = false;
3191 bool NSW = false;
3192 bool Exact = false;
3193 unsigned Opc = Lex.getUIntVal();
3194 Constant *Val0, *Val1;
3195 Lex.Lex();
3196 LocTy ModifierLoc = Lex.getLoc();
3197 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
3198 Opc == Instruction::Mul || Opc == Instruction::Shl) {
3199 if (EatIfPresent(lltok::kw_nuw))
3200 NUW = true;
3201 if (EatIfPresent(lltok::kw_nsw)) {
3202 NSW = true;
3203 if (EatIfPresent(lltok::kw_nuw))
3204 NUW = true;
3205 }
3206 } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
3207 Opc == Instruction::LShr || Opc == Instruction::AShr) {
3208 if (EatIfPresent(lltok::kw_exact))
3209 Exact = true;
3210 }
3211 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
3212 ParseGlobalTypeAndValue(Val0) ||
3213 ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
3214 ParseGlobalTypeAndValue(Val1) ||
3215 ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
3216 return true;
3217 if (Val0->getType() != Val1->getType())
3218 return Error(ID.Loc, "operands of constexpr must have same type");
3219 if (!Val0->getType()->isIntOrIntVectorTy()) {
3220 if (NUW)
3221 return Error(ModifierLoc, "nuw only applies to integer operations");
3222 if (NSW)
3223 return Error(ModifierLoc, "nsw only applies to integer operations");
3224 }
3225 // Check that the type is valid for the operator.
3226 switch (Opc) {
3227 case Instruction::Add:
3228 case Instruction::Sub:
3229 case Instruction::Mul:
3230 case Instruction::UDiv:
3231 case Instruction::SDiv:
3232 case Instruction::URem:
3233 case Instruction::SRem:
3234 case Instruction::Shl:
3235 case Instruction::AShr:
3236 case Instruction::LShr:
3237 if (!Val0->getType()->isIntOrIntVectorTy())
3238 return Error(ID.Loc, "constexpr requires integer operands");
3239 break;
3240 case Instruction::FAdd:
3241 case Instruction::FSub:
3242 case Instruction::FMul:
3243 case Instruction::FDiv:
3244 case Instruction::FRem:
3245 if (!Val0->getType()->isFPOrFPVectorTy())
3246 return Error(ID.Loc, "constexpr requires fp operands");
3247 break;
3248 default: llvm_unreachable("Unknown binary operator!")::llvm::llvm_unreachable_internal("Unknown binary operator!",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3248)
;
3249 }
3250 unsigned Flags = 0;
3251 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
3252 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
3253 if (Exact) Flags |= PossiblyExactOperator::IsExact;
3254 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
3255 ID.ConstantVal = C;
3256 ID.Kind = ValID::t_Constant;
3257 return false;
3258 }
3259
3260 // Logical Operations
3261 case lltok::kw_and:
3262 case lltok::kw_or:
3263 case lltok::kw_xor: {
3264 unsigned Opc = Lex.getUIntVal();
3265 Constant *Val0, *Val1;
3266 Lex.Lex();
3267 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
3268 ParseGlobalTypeAndValue(Val0) ||
3269 ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
3270 ParseGlobalTypeAndValue(Val1) ||
3271 ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
3272 return true;
3273 if (Val0->getType() != Val1->getType())
3274 return Error(ID.Loc, "operands of constexpr must have same type");
3275 if (!Val0->getType()->isIntOrIntVectorTy())
3276 return Error(ID.Loc,
3277 "constexpr requires integer or integer vector operands");
3278 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
3279 ID.Kind = ValID::t_Constant;
3280 return false;
3281 }
3282
3283 case lltok::kw_getelementptr:
3284 case lltok::kw_shufflevector:
3285 case lltok::kw_insertelement:
3286 case lltok::kw_extractelement:
3287 case lltok::kw_select: {
3288 unsigned Opc = Lex.getUIntVal();
3289 SmallVector<Constant*, 16> Elts;
3290 bool InBounds = false;
3291 Type *Ty;
3292 Lex.Lex();
3293
3294 if (Opc == Instruction::GetElementPtr)
3295 InBounds = EatIfPresent(lltok::kw_inbounds);
3296
3297 if (ParseToken(lltok::lparen, "expected '(' in constantexpr"))
3298 return true;
3299
3300 LocTy ExplicitTypeLoc = Lex.getLoc();
3301 if (Opc == Instruction::GetElementPtr) {
3302 if (ParseType(Ty) ||
3303 ParseToken(lltok::comma, "expected comma after getelementptr's type"))
3304 return true;
3305 }
3306
3307 Optional<unsigned> InRangeOp;
3308 if (ParseGlobalValueVector(
3309 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp : nullptr) ||
3310 ParseToken(lltok::rparen, "expected ')' in constantexpr"))
3311 return true;
3312
3313 if (Opc == Instruction::GetElementPtr) {
3314 if (Elts.size() == 0 ||
3315 !Elts[0]->getType()->isPtrOrPtrVectorTy())
3316 return Error(ID.Loc, "base of getelementptr must be a pointer");
3317
3318 Type *BaseType = Elts[0]->getType();
3319 auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
3320 if (Ty != BasePointerType->getElementType())
3321 return Error(
3322 ExplicitTypeLoc,
3323 "explicit pointee type doesn't match operand's pointee type");
3324
3325 unsigned GEPWidth =
3326 BaseType->isVectorTy() ? BaseType->getVectorNumElements() : 0;
3327
3328 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
3329 for (Constant *Val : Indices) {
3330 Type *ValTy = Val->getType();
3331 if (!ValTy->isIntOrIntVectorTy())
3332 return Error(ID.Loc, "getelementptr index must be an integer");
3333 if (ValTy->isVectorTy()) {
3334 unsigned ValNumEl = ValTy->getVectorNumElements();
3335 if (GEPWidth && (ValNumEl != GEPWidth))
3336 return Error(
3337 ID.Loc,
3338 "getelementptr vector index has a wrong number of elements");
3339 // GEPWidth may have been unknown because the base is a scalar,
3340 // but it is known now.
3341 GEPWidth = ValNumEl;
3342 }
3343 }
3344
3345 SmallPtrSet<Type*, 4> Visited;
3346 if (!Indices.empty() && !Ty->isSized(&Visited))
3347 return Error(ID.Loc, "base element of getelementptr must be sized");
3348
3349 if (!GetElementPtrInst::getIndexedType(Ty, Indices))
3350 return Error(ID.Loc, "invalid getelementptr indices");
3351
3352 if (InRangeOp) {
3353 if (*InRangeOp == 0)
3354 return Error(ID.Loc,
3355 "inrange keyword may not appear on pointer operand");
3356 --*InRangeOp;
3357 }
3358
3359 ID.ConstantVal = ConstantExpr::getGetElementPtr(Ty, Elts[0], Indices,
3360 InBounds, InRangeOp);
3361 } else if (Opc == Instruction::Select) {
3362 if (Elts.size() != 3)
3363 return Error(ID.Loc, "expected three operands to select");
3364 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
3365 Elts[2]))
3366 return Error(ID.Loc, Reason);
3367 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
3368 } else if (Opc == Instruction::ShuffleVector) {
3369 if (Elts.size() != 3)
3370 return Error(ID.Loc, "expected three operands to shufflevector");
3371 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3372 return Error(ID.Loc, "invalid operands to shufflevector");
3373 ID.ConstantVal =
3374 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
3375 } else if (Opc == Instruction::ExtractElement) {
3376 if (Elts.size() != 2)
3377 return Error(ID.Loc, "expected two operands to extractelement");
3378 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
3379 return Error(ID.Loc, "invalid extractelement operands");
3380 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
3381 } else {
3382 assert(Opc == Instruction::InsertElement && "Unknown opcode")(static_cast <bool> (Opc == Instruction::InsertElement &&
"Unknown opcode") ? void (0) : __assert_fail ("Opc == Instruction::InsertElement && \"Unknown opcode\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3382, __extension__ __PRETTY_FUNCTION__))
;
3383 if (Elts.size() != 3)
3384 return Error(ID.Loc, "expected three operands to insertelement");
3385 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3386 return Error(ID.Loc, "invalid insertelement operands");
3387 ID.ConstantVal =
3388 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
3389 }
3390
3391 ID.Kind = ValID::t_Constant;
3392 return false;
3393 }
3394 }
3395
3396 Lex.Lex();
3397 return false;
3398}
3399
3400/// ParseGlobalValue - Parse a global value with the specified type.
3401bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
3402 C = nullptr;
3403 ValID ID;
3404 Value *V = nullptr;
3405 bool Parsed = ParseValID(ID) ||
3406 ConvertValIDToValue(Ty, ID, V, nullptr, /*IsCall=*/false);
3407 if (V && !(C = dyn_cast<Constant>(V)))
3408 return Error(ID.Loc, "global values must be constants");
3409 return Parsed;
3410}
3411
3412bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
3413 Type *Ty = nullptr;
3414 return ParseType(Ty) ||
3415 ParseGlobalValue(Ty, V);
3416}
3417
3418bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
3419 C = nullptr;
3420
3421 LocTy KwLoc = Lex.getLoc();
3422 if (!EatIfPresent(lltok::kw_comdat))
3423 return false;
3424
3425 if (EatIfPresent(lltok::lparen)) {
3426 if (Lex.getKind() != lltok::ComdatVar)
3427 return TokError("expected comdat variable");
3428 C = getComdat(Lex.getStrVal(), Lex.getLoc());
3429 Lex.Lex();
3430 if (ParseToken(lltok::rparen, "expected ')' after comdat var"))
3431 return true;
3432 } else {
3433 if (GlobalName.empty())
3434 return TokError("comdat cannot be unnamed");
3435 C = getComdat(GlobalName, KwLoc);
3436 }
3437
3438 return false;
3439}
3440
3441/// ParseGlobalValueVector
3442/// ::= /*empty*/
3443/// ::= [inrange] TypeAndValue (',' [inrange] TypeAndValue)*
3444bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
3445 Optional<unsigned> *InRangeOp) {
3446 // Empty list.
3447 if (Lex.getKind() == lltok::rbrace ||
3448 Lex.getKind() == lltok::rsquare ||
3449 Lex.getKind() == lltok::greater ||
3450 Lex.getKind() == lltok::rparen)
3451 return false;
3452
3453 do {
3454 if (InRangeOp && !*InRangeOp && EatIfPresent(lltok::kw_inrange))
3455 *InRangeOp = Elts.size();
3456
3457 Constant *C;
3458 if (ParseGlobalTypeAndValue(C)) return true;
3459 Elts.push_back(C);
3460 } while (EatIfPresent(lltok::comma));
3461
3462 return false;
3463}
3464
3465bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
3466 SmallVector<Metadata *, 16> Elts;
3467 if (ParseMDNodeVector(Elts))
3468 return true;
3469
3470 MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
3471 return false;
3472}
3473
3474/// MDNode:
3475/// ::= !{ ... }
3476/// ::= !7
3477/// ::= !DILocation(...)
3478bool LLParser::ParseMDNode(MDNode *&N) {
3479 if (Lex.getKind() == lltok::MetadataVar)
3480 return ParseSpecializedMDNode(N);
3481
3482 return ParseToken(lltok::exclaim, "expected '!' here") ||
3483 ParseMDNodeTail(N);
3484}
3485
3486bool LLParser::ParseMDNodeTail(MDNode *&N) {
3487 // !{ ... }
3488 if (Lex.getKind() == lltok::lbrace)
3489 return ParseMDTuple(N);
3490
3491 // !42
3492 return ParseMDNodeID(N);
3493}
3494
3495namespace {
3496
3497/// Structure to represent an optional metadata field.
3498template <class FieldTy> struct MDFieldImpl {
3499 typedef MDFieldImpl ImplTy;
3500 FieldTy Val;
3501 bool Seen;
3502
3503 void assign(FieldTy Val) {
3504 Seen = true;
3505 this->Val = std::move(Val);
3506 }
3507
3508 explicit MDFieldImpl(FieldTy Default)
3509 : Val(std::move(Default)), Seen(false) {}
3510};
3511
3512/// Structure to represent an optional metadata field that
3513/// can be of either type (A or B) and encapsulates the
3514/// MD<typeofA>Field and MD<typeofB>Field structs, so not
3515/// to reimplement the specifics for representing each Field.
3516template <class FieldTypeA, class FieldTypeB> struct MDEitherFieldImpl {
3517 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
3518 FieldTypeA A;
3519 FieldTypeB B;
3520 bool Seen;
3521
3522 enum {
3523 IsInvalid = 0,
3524 IsTypeA = 1,
3525 IsTypeB = 2
3526 } WhatIs;
3527
3528 void assign(FieldTypeA A) {
3529 Seen = true;
3530 this->A = std::move(A);
3531 WhatIs = IsTypeA;
3532 }
3533
3534 void assign(FieldTypeB B) {
3535 Seen = true;
3536 this->B = std::move(B);
3537 WhatIs = IsTypeB;
3538 }
3539
3540 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
3541 : A(std::move(DefaultA)), B(std::move(DefaultB)), Seen(false),
3542 WhatIs(IsInvalid) {}
3543};
3544
3545struct MDUnsignedField : public MDFieldImpl<uint64_t> {
3546 uint64_t Max;
3547
3548 MDUnsignedField(uint64_t Default = 0, uint64_t Max = UINT64_MAX(18446744073709551615UL))
3549 : ImplTy(Default), Max(Max) {}
3550};
3551
3552struct LineField : public MDUnsignedField {
3553 LineField() : MDUnsignedField(0, UINT32_MAX(4294967295U)) {}
3554};
3555
3556struct ColumnField : public MDUnsignedField {
3557 ColumnField() : MDUnsignedField(0, UINT16_MAX(65535)) {}
3558};
3559
3560struct DwarfTagField : public MDUnsignedField {
3561 DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
3562 DwarfTagField(dwarf::Tag DefaultTag)
3563 : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
3564};
3565
3566struct DwarfMacinfoTypeField : public MDUnsignedField {
3567 DwarfMacinfoTypeField() : MDUnsignedField(0, dwarf::DW_MACINFO_vendor_ext) {}
3568 DwarfMacinfoTypeField(dwarf::MacinfoRecordType DefaultType)
3569 : MDUnsignedField(DefaultType, dwarf::DW_MACINFO_vendor_ext) {}
3570};
3571
3572struct DwarfAttEncodingField : public MDUnsignedField {
3573 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
3574};
3575
3576struct DwarfVirtualityField : public MDUnsignedField {
3577 DwarfVirtualityField() : MDUnsignedField(0, dwarf::DW_VIRTUALITY_max) {}
3578};
3579
3580struct DwarfLangField : public MDUnsignedField {
3581 DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
3582};
3583
3584struct DwarfCCField : public MDUnsignedField {
3585 DwarfCCField() : MDUnsignedField(0, dwarf::DW_CC_hi_user) {}
3586};
3587
3588struct EmissionKindField : public MDUnsignedField {
3589 EmissionKindField() : MDUnsignedField(0, DICompileUnit::LastEmissionKind) {}
3590};
3591
3592struct DIFlagField : public MDFieldImpl<DINode::DIFlags> {
3593 DIFlagField() : MDFieldImpl(DINode::FlagZero) {}
3594};
3595
3596struct MDSignedField : public MDFieldImpl<int64_t> {
3597 int64_t Min;
3598 int64_t Max;
3599
3600 MDSignedField(int64_t Default = 0)
3601 : ImplTy(Default), Min(INT64_MIN(-9223372036854775807L -1)), Max(INT64_MAX(9223372036854775807L)) {}
3602 MDSignedField(int64_t Default, int64_t Min, int64_t Max)
3603 : ImplTy(Default), Min(Min), Max(Max) {}
3604};
3605
3606struct MDBoolField : public MDFieldImpl<bool> {
3607 MDBoolField(bool Default = false) : ImplTy(Default) {}
3608};
3609
3610struct MDField : public MDFieldImpl<Metadata *> {
3611 bool AllowNull;
3612
3613 MDField(bool AllowNull = true) : ImplTy(nullptr), AllowNull(AllowNull) {}
3614};
3615
3616struct MDConstant : public MDFieldImpl<ConstantAsMetadata *> {
3617 MDConstant() : ImplTy(nullptr) {}
3618};
3619
3620struct MDStringField : public MDFieldImpl<MDString *> {
3621 bool AllowEmpty;
3622 MDStringField(bool AllowEmpty = true)
3623 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
3624};
3625
3626struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
3627 MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
3628};
3629
3630struct ChecksumKindField : public MDFieldImpl<DIFile::ChecksumKind> {
3631 ChecksumKindField(DIFile::ChecksumKind CSKind) : ImplTy(CSKind) {}
3632};
3633
3634struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
3635 MDSignedOrMDField(int64_t Default = 0, bool AllowNull = true)
3636 : ImplTy(MDSignedField(Default), MDField(AllowNull)) {}
3637
3638 MDSignedOrMDField(int64_t Default, int64_t Min, int64_t Max,
3639 bool AllowNull = true)
3640 : ImplTy(MDSignedField(Default, Min, Max), MDField(AllowNull)) {}
3641
3642 bool isMDSignedField() const { return WhatIs == IsTypeA; }
3643 bool isMDField() const { return WhatIs == IsTypeB; }
3644 int64_t getMDSignedValue() const {
3645 assert(isMDSignedField() && "Wrong field type")(static_cast <bool> (isMDSignedField() && "Wrong field type"
) ? void (0) : __assert_fail ("isMDSignedField() && \"Wrong field type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3645, __extension__ __PRETTY_FUNCTION__))
;
3646 return A.Val;
3647 }
3648 Metadata *getMDFieldValue() const {
3649 assert(isMDField() && "Wrong field type")(static_cast <bool> (isMDField() && "Wrong field type"
) ? void (0) : __assert_fail ("isMDField() && \"Wrong field type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__))
;
3650 return B.Val;
3651 }
3652};
3653
3654struct MDSignedOrUnsignedField
3655 : MDEitherFieldImpl<MDSignedField, MDUnsignedField> {
3656 MDSignedOrUnsignedField() : ImplTy(MDSignedField(0), MDUnsignedField(0)) {}
3657
3658 bool isMDSignedField() const { return WhatIs == IsTypeA; }
3659 bool isMDUnsignedField() const { return WhatIs == IsTypeB; }
3660 int64_t getMDSignedValue() const {
3661 assert(isMDSignedField() && "Wrong field type")(static_cast <bool> (isMDSignedField() && "Wrong field type"
) ? void (0) : __assert_fail ("isMDSignedField() && \"Wrong field type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3661, __extension__ __PRETTY_FUNCTION__))
;
3662 return A.Val;
3663 }
3664 uint64_t getMDUnsignedValue() const {
3665 assert(isMDUnsignedField() && "Wrong field type")(static_cast <bool> (isMDUnsignedField() && "Wrong field type"
) ? void (0) : __assert_fail ("isMDUnsignedField() && \"Wrong field type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3665, __extension__ __PRETTY_FUNCTION__))
;
3666 return B.Val;
3667 }
3668};
3669
3670} // end anonymous namespace
3671
3672namespace llvm {
3673
3674template <>
3675bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3676 MDUnsignedField &Result) {
3677 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
3678 return TokError("expected unsigned integer");
3679
3680 auto &U = Lex.getAPSIntVal();
3681 if (U.ugt(Result.Max))
3682 return TokError("value for '" + Name + "' too large, limit is " +
3683 Twine(Result.Max));
3684 Result.assign(U.getZExtValue());
3685 assert(Result.Val <= Result.Max && "Expected value in range")(static_cast <bool> (Result.Val <= Result.Max &&
"Expected value in range") ? void (0) : __assert_fail ("Result.Val <= Result.Max && \"Expected value in range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3685, __extension__ __PRETTY_FUNCTION__))
;
3686 Lex.Lex();
3687 return false;
3688}
3689
3690template <>
3691bool LLParser::ParseMDField(LocTy Loc, StringRef Name, LineField &Result) {
3692 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3693}
3694template <>
3695bool LLParser::ParseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
3696 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3697}
3698
3699template <>
3700bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
3701 if (Lex.getKind() == lltok::APSInt)
3702 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3703
3704 if (Lex.getKind() != lltok::DwarfTag)
3705 return TokError("expected DWARF tag");
3706
3707 unsigned Tag = dwarf::getTag(Lex.getStrVal());
3708 if (Tag == dwarf::DW_TAG_invalid)
3709 return TokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
3710 assert(Tag <= Result.Max && "Expected valid DWARF tag")(static_cast <bool> (Tag <= Result.Max && "Expected valid DWARF tag"
) ? void (0) : __assert_fail ("Tag <= Result.Max && \"Expected valid DWARF tag\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3710, __extension__ __PRETTY_FUNCTION__))
;
3711
3712 Result.assign(Tag);
3713 Lex.Lex();
3714 return false;
3715}
3716
3717template <>
3718bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3719 DwarfMacinfoTypeField &Result) {
3720 if (Lex.getKind() == lltok::APSInt)
3721 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3722
3723 if (Lex.getKind() != lltok::DwarfMacinfo)
3724 return TokError("expected DWARF macinfo type");
3725
3726 unsigned Macinfo = dwarf::getMacinfo(Lex.getStrVal());
3727 if (Macinfo == dwarf::DW_MACINFO_invalid)
3728 return TokError(
3729 "invalid DWARF macinfo type" + Twine(" '") + Lex.getStrVal() + "'");
3730 assert(Macinfo <= Result.Max && "Expected valid DWARF macinfo type")(static_cast <bool> (Macinfo <= Result.Max &&
"Expected valid DWARF macinfo type") ? void (0) : __assert_fail
("Macinfo <= Result.Max && \"Expected valid DWARF macinfo type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3730, __extension__ __PRETTY_FUNCTION__))
;
3731
3732 Result.assign(Macinfo);
3733 Lex.Lex();
3734 return false;
3735}
3736
3737template <>
3738bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3739 DwarfVirtualityField &Result) {
3740 if (Lex.getKind() == lltok::APSInt)
3741 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3742
3743 if (Lex.getKind() != lltok::DwarfVirtuality)
3744 return TokError("expected DWARF virtuality code");
3745
3746 unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
3747 if (Virtuality == dwarf::DW_VIRTUALITY_invalid)
3748 return TokError("invalid DWARF virtuality code" + Twine(" '") +
3749 Lex.getStrVal() + "'");
3750 assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code")(static_cast <bool> (Virtuality <= Result.Max &&
"Expected valid DWARF virtuality code") ? void (0) : __assert_fail
("Virtuality <= Result.Max && \"Expected valid DWARF virtuality code\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3750, __extension__ __PRETTY_FUNCTION__))
;
3751 Result.assign(Virtuality);
3752 Lex.Lex();
3753 return false;
3754}
3755
3756template <>
3757bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
3758 if (Lex.getKind() == lltok::APSInt)
3759 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3760
3761 if (Lex.getKind() != lltok::DwarfLang)
3762 return TokError("expected DWARF language");
3763
3764 unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
3765 if (!Lang)
3766 return TokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
3767 "'");
3768 assert(Lang <= Result.Max && "Expected valid DWARF language")(static_cast <bool> (Lang <= Result.Max && "Expected valid DWARF language"
) ? void (0) : __assert_fail ("Lang <= Result.Max && \"Expected valid DWARF language\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3768, __extension__ __PRETTY_FUNCTION__))
;
3769 Result.assign(Lang);
3770 Lex.Lex();
3771 return false;
3772}
3773
3774template <>
3775bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
3776 if (Lex.getKind() == lltok::APSInt)
3777 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3778
3779 if (Lex.getKind() != lltok::DwarfCC)
3780 return TokError("expected DWARF calling convention");
3781
3782 unsigned CC = dwarf::getCallingConvention(Lex.getStrVal());
3783 if (!CC)
3784 return TokError("invalid DWARF calling convention" + Twine(" '") + Lex.getStrVal() +
3785 "'");
3786 assert(CC <= Result.Max && "Expected valid DWARF calling convention")(static_cast <bool> (CC <= Result.Max && "Expected valid DWARF calling convention"
) ? void (0) : __assert_fail ("CC <= Result.Max && \"Expected valid DWARF calling convention\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3786, __extension__ __PRETTY_FUNCTION__))
;
3787 Result.assign(CC);
3788 Lex.Lex();
3789 return false;
3790}
3791
3792template <>
3793bool LLParser::ParseMDField(LocTy Loc, StringRef Name, EmissionKindField &Result) {
3794 if (Lex.getKind() == lltok::APSInt)
3795 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3796
3797 if (Lex.getKind() != lltok::EmissionKind)
3798 return TokError("expected emission kind");
3799
3800 auto Kind = DICompileUnit::getEmissionKind(Lex.getStrVal());
3801 if (!Kind)
3802 return TokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() +
3803 "'");
3804 assert(*Kind <= Result.Max && "Expected valid emission kind")(static_cast <bool> (*Kind <= Result.Max && "Expected valid emission kind"
) ? void (0) : __assert_fail ("*Kind <= Result.Max && \"Expected valid emission kind\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3804, __extension__ __PRETTY_FUNCTION__))
;
3805 Result.assign(*Kind);
3806 Lex.Lex();
3807 return false;
3808}
3809
3810template <>
3811bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3812 DwarfAttEncodingField &Result) {
3813 if (Lex.getKind() == lltok::APSInt)
3814 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3815
3816 if (Lex.getKind() != lltok::DwarfAttEncoding)
3817 return TokError("expected DWARF type attribute encoding");
3818
3819 unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
3820 if (!Encoding)
3821 return TokError("invalid DWARF type attribute encoding" + Twine(" '") +
3822 Lex.getStrVal() + "'");
3823 assert(Encoding <= Result.Max && "Expected valid DWARF language")(static_cast <bool> (Encoding <= Result.Max &&
"Expected valid DWARF language") ? void (0) : __assert_fail (
"Encoding <= Result.Max && \"Expected valid DWARF language\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3823, __extension__ __PRETTY_FUNCTION__))
;
3824 Result.assign(Encoding);
3825 Lex.Lex();
3826 return false;
3827}
3828
3829/// DIFlagField
3830/// ::= uint32
3831/// ::= DIFlagVector
3832/// ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
3833template <>
3834bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
3835
3836 // Parser for a single flag.
3837 auto parseFlag = [&](DINode::DIFlags &Val) {
3838 if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
3839 uint32_t TempVal = static_cast<uint32_t>(Val);
3840 bool Res = ParseUInt32(TempVal);
3841 Val = static_cast<DINode::DIFlags>(TempVal);
3842 return Res;
3843 }
3844
3845 if (Lex.getKind() != lltok::DIFlag)
3846 return TokError("expected debug info flag");
3847
3848 Val = DINode::getFlag(Lex.getStrVal());
3849 if (!Val)
3850 return TokError(Twine("invalid debug info flag flag '") +
3851 Lex.getStrVal() + "'");
3852 Lex.Lex();
3853 return false;
3854 };
3855
3856 // Parse the flags and combine them together.
3857 DINode::DIFlags Combined = DINode::FlagZero;
3858 do {
3859 DINode::DIFlags Val;
3860 if (parseFlag(Val))
3861 return true;
3862 Combined |= Val;
3863 } while (EatIfPresent(lltok::bar));
3864
3865 Result.assign(Combined);
3866 return false;
3867}
3868
3869template <>
3870bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3871 MDSignedField &Result) {
3872 if (Lex.getKind() != lltok::APSInt)
3873 return TokError("expected signed integer");
3874
3875 auto &S = Lex.getAPSIntVal();
3876 if (S < Result.Min)
3877 return TokError("value for '" + Name + "' too small, limit is " +
3878 Twine(Result.Min));
3879 if (S > Result.Max)
3880 return TokError("value for '" + Name + "' too large, limit is " +
3881 Twine(Result.Max));
3882 Result.assign(S.getExtValue());
3883 assert(Result.Val >= Result.Min && "Expected value in range")(static_cast <bool> (Result.Val >= Result.Min &&
"Expected value in range") ? void (0) : __assert_fail ("Result.Val >= Result.Min && \"Expected value in range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3883, __extension__ __PRETTY_FUNCTION__))
;
3884 assert(Result.Val <= Result.Max && "Expected value in range")(static_cast <bool> (Result.Val <= Result.Max &&
"Expected value in range") ? void (0) : __assert_fail ("Result.Val <= Result.Max && \"Expected value in range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 3884, __extension__ __PRETTY_FUNCTION__))
;
3885 Lex.Lex();
3886 return false;
3887}
3888
3889template <>
3890bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
3891 switch (Lex.getKind()) {
3892 default:
3893 return TokError("expected 'true' or 'false'");
3894 case lltok::kw_true:
3895 Result.assign(true);
3896 break;
3897 case lltok::kw_false:
3898 Result.assign(false);
3899 break;
3900 }
3901 Lex.Lex();
3902 return false;
3903}
3904
3905template <>
3906bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDField &Result) {
3907 if (Lex.getKind() == lltok::kw_null) {
3908 if (!Result.AllowNull)
3909 return TokError("'" + Name + "' cannot be null");
3910 Lex.Lex();
3911 Result.assign(nullptr);
3912 return false;
3913 }
3914
3915 Metadata *MD;
3916 if (ParseMetadata(MD, nullptr))
3917 return true;
3918
3919 Result.assign(MD);
3920 return false;
3921}
3922
3923template <>
3924bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3925 MDSignedOrMDField &Result) {
3926 // Try to parse a signed int.
3927 if (Lex.getKind() == lltok::APSInt) {
3928 MDSignedField Res = Result.A;
3929 if (!ParseMDField(Loc, Name, Res)) {
3930 Result.assign(Res);
3931 return false;
3932 }
3933 return true;
3934 }
3935
3936 // Otherwise, try to parse as an MDField.
3937 MDField Res = Result.B;
3938 if (!ParseMDField(Loc, Name, Res)) {
3939 Result.assign(Res);
3940 return false;
3941 }
3942
3943 return true;
3944}
3945
3946template <>
3947bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3948 MDSignedOrUnsignedField &Result) {
3949 if (Lex.getKind() != lltok::APSInt)
3950 return false;
3951
3952 if (Lex.getAPSIntVal().isSigned()) {
3953 MDSignedField Res = Result.A;
3954 if (ParseMDField(Loc, Name, Res))
3955 return true;
3956 Result.assign(Res);
3957 return false;
3958 }
3959
3960 MDUnsignedField Res = Result.B;
3961 if (ParseMDField(Loc, Name, Res))
3962 return true;
3963 Result.assign(Res);
3964 return false;
3965}
3966
3967template <>
3968bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
3969 LocTy ValueLoc = Lex.getLoc();
3970 std::string S;
3971 if (ParseStringConstant(S))
3972 return true;
3973
3974 if (!Result.AllowEmpty && S.empty())
3975 return Error(ValueLoc, "'" + Name + "' cannot be empty");
3976
3977 Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
3978 return false;
3979}
3980
3981template <>
3982bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
3983 SmallVector<Metadata *, 4> MDs;
3984 if (ParseMDNodeVector(MDs))
3985 return true;
3986
3987 Result.assign(std::move(MDs));
3988 return false;
3989}
3990
3991template <>
3992bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3993 ChecksumKindField &Result) {
3994 Optional<DIFile::ChecksumKind> CSKind =
3995 DIFile::getChecksumKind(Lex.getStrVal());
3996
3997 if (Lex.getKind() != lltok::ChecksumKind || !CSKind)
3998 return TokError(
3999 "invalid checksum kind" + Twine(" '") + Lex.getStrVal() + "'");
4000
4001 Result.assign(*CSKind);
4002 Lex.Lex();
4003 return false;
4004}
4005
4006} // end namespace llvm
4007
4008template <class ParserTy>
4009bool LLParser::ParseMDFieldsImplBody(ParserTy parseField) {
4010 do {
4011 if (Lex.getKind() != lltok::LabelStr)
4012 return TokError("expected field label here");
4013
4014 if (parseField())
4015 return true;
4016 } while (EatIfPresent(lltok::comma));
4017
4018 return false;
4019}
4020
4021template <class ParserTy>
4022bool LLParser::ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc) {
4023 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name")(static_cast <bool> (Lex.getKind() == lltok::MetadataVar
&& "Expected metadata type name") ? void (0) : __assert_fail
("Lex.getKind() == lltok::MetadataVar && \"Expected metadata type name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4023, __extension__ __PRETTY_FUNCTION__))
;
4024 Lex.Lex();
4025
4026 if (ParseToken(lltok::lparen, "expected '(' here"))
4027 return true;
4028 if (Lex.getKind() != lltok::rparen)
4029 if (ParseMDFieldsImplBody(parseField))
4030 return true;
4031
4032 ClosingLoc = Lex.getLoc();
4033 return ParseToken(lltok::rparen, "expected ')' here");
4034}
4035
4036template <class FieldTy>
4037bool LLParser::ParseMDField(StringRef Name, FieldTy &Result) {
4038 if (Result.Seen)
4039 return TokError("field '" + Name + "' cannot be specified more than once");
4040
4041 LocTy Loc = Lex.getLoc();
4042 Lex.Lex();
4043 return ParseMDField(Loc, Name, Result);
4044}
4045
4046bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
4047 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name")(static_cast <bool> (Lex.getKind() == lltok::MetadataVar
&& "Expected metadata type name") ? void (0) : __assert_fail
("Lex.getKind() == lltok::MetadataVar && \"Expected metadata type name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4047, __extension__ __PRETTY_FUNCTION__))
;
4048
4049#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4050 if (Lex.getStrVal() == #CLASS) \
4051 return Parse##CLASS(N, IsDistinct);
4052#include "llvm/IR/Metadata.def"
4053
4054 return TokError("expected metadata type");
4055}
4056
4057#define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4058#define NOP_FIELD(NAME, TYPE, INIT)
4059#define REQUIRE_FIELD(NAME, TYPE, INIT) \
4060 if (!NAME.Seen) \
4061 return Error(ClosingLoc, "missing required field '" #NAME "'");
4062#define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4063 if (Lex.getStrVal() == #NAME) \
4064 return ParseMDField(#NAME, NAME);
4065#define PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
\
4066 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4067 do { \
4068 LocTy ClosingLoc; \
4069 if (ParseMDFieldsImpl([&]() -> bool { \
4070 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4071 return TokError(Twine("invalid field '") + Lex.getStrVal() + "'"); \
4072 }, ClosingLoc)) \
4073 return true; \
4074 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4075 } while (false)
4076#define GET_OR_DISTINCT(CLASS, ARGS)(IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS) \
4077 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4078
4079/// ParseDILocationFields:
4080/// ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6)
4081bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
4082#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4083 OPTIONAL(line, LineField, ); \
4084 OPTIONAL(column, ColumnField, ); \
4085 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4086 OPTIONAL(inlinedAt, MDField, );
4087 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4088#undef VISIT_MD_FIELDS
4089
4090 Result = GET_OR_DISTINCT((IsDistinct ? DILocation::getDistinct (Context, line.Val, column
.Val, scope.Val, inlinedAt.Val) : DILocation::get (Context, line
.Val, column.Val, scope.Val, inlinedAt.Val))
4091 DILocation, (Context, line.Val, column.Val, scope.Val, inlinedAt.Val))(IsDistinct ? DILocation::getDistinct (Context, line.Val, column
.Val, scope.Val, inlinedAt.Val) : DILocation::get (Context, line
.Val, column.Val, scope.Val, inlinedAt.Val))
;
4092 return false;
4093}
4094
4095/// ParseGenericDINode:
4096/// ::= !GenericDINode(tag: 15, header: "...", operands: {...})
4097bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
4098#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4099 REQUIRED(tag, DwarfTagField, ); \
4100 OPTIONAL(header, MDStringField, ); \
4101 OPTIONAL(operands, MDFieldList, );
4102 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4103#undef VISIT_MD_FIELDS
4104
4105 Result = GET_OR_DISTINCT(GenericDINode,(IsDistinct ? GenericDINode::getDistinct (Context, tag.Val, header
.Val, operands.Val) : GenericDINode::get (Context, tag.Val, header
.Val, operands.Val))
4106 (Context, tag.Val, header.Val, operands.Val))(IsDistinct ? GenericDINode::getDistinct (Context, tag.Val, header
.Val, operands.Val) : GenericDINode::get (Context, tag.Val, header
.Val, operands.Val))
;
4107 return false;
4108}
4109
4110/// ParseDISubrange:
4111/// ::= !DISubrange(count: 30, lowerBound: 2)
4112/// ::= !DISubrange(count: !node, lowerBound: 2)
4113bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
4114#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4115 REQUIRED(count, MDSignedOrMDField, (-1, -1, INT64_MAX(9223372036854775807L), false)); \
4116 OPTIONAL(lowerBound, MDSignedField, );
4117 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4118#undef VISIT_MD_FIELDS
4119
4120 if (count.isMDSignedField())
4121 Result = GET_OR_DISTINCT((IsDistinct ? DISubrange::getDistinct (Context, count.getMDSignedValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDSignedValue
(), lowerBound.Val))
4122 DISubrange, (Context, count.getMDSignedValue(), lowerBound.Val))(IsDistinct ? DISubrange::getDistinct (Context, count.getMDSignedValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDSignedValue
(), lowerBound.Val))
;
4123 else if (count.isMDField())
4124 Result = GET_OR_DISTINCT((IsDistinct ? DISubrange::getDistinct (Context, count.getMDFieldValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDFieldValue
(), lowerBound.Val))
4125 DISubrange, (Context, count.getMDFieldValue(), lowerBound.Val))(IsDistinct ? DISubrange::getDistinct (Context, count.getMDFieldValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDFieldValue
(), lowerBound.Val))
;
4126 else
4127 return true;
4128
4129 return false;
4130}
4131
4132/// ParseDIEnumerator:
4133/// ::= !DIEnumerator(value: 30, isUnsigned: true, name: "SomeKind")
4134bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
4135#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4136 REQUIRED(name, MDStringField, ); \
4137 REQUIRED(value, MDSignedOrUnsignedField, ); \
4138 OPTIONAL(isUnsigned, MDBoolField, (false));
4139 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4140#undef VISIT_MD_FIELDS
4141
4142 if (isUnsigned.Val && value.isMDSignedField())
4143 return TokError("unsigned enumerator with negative value");
4144
4145 int64_t Value = value.isMDSignedField()
4146 ? value.getMDSignedValue()
4147 : static_cast<int64_t>(value.getMDUnsignedValue());
4148 Result =
4149 GET_OR_DISTINCT(DIEnumerator, (Context, Value, isUnsigned.Val, name.Val))(IsDistinct ? DIEnumerator::getDistinct (Context, Value, isUnsigned
.Val, name.Val) : DIEnumerator::get (Context, Value, isUnsigned
.Val, name.Val))
;
4150
4151 return false;
4152}
4153
4154/// ParseDIBasicType:
4155/// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
4156bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
4157#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4158 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
4159 OPTIONAL(name, MDStringField, ); \
4160 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4161 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4162 OPTIONAL(encoding, DwarfAttEncodingField, );
4163 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4164#undef VISIT_MD_FIELDS
4165
4166 Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,(IsDistinct ? DIBasicType::getDistinct (Context, tag.Val, name
.Val, size.Val, align.Val, encoding.Val) : DIBasicType::get (
Context, tag.Val, name.Val, size.Val, align.Val, encoding.Val
))
4167 align.Val, encoding.Val))(IsDistinct ? DIBasicType::getDistinct (Context, tag.Val, name
.Val, size.Val, align.Val, encoding.Val) : DIBasicType::get (
Context, tag.Val, name.Val, size.Val, align.Val, encoding.Val
))
;
4168 return false;
4169}
4170
4171/// ParseDIDerivedType:
4172/// ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
4173/// line: 7, scope: !1, baseType: !2, size: 32,
4174/// align: 32, offset: 0, flags: 0, extraData: !3,
4175/// dwarfAddressSpace: 3)
4176bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
4177#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4178 REQUIRED(tag, DwarfTagField, ); \
4179 OPTIONAL(name, MDStringField, ); \
4180 OPTIONAL(file, MDField, ); \
4181 OPTIONAL(line, LineField, ); \
4182 OPTIONAL(scope, MDField, ); \
4183 REQUIRED(baseType, MDField, ); \
4184 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4185 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4186 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4187 OPTIONAL(flags, DIFlagField, ); \
4188 OPTIONAL(extraData, MDField, ); \
4189 OPTIONAL(dwarfAddressSpace, MDUnsignedField, (UINT32_MAX(4294967295U), UINT32_MAX(4294967295U)));
4190 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4191#undef VISIT_MD_FIELDS
4192
4193 Optional<unsigned> DWARFAddressSpace;
4194 if (dwarfAddressSpace.Val != UINT32_MAX(4294967295U))
4195 DWARFAddressSpace = dwarfAddressSpace.Val;
4196
4197 Result = GET_OR_DISTINCT(DIDerivedType,(IsDistinct ? DIDerivedType::getDistinct (Context, tag.Val, name
.Val, file.Val, line.Val, scope.Val, baseType.Val, size.Val, align
.Val, offset.Val, DWARFAddressSpace, flags.Val, extraData.Val
) : DIDerivedType::get (Context, tag.Val, name.Val, file.Val,
line.Val, scope.Val, baseType.Val, size.Val, align.Val, offset
.Val, DWARFAddressSpace, flags.Val, extraData.Val))
4198 (Context, tag.Val, name.Val, file.Val, line.Val,(IsDistinct ? DIDerivedType::getDistinct (Context, tag.Val, name
.Val, file.Val, line.Val, scope.Val, baseType.Val, size.Val, align
.Val, offset.Val, DWARFAddressSpace, flags.Val, extraData.Val
) : DIDerivedType::get (Context, tag.Val, name.Val, file.Val,
line.Val, scope.Val, baseType.Val, size.Val, align.Val, offset
.Val, DWARFAddressSpace, flags.Val, extraData.Val))
4199 scope.Val, baseType.Val, size.Val, align.Val,(IsDistinct ? DIDerivedType::getDistinct (Context, tag.Val, name
.Val, file.Val, line.Val, scope.Val, baseType.Val, size.Val, align
.Val, offset.Val, DWARFAddressSpace, flags.Val, extraData.Val
) : DIDerivedType::get (Context, tag.Val, name.Val, file.Val,
line.Val, scope.Val, baseType.Val, size.Val, align.Val, offset
.Val, DWARFAddressSpace, flags.Val, extraData.Val))
4200 offset.Val, DWARFAddressSpace, flags.Val,(IsDistinct ? DIDerivedType::getDistinct (Context, tag.Val, name
.Val, file.Val, line.Val, scope.Val, baseType.Val, size.Val, align
.Val, offset.Val, DWARFAddressSpace, flags.Val, extraData.Val
) : DIDerivedType::get (Context, tag.Val, name.Val, file.Val,
line.Val, scope.Val, baseType.Val, size.Val, align.Val, offset
.Val, DWARFAddressSpace, flags.Val, extraData.Val))
4201 extraData.Val))(IsDistinct ? DIDerivedType::getDistinct (Context, tag.Val, name
.Val, file.Val, line.Val, scope.Val, baseType.Val, size.Val, align
.Val, offset.Val, DWARFAddressSpace, flags.Val, extraData.Val
) : DIDerivedType::get (Context, tag.Val, name.Val, file.Val,
line.Val, scope.Val, baseType.Val, size.Val, align.Val, offset
.Val, DWARFAddressSpace, flags.Val, extraData.Val))
;
4202 return false;
4203}
4204
4205bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
4206#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4207 REQUIRED(tag, DwarfTagField, ); \
4208 OPTIONAL(name, MDStringField, ); \
4209 OPTIONAL(file, MDField, ); \
4210 OPTIONAL(line, LineField, ); \
4211 OPTIONAL(scope, MDField, ); \
4212 OPTIONAL(baseType, MDField, ); \
4213 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4214 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4215 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4216 OPTIONAL(flags, DIFlagField, ); \
4217 OPTIONAL(elements, MDField, ); \
4218 OPTIONAL(runtimeLang, DwarfLangField, ); \
4219 OPTIONAL(vtableHolder, MDField, ); \
4220 OPTIONAL(templateParams, MDField, ); \
4221 OPTIONAL(identifier, MDStringField, ); \
4222 OPTIONAL(discriminator, MDField, );
4223 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4224#undef VISIT_MD_FIELDS
4225
4226 // If this has an identifier try to build an ODR type.
4227 if (identifier.Val)
4228 if (auto *CT = DICompositeType::buildODRType(
4229 Context, *identifier.Val, tag.Val, name.Val, file.Val, line.Val,
4230 scope.Val, baseType.Val, size.Val, align.Val, offset.Val, flags.Val,
4231 elements.Val, runtimeLang.Val, vtableHolder.Val,
4232 templateParams.Val, discriminator.Val)) {
4233 Result = CT;
4234 return false;
4235 }
4236
4237 // Create a new node, and save it in the context if it belongs in the type
4238 // map.
4239 Result = GET_OR_DISTINCT((IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
4240 DICompositeType,(IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
4241 (Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,(IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
4242 size.Val, align.Val, offset.Val, flags.Val, elements.Val,(IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
4243 runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val,(IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
4244 discriminator.Val))(IsDistinct ? DICompositeType::getDistinct (Context, tag.Val,
name.Val, file.Val, line.Val, scope.Val, baseType.Val, size.
Val, align.Val, offset.Val, flags.Val, elements.Val, runtimeLang
.Val, vtableHolder.Val, templateParams.Val, identifier.Val, discriminator
.Val) : DICompositeType::get (Context, tag.Val, name.Val, file
.Val, line.Val, scope.Val, baseType.Val, size.Val, align.Val,
offset.Val, flags.Val, elements.Val, runtimeLang.Val, vtableHolder
.Val, templateParams.Val, identifier.Val, discriminator.Val))
;
4245 return false;
4246}
4247
4248bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
4249#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4250 OPTIONAL(flags, DIFlagField, ); \
4251 OPTIONAL(cc, DwarfCCField, ); \
4252 REQUIRED(types, MDField, );
4253 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4254#undef VISIT_MD_FIELDS
4255
4256 Result = GET_OR_DISTINCT(DISubroutineType,(IsDistinct ? DISubroutineType::getDistinct (Context, flags.Val
, cc.Val, types.Val) : DISubroutineType::get (Context, flags.
Val, cc.Val, types.Val))
4257 (Context, flags.Val, cc.Val, types.Val))(IsDistinct ? DISubroutineType::getDistinct (Context, flags.Val
, cc.Val, types.Val) : DISubroutineType::get (Context, flags.
Val, cc.Val, types.Val))
;
4258 return false;
4259}
4260
4261/// ParseDIFileType:
4262/// ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir",
4263/// checksumkind: CSK_MD5,
4264/// checksum: "000102030405060708090a0b0c0d0e0f",
4265/// source: "source file contents")
4266bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
4267 // The default constructed value for checksumkind is required, but will never
4268 // be used, as the parser checks if the field was actually Seen before using
4269 // the Val.
4270#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4271 REQUIRED(filename, MDStringField, ); \
4272 REQUIRED(directory, MDStringField, ); \
4273 OPTIONAL(checksumkind, ChecksumKindField, (DIFile::CSK_MD5)); \
4274 OPTIONAL(checksum, MDStringField, ); \
4275 OPTIONAL(source, MDStringField, );
4276 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4277#undef VISIT_MD_FIELDS
4278
4279 Optional<DIFile::ChecksumInfo<MDString *>> OptChecksum;
4280 if (checksumkind.Seen && checksum.Seen)
4281 OptChecksum.emplace(checksumkind.Val, checksum.Val);
4282 else if (checksumkind.Seen || checksum.Seen)
4283 return Lex.Error("'checksumkind' and 'checksum' must be provided together");
4284
4285 Optional<MDString *> OptSource;
4286 if (source.Seen)
4287 OptSource = source.Val;
4288 Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val,(IsDistinct ? DIFile::getDistinct (Context, filename.Val, directory
.Val, OptChecksum, OptSource) : DIFile::get (Context, filename
.Val, directory.Val, OptChecksum, OptSource))
4289 OptChecksum, OptSource))(IsDistinct ? DIFile::getDistinct (Context, filename.Val, directory
.Val, OptChecksum, OptSource) : DIFile::get (Context, filename
.Val, directory.Val, OptChecksum, OptSource))
;
4290 return false;
4291}
4292
4293/// ParseDICompileUnit:
4294/// ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
4295/// isOptimized: true, flags: "-O2", runtimeVersion: 1,
4296/// splitDebugFilename: "abc.debug",
4297/// emissionKind: FullDebug, enums: !1, retainedTypes: !2,
4298/// globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd)
4299bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
4300 if (!IsDistinct)
4301 return Lex.Error("missing 'distinct', required for !DICompileUnit");
4302
4303#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4304 REQUIRED(language, DwarfLangField, ); \
4305 REQUIRED(file, MDField, (/* AllowNull */ false)); \
4306 OPTIONAL(producer, MDStringField, ); \
4307 OPTIONAL(isOptimized, MDBoolField, ); \
4308 OPTIONAL(flags, MDStringField, ); \
4309 OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4310 OPTIONAL(splitDebugFilename, MDStringField, ); \
4311 OPTIONAL(emissionKind, EmissionKindField, ); \
4312 OPTIONAL(enums, MDField, ); \
4313 OPTIONAL(retainedTypes, MDField, ); \
4314 OPTIONAL(globals, MDField, ); \
4315 OPTIONAL(imports, MDField, ); \
4316 OPTIONAL(macros, MDField, ); \
4317 OPTIONAL(dwoId, MDUnsignedField, ); \
4318 OPTIONAL(splitDebugInlining, MDBoolField, = true); \
4319 OPTIONAL(debugInfoForProfiling, MDBoolField, = false); \
4320 OPTIONAL(gnuPubnames, MDBoolField, = false);
4321 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4322#undef VISIT_MD_FIELDS
4323
4324 Result = DICompileUnit::getDistinct(
4325 Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
4326 runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
4327 retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
4328 splitDebugInlining.Val, debugInfoForProfiling.Val, gnuPubnames.Val);
4329 return false;
4330}
4331
4332/// ParseDISubprogram:
4333/// ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
4334/// file: !1, line: 7, type: !2, isLocal: false,
4335/// isDefinition: true, scopeLine: 8, containingType: !3,
4336/// virtuality: DW_VIRTUALTIY_pure_virtual,
4337/// virtualIndex: 10, thisAdjustment: 4, flags: 11,
4338/// isOptimized: false, templateParams: !4, declaration: !5,
4339/// variables: !6, thrownTypes: !7)
4340bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
4341 auto Loc = Lex.getLoc();
4342#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4343 OPTIONAL(scope, MDField, ); \
4344 OPTIONAL(name, MDStringField, ); \
4345 OPTIONAL(linkageName, MDStringField, ); \
4346 OPTIONAL(file, MDField, ); \
4347 OPTIONAL(line, LineField, ); \
4348 OPTIONAL(type, MDField, ); \
4349 OPTIONAL(isLocal, MDBoolField, ); \
4350 OPTIONAL(isDefinition, MDBoolField, (true)); \
4351 OPTIONAL(scopeLine, LineField, ); \
4352 OPTIONAL(containingType, MDField, ); \
4353 OPTIONAL(virtuality, DwarfVirtualityField, ); \
4354 OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4355 OPTIONAL(thisAdjustment, MDSignedField, (0, INT32_MIN(-2147483647-1), INT32_MAX(2147483647))); \
4356 OPTIONAL(flags, DIFlagField, ); \
4357 OPTIONAL(isOptimized, MDBoolField, ); \
4358 OPTIONAL(unit, MDField, ); \
4359 OPTIONAL(templateParams, MDField, ); \
4360 OPTIONAL(declaration, MDField, ); \
4361 OPTIONAL(variables, MDField, ); \
4362 OPTIONAL(thrownTypes, MDField, );
4363 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4364#undef VISIT_MD_FIELDS
4365
4366 if (isDefinition.Val && !IsDistinct)
4367 return Lex.Error(
4368 Loc,
4369 "missing 'distinct', required for !DISubprogram when 'isDefinition'");
4370
4371 Result = GET_OR_DISTINCT((IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4372 DISubprogram,(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4373 (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4374 type.Val, isLocal.Val, isDefinition.Val, scopeLine.Val,(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4375 containingType.Val, virtuality.Val, virtualIndex.Val, thisAdjustment.Val,(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4376 flags.Val, isOptimized.Val, unit.Val, templateParams.Val,(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
4377 declaration.Val, variables.Val, thrownTypes.Val))(IsDistinct ? DISubprogram::getDistinct (Context, scope.Val, name
.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal.
Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val) : DISubprogram::get (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, scopeLine.Val, containingType.Val, virtuality
.Val, virtualIndex.Val, thisAdjustment.Val, flags.Val, isOptimized
.Val, unit.Val, templateParams.Val, declaration.Val, variables
.Val, thrownTypes.Val))
;
4378 return false;
4379}
4380
4381/// ParseDILexicalBlock:
4382/// ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
4383bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
4384#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4385 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4386 OPTIONAL(file, MDField, ); \
4387 OPTIONAL(line, LineField, ); \
4388 OPTIONAL(column, ColumnField, );
4389 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4390#undef VISIT_MD_FIELDS
4391
4392 Result = GET_OR_DISTINCT((IsDistinct ? DILexicalBlock::getDistinct (Context, scope.Val
, file.Val, line.Val, column.Val) : DILexicalBlock::get (Context
, scope.Val, file.Val, line.Val, column.Val))
4393 DILexicalBlock, (Context, scope.Val, file.Val, line.Val, column.Val))(IsDistinct ? DILexicalBlock::getDistinct (Context, scope.Val
, file.Val, line.Val, column.Val) : DILexicalBlock::get (Context
, scope.Val, file.Val, line.Val, column.Val))
;
4394 return false;
4395}
4396
4397/// ParseDILexicalBlockFile:
4398/// ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
4399bool LLParser::ParseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
4400#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4401 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4402 OPTIONAL(file, MDField, ); \
4403 REQUIRED(discriminator, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4404 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4405#undef VISIT_MD_FIELDS
4406
4407 Result = GET_OR_DISTINCT(DILexicalBlockFile,(IsDistinct ? DILexicalBlockFile::getDistinct (Context, scope
.Val, file.Val, discriminator.Val) : DILexicalBlockFile::get (
Context, scope.Val, file.Val, discriminator.Val))
4408 (Context, scope.Val, file.Val, discriminator.Val))(IsDistinct ? DILexicalBlockFile::getDistinct (Context, scope
.Val, file.Val, discriminator.Val) : DILexicalBlockFile::get (
Context, scope.Val, file.Val, discriminator.Val))
;
4409 return false;
4410}
4411
4412/// ParseDINamespace:
4413/// ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
4414bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
4415#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4416 REQUIRED(scope, MDField, ); \
4417 OPTIONAL(name, MDStringField, ); \
4418 OPTIONAL(exportSymbols, MDBoolField, );
4419 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4420#undef VISIT_MD_FIELDS
4421
4422 Result = GET_OR_DISTINCT(DINamespace,(IsDistinct ? DINamespace::getDistinct (Context, scope.Val, name
.Val, exportSymbols.Val) : DINamespace::get (Context, scope.Val
, name.Val, exportSymbols.Val))
4423 (Context, scope.Val, name.Val, exportSymbols.Val))(IsDistinct ? DINamespace::getDistinct (Context, scope.Val, name
.Val, exportSymbols.Val) : DINamespace::get (Context, scope.Val
, name.Val, exportSymbols.Val))
;
4424 return false;
4425}
4426
4427/// ParseDIMacro:
4428/// ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value: "SomeValue")
4429bool LLParser::ParseDIMacro(MDNode *&Result, bool IsDistinct) {
4430#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4431 REQUIRED(type, DwarfMacinfoTypeField, ); \
4432 OPTIONAL(line, LineField, ); \
4433 REQUIRED(name, MDStringField, ); \
4434 OPTIONAL(value, MDStringField, );
4435 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4436#undef VISIT_MD_FIELDS
4437
4438 Result = GET_OR_DISTINCT(DIMacro,(IsDistinct ? DIMacro::getDistinct (Context, type.Val, line.Val
, name.Val, value.Val) : DIMacro::get (Context, type.Val, line
.Val, name.Val, value.Val))
4439 (Context, type.Val, line.Val, name.Val, value.Val))(IsDistinct ? DIMacro::getDistinct (Context, type.Val, line.Val
, name.Val, value.Val) : DIMacro::get (Context, type.Val, line
.Val, name.Val, value.Val))
;
4440 return false;
4441}
4442
4443/// ParseDIMacroFile:
4444/// ::= !DIMacroFile(line: 9, file: !2, nodes: !3)
4445bool LLParser::ParseDIMacroFile(MDNode *&Result, bool IsDistinct) {
4446#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4447 OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file)); \
4448 OPTIONAL(line, LineField, ); \
4449 REQUIRED(file, MDField, ); \
4450 OPTIONAL(nodes, MDField, );
4451 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4452#undef VISIT_MD_FIELDS
4453
4454 Result = GET_OR_DISTINCT(DIMacroFile,(IsDistinct ? DIMacroFile::getDistinct (Context, type.Val, line
.Val, file.Val, nodes.Val) : DIMacroFile::get (Context, type.
Val, line.Val, file.Val, nodes.Val))
4455 (Context, type.Val, line.Val, file.Val, nodes.Val))(IsDistinct ? DIMacroFile::getDistinct (Context, type.Val, line
.Val, file.Val, nodes.Val) : DIMacroFile::get (Context, type.
Val, line.Val, file.Val, nodes.Val))
;
4456 return false;
4457}
4458
4459/// ParseDIModule:
4460/// ::= !DIModule(scope: !0, name: "SomeModule", configMacros: "-DNDEBUG",
4461/// includePath: "/usr/include", isysroot: "/")
4462bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
4463#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4464 REQUIRED(scope, MDField, ); \
4465 REQUIRED(name, MDStringField, ); \
4466 OPTIONAL(configMacros, MDStringField, ); \
4467 OPTIONAL(includePath, MDStringField, ); \
4468 OPTIONAL(isysroot, MDStringField, );
4469 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4470#undef VISIT_MD_FIELDS
4471
4472 Result = GET_OR_DISTINCT(DIModule, (Context, scope.Val, name.Val,(IsDistinct ? DIModule::getDistinct (Context, scope.Val, name
.Val, configMacros.Val, includePath.Val, isysroot.Val) : DIModule
::get (Context, scope.Val, name.Val, configMacros.Val, includePath
.Val, isysroot.Val))
4473 configMacros.Val, includePath.Val, isysroot.Val))(IsDistinct ? DIModule::getDistinct (Context, scope.Val, name
.Val, configMacros.Val, includePath.Val, isysroot.Val) : DIModule
::get (Context, scope.Val, name.Val, configMacros.Val, includePath
.Val, isysroot.Val))
;
4474 return false;
4475}
4476
4477/// ParseDITemplateTypeParameter:
4478/// ::= !DITemplateTypeParameter(name: "Ty", type: !1)
4479bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
4480#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4481 OPTIONAL(name, MDStringField, ); \
4482 REQUIRED(type, MDField, );
4483 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4484#undef VISIT_MD_FIELDS
4485
4486 Result =
4487 GET_OR_DISTINCT(DITemplateTypeParameter, (Context, name.Val, type.Val))(IsDistinct ? DITemplateTypeParameter::getDistinct (Context, name
.Val, type.Val) : DITemplateTypeParameter::get (Context, name
.Val, type.Val))
;
4488 return false;
4489}
4490
4491/// ParseDITemplateValueParameter:
4492/// ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
4493/// name: "V", type: !1, value: i32 7)
4494bool LLParser::ParseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
4495#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4496 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter)); \
4497 OPTIONAL(name, MDStringField, ); \
4498 OPTIONAL(type, MDField, ); \
4499 REQUIRED(value, MDField, );
4500 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4501#undef VISIT_MD_FIELDS
4502
4503 Result = GET_OR_DISTINCT(DITemplateValueParameter,(IsDistinct ? DITemplateValueParameter::getDistinct (Context,
tag.Val, name.Val, type.Val, value.Val) : DITemplateValueParameter
::get (Context, tag.Val, name.Val, type.Val, value.Val))
4504 (Context, tag.Val, name.Val, type.Val, value.Val))(IsDistinct ? DITemplateValueParameter::getDistinct (Context,
tag.Val, name.Val, type.Val, value.Val) : DITemplateValueParameter
::get (Context, tag.Val, name.Val, type.Val, value.Val))
;
4505 return false;
4506}
4507
4508/// ParseDIGlobalVariable:
4509/// ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
4510/// file: !1, line: 7, type: !2, isLocal: false,
4511/// isDefinition: true, declaration: !3, align: 8)
4512bool LLParser::ParseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
4513#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4514 REQUIRED(name, MDStringField, (/* AllowEmpty */ false)); \
4515 OPTIONAL(scope, MDField, ); \
4516 OPTIONAL(linkageName, MDStringField, ); \
4517 OPTIONAL(file, MDField, ); \
4518 OPTIONAL(line, LineField, ); \
4519 OPTIONAL(type, MDField, ); \
4520 OPTIONAL(isLocal, MDBoolField, ); \
4521 OPTIONAL(isDefinition, MDBoolField, (true)); \
4522 OPTIONAL(declaration, MDField, ); \
4523 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4524 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4525#undef VISIT_MD_FIELDS
4526
4527 Result = GET_OR_DISTINCT(DIGlobalVariable,(IsDistinct ? DIGlobalVariable::getDistinct (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, declaration.Val, align.Val) : DIGlobalVariable
::get (Context, scope.Val, name.Val, linkageName.Val, file.Val
, line.Val, type.Val, isLocal.Val, isDefinition.Val, declaration
.Val, align.Val))
4528 (Context, scope.Val, name.Val, linkageName.Val,(IsDistinct ? DIGlobalVariable::getDistinct (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, declaration.Val, align.Val) : DIGlobalVariable
::get (Context, scope.Val, name.Val, linkageName.Val, file.Val
, line.Val, type.Val, isLocal.Val, isDefinition.Val, declaration
.Val, align.Val))
4529 file.Val, line.Val, type.Val, isLocal.Val,(IsDistinct ? DIGlobalVariable::getDistinct (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, declaration.Val, align.Val) : DIGlobalVariable
::get (Context, scope.Val, name.Val, linkageName.Val, file.Val
, line.Val, type.Val, isLocal.Val, isDefinition.Val, declaration
.Val, align.Val))
4530 isDefinition.Val, declaration.Val, align.Val))(IsDistinct ? DIGlobalVariable::getDistinct (Context, scope.Val
, name.Val, linkageName.Val, file.Val, line.Val, type.Val, isLocal
.Val, isDefinition.Val, declaration.Val, align.Val) : DIGlobalVariable
::get (Context, scope.Val, name.Val, linkageName.Val, file.Val
, line.Val, type.Val, isLocal.Val, isDefinition.Val, declaration
.Val, align.Val))
;
4531 return false;
4532}
4533
4534/// ParseDILocalVariable:
4535/// ::= !DILocalVariable(arg: 7, scope: !0, name: "foo",
4536/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
4537/// align: 8)
4538/// ::= !DILocalVariable(scope: !0, name: "foo",
4539/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
4540/// align: 8)
4541bool LLParser::ParseDILocalVariable(MDNode *&Result, bool IsDistinct) {
4542#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4543 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4544 OPTIONAL(name, MDStringField, ); \
4545 OPTIONAL(arg, MDUnsignedField, (0, UINT16_MAX(65535))); \
4546 OPTIONAL(file, MDField, ); \
4547 OPTIONAL(line, LineField, ); \
4548 OPTIONAL(type, MDField, ); \
4549 OPTIONAL(flags, DIFlagField, ); \
4550 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4551 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4552#undef VISIT_MD_FIELDS
4553
4554 Result = GET_OR_DISTINCT(DILocalVariable,(IsDistinct ? DILocalVariable::getDistinct (Context, scope.Val
, name.Val, file.Val, line.Val, type.Val, arg.Val, flags.Val,
align.Val) : DILocalVariable::get (Context, scope.Val, name.
Val, file.Val, line.Val, type.Val, arg.Val, flags.Val, align.
Val))
4555 (Context, scope.Val, name.Val, file.Val, line.Val,(IsDistinct ? DILocalVariable::getDistinct (Context, scope.Val
, name.Val, file.Val, line.Val, type.Val, arg.Val, flags.Val,
align.Val) : DILocalVariable::get (Context, scope.Val, name.
Val, file.Val, line.Val, type.Val, arg.Val, flags.Val, align.
Val))
4556 type.Val, arg.Val, flags.Val, align.Val))(IsDistinct ? DILocalVariable::getDistinct (Context, scope.Val
, name.Val, file.Val, line.Val, type.Val, arg.Val, flags.Val,
align.Val) : DILocalVariable::get (Context, scope.Val, name.
Val, file.Val, line.Val, type.Val, arg.Val, flags.Val, align.
Val))
;
4557 return false;
4558}
4559
4560/// ParseDIExpression:
4561/// ::= !DIExpression(0, 7, -1)
4562bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
4563 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name")(static_cast <bool> (Lex.getKind() == lltok::MetadataVar
&& "Expected metadata type name") ? void (0) : __assert_fail
("Lex.getKind() == lltok::MetadataVar && \"Expected metadata type name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4563, __extension__ __PRETTY_FUNCTION__))
;
4564 Lex.Lex();
4565
4566 if (ParseToken(lltok::lparen, "expected '(' here"))
4567 return true;
4568
4569 SmallVector<uint64_t, 8> Elements;
4570 if (Lex.getKind() != lltok::rparen)
4571 do {
4572 if (Lex.getKind() == lltok::DwarfOp) {
4573 if (unsigned Op = dwarf::getOperationEncoding(Lex.getStrVal())) {
4574 Lex.Lex();
4575 Elements.push_back(Op);
4576 continue;
4577 }
4578 return TokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
4579 }
4580
4581 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
4582 return TokError("expected unsigned integer");
4583
4584 auto &U = Lex.getAPSIntVal();
4585 if (U.ugt(UINT64_MAX(18446744073709551615UL)))
4586 return TokError("element too large, limit is " + Twine(UINT64_MAX(18446744073709551615UL)));
4587 Elements.push_back(U.getZExtValue());
4588 Lex.Lex();
4589 } while (EatIfPresent(lltok::comma));
4590
4591 if (ParseToken(lltok::rparen, "expected ')' here"))
4592 return true;
4593
4594 Result = GET_OR_DISTINCT(DIExpression, (Context, Elements))(IsDistinct ? DIExpression::getDistinct (Context, Elements) :
DIExpression::get (Context, Elements))
;
4595 return false;
4596}
4597
4598/// ParseDIGlobalVariableExpression:
4599/// ::= !DIGlobalVariableExpression(var: !0, expr: !1)
4600bool LLParser::ParseDIGlobalVariableExpression(MDNode *&Result,
4601 bool IsDistinct) {
4602#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4603 REQUIRED(var, MDField, ); \
4604 REQUIRED(expr, MDField, );
4605 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4606#undef VISIT_MD_FIELDS
4607
4608 Result =
4609 GET_OR_DISTINCT(DIGlobalVariableExpression, (Context, var.Val, expr.Val))(IsDistinct ? DIGlobalVariableExpression::getDistinct (Context
, var.Val, expr.Val) : DIGlobalVariableExpression::get (Context
, var.Val, expr.Val))
;
4610 return false;
4611}
4612
4613/// ParseDIObjCProperty:
4614/// ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
4615/// getter: "getFoo", attributes: 7, type: !2)
4616bool LLParser::ParseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
4617#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4618 OPTIONAL(name, MDStringField, ); \
4619 OPTIONAL(file, MDField, ); \
4620 OPTIONAL(line, LineField, ); \
4621 OPTIONAL(setter, MDStringField, ); \
4622 OPTIONAL(getter, MDStringField, ); \
4623 OPTIONAL(attributes, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4624 OPTIONAL(type, MDField, );
4625 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4626#undef VISIT_MD_FIELDS
4627
4628 Result = GET_OR_DISTINCT(DIObjCProperty,(IsDistinct ? DIObjCProperty::getDistinct (Context, name.Val,
file.Val, line.Val, setter.Val, getter.Val, attributes.Val, type
.Val) : DIObjCProperty::get (Context, name.Val, file.Val, line
.Val, setter.Val, getter.Val, attributes.Val, type.Val))
4629 (Context, name.Val, file.Val, line.Val, setter.Val,(IsDistinct ? DIObjCProperty::getDistinct (Context, name.Val,
file.Val, line.Val, setter.Val, getter.Val, attributes.Val, type
.Val) : DIObjCProperty::get (Context, name.Val, file.Val, line
.Val, setter.Val, getter.Val, attributes.Val, type.Val))
4630 getter.Val, attributes.Val, type.Val))(IsDistinct ? DIObjCProperty::getDistinct (Context, name.Val,
file.Val, line.Val, setter.Val, getter.Val, attributes.Val, type
.Val) : DIObjCProperty::get (Context, name.Val, file.Val, line
.Val, setter.Val, getter.Val, attributes.Val, type.Val))
;
4631 return false;
4632}
4633
4634/// ParseDIImportedEntity:
4635/// ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
4636/// line: 7, name: "foo")
4637bool LLParser::ParseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
4638#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4639 REQUIRED(tag, DwarfTagField, ); \
4640 REQUIRED(scope, MDField, ); \
4641 OPTIONAL(entity, MDField, ); \
4642 OPTIONAL(file, MDField, ); \
4643 OPTIONAL(line, LineField, ); \
4644 OPTIONAL(name, MDStringField, );
4645 PARSE_MD_FIELDS()VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) do { LocTy ClosingLoc
; if (ParseMDFieldsImpl([&]() -> bool { VISIT_MD_FIELDS
(PARSE_MD_FIELD, PARSE_MD_FIELD) return TokError(Twine("invalid field '"
) + Lex.getStrVal() + "'"); }, ClosingLoc)) return true; VISIT_MD_FIELDS
(NOP_FIELD, REQUIRE_FIELD) } while (false)
;
4646#undef VISIT_MD_FIELDS
4647
4648 Result = GET_OR_DISTINCT((IsDistinct ? DIImportedEntity::getDistinct (Context, tag.Val
, scope.Val, entity.Val, file.Val, line.Val, name.Val) : DIImportedEntity
::get (Context, tag.Val, scope.Val, entity.Val, file.Val, line
.Val, name.Val))
4649 DIImportedEntity,(IsDistinct ? DIImportedEntity::getDistinct (Context, tag.Val
, scope.Val, entity.Val, file.Val, line.Val, name.Val) : DIImportedEntity
::get (Context, tag.Val, scope.Val, entity.Val, file.Val, line
.Val, name.Val))
4650 (Context, tag.Val, scope.Val, entity.Val, file.Val, line.Val, name.Val))(IsDistinct ? DIImportedEntity::getDistinct (Context, tag.Val
, scope.Val, entity.Val, file.Val, line.Val, name.Val) : DIImportedEntity
::get (Context, tag.Val, scope.Val, entity.Val, file.Val, line
.Val, name.Val))
;
4651 return false;
4652}
4653
4654#undef PARSE_MD_FIELD
4655#undef NOP_FIELD
4656#undef REQUIRE_FIELD
4657#undef DECLARE_FIELD
4658
4659/// ParseMetadataAsValue
4660/// ::= metadata i32 %local
4661/// ::= metadata i32 @global
4662/// ::= metadata i32 7
4663/// ::= metadata !0
4664/// ::= metadata !{...}
4665/// ::= metadata !"string"
4666bool LLParser::ParseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
4667 // Note: the type 'metadata' has already been parsed.
4668 Metadata *MD;
4669 if (ParseMetadata(MD, &PFS))
4670 return true;
4671
4672 V = MetadataAsValue::get(Context, MD);
4673 return false;
4674}
4675
4676/// ParseValueAsMetadata
4677/// ::= i32 %local
4678/// ::= i32 @global
4679/// ::= i32 7
4680bool LLParser::ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
4681 PerFunctionState *PFS) {
4682 Type *Ty;
4683 LocTy Loc;
4684 if (ParseType(Ty, TypeMsg, Loc))
4685 return true;
4686 if (Ty->isMetadataTy())
4687 return Error(Loc, "invalid metadata-value-metadata roundtrip");
4688
4689 Value *V;
4690 if (ParseValue(Ty, V, PFS))
4691 return true;
4692
4693 MD = ValueAsMetadata::get(V);
4694 return false;
4695}
4696
4697/// ParseMetadata
4698/// ::= i32 %local
4699/// ::= i32 @global
4700/// ::= i32 7
4701/// ::= !42
4702/// ::= !{...}
4703/// ::= !"string"
4704/// ::= !DILocation(...)
4705bool LLParser::ParseMetadata(Metadata *&MD, PerFunctionState *PFS) {
4706 if (Lex.getKind() == lltok::MetadataVar) {
4707 MDNode *N;
4708 if (ParseSpecializedMDNode(N))
4709 return true;
4710 MD = N;
4711 return false;
4712 }
4713
4714 // ValueAsMetadata:
4715 // <type> <value>
4716 if (Lex.getKind() != lltok::exclaim)
4717 return ParseValueAsMetadata(MD, "expected metadata operand", PFS);
4718
4719 // '!'.
4720 assert(Lex.getKind() == lltok::exclaim && "Expected '!' here")(static_cast <bool> (Lex.getKind() == lltok::exclaim &&
"Expected '!' here") ? void (0) : __assert_fail ("Lex.getKind() == lltok::exclaim && \"Expected '!' here\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4720, __extension__ __PRETTY_FUNCTION__))
;
4721 Lex.Lex();
4722
4723 // MDString:
4724 // ::= '!' STRINGCONSTANT
4725 if (Lex.getKind() == lltok::StringConstant) {
4726 MDString *S;
4727 if (ParseMDString(S))
4728 return true;
4729 MD = S;
4730 return false;
4731 }
4732
4733 // MDNode:
4734 // !{ ... }
4735 // !7
4736 MDNode *N;
4737 if (ParseMDNodeTail(N))
4738 return true;
4739 MD = N;
4740 return false;
4741}
4742
4743//===----------------------------------------------------------------------===//
4744// Function Parsing.
4745//===----------------------------------------------------------------------===//
4746
4747bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
4748 PerFunctionState *PFS, bool IsCall) {
4749 if (Ty->isFunctionTy())
4750 return Error(ID.Loc, "functions are not values, refer to them as pointers");
4751
4752 switch (ID.Kind) {
4753 case ValID::t_LocalID:
4754 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
4755 V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc, IsCall);
4756 return V == nullptr;
4757 case ValID::t_LocalName:
4758 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
4759 V = PFS->GetVal(ID.StrVal, Ty, ID.Loc, IsCall);
4760 return V == nullptr;
4761 case ValID::t_InlineAsm: {
4762 if (!ID.FTy || !InlineAsm::Verify(ID.FTy, ID.StrVal2))
4763 return Error(ID.Loc, "invalid type for inline asm constraint string");
4764 V = InlineAsm::get(ID.FTy, ID.StrVal, ID.StrVal2, ID.UIntVal & 1,
4765 (ID.UIntVal >> 1) & 1,
4766 (InlineAsm::AsmDialect(ID.UIntVal >> 2)));
4767 return false;
4768 }
4769 case ValID::t_GlobalName:
4770 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
4771 return V == nullptr;
4772 case ValID::t_GlobalID:
4773 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
4774 return V == nullptr;
4775 case ValID::t_APSInt:
4776 if (!Ty->isIntegerTy())
4777 return Error(ID.Loc, "integer constant must have integer type");
4778 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
4779 V = ConstantInt::get(Context, ID.APSIntVal);
4780 return false;
4781 case ValID::t_APFloat:
4782 if (!Ty->isFloatingPointTy() ||
4783 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
4784 return Error(ID.Loc, "floating point constant invalid for type");
4785
4786 // The lexer has no type info, so builds all half, float, and double FP
4787 // constants as double. Fix this here. Long double does not need this.
4788 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
4789 bool Ignored;
4790 if (Ty->isHalfTy())
4791 ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
4792 &Ignored);
4793 else if (Ty->isFloatTy())
4794 ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
4795 &Ignored);
4796 }
4797 V = ConstantFP::get(Context, ID.APFloatVal);
4798
4799 if (V->getType() != Ty)
4800 return Error(ID.Loc, "floating point constant does not have type '" +
4801 getTypeString(Ty) + "'");
4802
4803 return false;
4804 case ValID::t_Null:
4805 if (!Ty->isPointerTy())
4806 return Error(ID.Loc, "null must be a pointer type");
4807 V = ConstantPointerNull::get(cast<PointerType>(Ty));
4808 return false;
4809 case ValID::t_Undef:
4810 // FIXME: LabelTy should not be a first-class type.
4811 if (!Ty->isFirstClassType() || Ty->isLabelTy())
4812 return Error(ID.Loc, "invalid type for undef constant");
4813 V = UndefValue::get(Ty);
4814 return false;
4815 case ValID::t_EmptyArray:
4816 if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
4817 return Error(ID.Loc, "invalid empty array initializer");
4818 V = UndefValue::get(Ty);
4819 return false;
4820 case ValID::t_Zero:
4821 // FIXME: LabelTy should not be a first-class type.
4822 if (!Ty->isFirstClassType() || Ty->isLabelTy())
4823 return Error(ID.Loc, "invalid type for null constant");
4824 V = Constant::getNullValue(Ty);
4825 return false;
4826 case ValID::t_None:
4827 if (!Ty->isTokenTy())
4828 return Error(ID.Loc, "invalid type for none constant");
4829 V = Constant::getNullValue(Ty);
4830 return false;
4831 case ValID::t_Constant:
4832 if (ID.ConstantVal->getType() != Ty)
4833 return Error(ID.Loc, "constant expression type mismatch");
4834
4835 V = ID.ConstantVal;
4836 return false;
4837 case ValID::t_ConstantStruct:
4838 case ValID::t_PackedConstantStruct:
4839 if (StructType *ST = dyn_cast<StructType>(Ty)) {
4840 if (ST->getNumElements() != ID.UIntVal)
4841 return Error(ID.Loc,
4842 "initializer with struct type has wrong # elements");
4843 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
4844 return Error(ID.Loc, "packed'ness of initializer and type don't match");
4845
4846 // Verify that the elements are compatible with the structtype.
4847 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
4848 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
4849 return Error(ID.Loc, "element " + Twine(i) +
4850 " of struct initializer doesn't match struct element type");
4851
4852 V = ConstantStruct::get(
4853 ST, makeArrayRef(ID.ConstantStructElts.get(), ID.UIntVal));
4854 } else
4855 return Error(ID.Loc, "constant expression type mismatch");
4856 return false;
4857 }
4858 llvm_unreachable("Invalid ValID")::llvm::llvm_unreachable_internal("Invalid ValID", "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4858)
;
4859}
4860
4861bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
4862 C = nullptr;
4863 ValID ID;
4864 auto Loc = Lex.getLoc();
4865 if (ParseValID(ID, /*PFS=*/nullptr))
4866 return true;
4867 switch (ID.Kind) {
4868 case ValID::t_APSInt:
4869 case ValID::t_APFloat:
4870 case ValID::t_Undef:
4871 case ValID::t_Constant:
4872 case ValID::t_ConstantStruct:
4873 case ValID::t_PackedConstantStruct: {
4874 Value *V;
4875 if (ConvertValIDToValue(Ty, ID, V, /*PFS=*/nullptr, /*IsCall=*/false))
4876 return true;
4877 assert(isa<Constant>(V) && "Expected a constant value")(static_cast <bool> (isa<Constant>(V) && "Expected a constant value"
) ? void (0) : __assert_fail ("isa<Constant>(V) && \"Expected a constant value\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 4877, __extension__ __PRETTY_FUNCTION__))
;
4878 C = cast<Constant>(V);
4879 return false;
4880 }
4881 case ValID::t_Null:
4882 C = Constant::getNullValue(Ty);
4883 return false;
4884 default:
4885 return Error(Loc, "expected a constant value");
4886 }
4887}
4888
4889bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
4890 V = nullptr;
4891 ValID ID;
4892 return ParseValID(ID, PFS) ||
4893 ConvertValIDToValue(Ty, ID, V, PFS, /*IsCall=*/false);
4894}
4895
4896bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) {
4897 Type *Ty = nullptr;
4898 return ParseType(Ty) ||
4899 ParseValue(Ty, V, PFS);
4900}
4901
4902bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
4903 PerFunctionState &PFS) {
4904 Value *V;
4905 Loc = Lex.getLoc();
4906 if (ParseTypeAndValue(V, PFS)) return true;
4907 if (!isa<BasicBlock>(V))
4908 return Error(Loc, "expected a basic block");
4909 BB = cast<BasicBlock>(V);
4910 return false;
4911}
4912
4913/// FunctionHeader
4914/// ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
4915/// OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
4916/// '(' ArgList ')' OptFuncAttrs OptSection OptionalAlign OptGC
4917/// OptionalPrefix OptionalPrologue OptPersonalityFn
4918bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
4919 // Parse the linkage.
4920 LocTy LinkageLoc = Lex.getLoc();
4921 unsigned Linkage;
4922 unsigned Visibility;
4923 unsigned DLLStorageClass;
4924 bool DSOLocal;
4925 AttrBuilder RetAttrs;
4926 unsigned CC;
4927 bool HasLinkage;
4928 Type *RetType = nullptr;
4929 LocTy RetTypeLoc = Lex.getLoc();
4930 if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
4931 DSOLocal) ||
4932 ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
4933 ParseType(RetType, RetTypeLoc, true /*void allowed*/))
4934 return true;
4935
4936 // Verify that the linkage is ok.
4937 switch ((GlobalValue::LinkageTypes)Linkage) {
4938 case GlobalValue::ExternalLinkage:
4939 break; // always ok.
4940 case GlobalValue::ExternalWeakLinkage:
4941 if (isDefine)
4942 return Error(LinkageLoc, "invalid linkage for function definition");
4943 break;
4944 case GlobalValue::PrivateLinkage:
4945 case GlobalValue::InternalLinkage:
4946 case GlobalValue::AvailableExternallyLinkage:
4947 case GlobalValue::LinkOnceAnyLinkage:
4948 case GlobalValue::LinkOnceODRLinkage:
4949 case GlobalValue::WeakAnyLinkage:
4950 case GlobalValue::WeakODRLinkage:
4951 if (!isDefine)
4952 return Error(LinkageLoc, "invalid linkage for function declaration");
4953 break;
4954 case GlobalValue::AppendingLinkage:
4955 case GlobalValue::CommonLinkage:
4956 return Error(LinkageLoc, "invalid function linkage type");
4957 }
4958
4959 if (!isValidVisibilityForLinkage(Visibility, Linkage))
4960 return Error(LinkageLoc,
4961 "symbol with local linkage must have default visibility");
4962
4963 if (!FunctionType::isValidReturnType(RetType))
4964 return Error(RetTypeLoc, "invalid function return type");
4965
4966 LocTy NameLoc = Lex.getLoc();
4967
4968 std::string FunctionName;
4969 if (Lex.getKind() == lltok::GlobalVar) {
4970 FunctionName = Lex.getStrVal();
4971 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
4972 unsigned NameID = Lex.getUIntVal();
4973
4974 if (NameID != NumberedVals.size())
4975 return TokError("function expected to be numbered '%" +
4976 Twine(NumberedVals.size()) + "'");
4977 } else {
4978 return TokError("expected function name");
4979 }
4980
4981 Lex.Lex();
4982
4983 if (Lex.getKind() != lltok::lparen)
4984 return TokError("expected '(' in function argument list");
4985
4986 SmallVector<ArgInfo, 8> ArgList;
4987 bool isVarArg;
4988 AttrBuilder FuncAttrs;
4989 std::vector<unsigned> FwdRefAttrGrps;
4990 LocTy BuiltinLoc;
4991 std::string Section;
4992 unsigned Alignment;
4993 std::string GC;
4994 GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
4995 Constant *Prefix = nullptr;
4996 Constant *Prologue = nullptr;
4997 Constant *PersonalityFn = nullptr;
4998 Comdat *C;
4999
5000 if (ParseArgumentList(ArgList, isVarArg) ||
5001 ParseOptionalUnnamedAddr(UnnamedAddr) ||
5002 ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
5003 BuiltinLoc) ||
5004 (EatIfPresent(lltok::kw_section) &&
5005 ParseStringConstant(Section)) ||
5006 parseOptionalComdat(FunctionName, C) ||
5007 ParseOptionalAlignment(Alignment) ||
5008 (EatIfPresent(lltok::kw_gc) &&
5009 ParseStringConstant(GC)) ||
5010 (EatIfPresent(lltok::kw_prefix) &&
5011 ParseGlobalTypeAndValue(Prefix)) ||
5012 (EatIfPresent(lltok::kw_prologue) &&
5013 ParseGlobalTypeAndValue(Prologue)) ||
5014 (EatIfPresent(lltok::kw_personality) &&
5015 ParseGlobalTypeAndValue(PersonalityFn)))
5016 return true;
5017
5018 if (FuncAttrs.contains(Attribute::Builtin))
5019 return Error(BuiltinLoc, "'builtin' attribute not valid on function");
5020
5021 // If the alignment was parsed as an attribute, move to the alignment field.
5022 if (FuncAttrs.hasAlignmentAttr()) {
5023 Alignment = FuncAttrs.getAlignment();
5024 FuncAttrs.removeAttribute(Attribute::Alignment);
5025 }
5026
5027 // Okay, if we got here, the function is syntactically valid. Convert types
5028 // and do semantic checks.
5029 std::vector<Type*> ParamTypeList;
5030 SmallVector<AttributeSet, 8> Attrs;
5031
5032 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5033 ParamTypeList.push_back(ArgList[i].Ty);
5034 Attrs.push_back(ArgList[i].Attrs);
5035 }
5036
5037 AttributeList PAL =
5038 AttributeList::get(Context, AttributeSet::get(Context, FuncAttrs),
5039 AttributeSet::get(Context, RetAttrs), Attrs);
5040
5041 if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
5042 return Error(RetTypeLoc, "functions with 'sret' argument must return void");
5043
5044 FunctionType *FT =
5045 FunctionType::get(RetType, ParamTypeList, isVarArg);
5046 PointerType *PFT = PointerType::getUnqual(FT);
5047
5048 Fn = nullptr;
5049 if (!FunctionName.empty()) {
5050 // If this was a definition of a forward reference, remove the definition
5051 // from the forward reference table and fill in the forward ref.
5052 auto FRVI = ForwardRefVals.find(FunctionName);
5053 if (FRVI != ForwardRefVals.end()) {
5054 Fn = M->getFunction(FunctionName);
5055 if (!Fn)
5056 return Error(FRVI->second.second, "invalid forward reference to "
5057 "function as global value!");
5058 if (Fn->getType() != PFT)
5059 return Error(FRVI->second.second, "invalid forward reference to "
5060 "function '" + FunctionName + "' with wrong type!");
5061
5062 ForwardRefVals.erase(FRVI);
5063 } else if ((Fn = M->getFunction(FunctionName))) {
5064 // Reject redefinitions.
5065 return Error(NameLoc, "invalid redefinition of function '" +
5066 FunctionName + "'");
5067 } else if (M->getNamedValue(FunctionName)) {
5068 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
5069 }
5070
5071 } else {
5072 // If this is a definition of a forward referenced function, make sure the
5073 // types agree.
5074 auto I = ForwardRefValIDs.find(NumberedVals.size());
5075 if (I != ForwardRefValIDs.end()) {
5076 Fn = cast<Function>(I->second.first);
5077 if (Fn->getType() != PFT)
5078 return Error(NameLoc, "type of definition and forward reference of '@" +
5079 Twine(NumberedVals.size()) + "' disagree");
5080 ForwardRefValIDs.erase(I);
5081 }
5082 }
5083
5084 if (!Fn)
5085 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
5086 else // Move the forward-reference to the correct spot in the module.
5087 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
5088
5089 if (FunctionName.empty())
5090 NumberedVals.push_back(Fn);
5091
5092 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
5093 maybeSetDSOLocal(DSOLocal, *Fn);
5094 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
5095 Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
5096 Fn->setCallingConv(CC);
5097 Fn->setAttributes(PAL);
5098 Fn->setUnnamedAddr(UnnamedAddr);
5099 Fn->setAlignment(Alignment);
5100 Fn->setSection(Section);
5101 Fn->setComdat(C);
5102 Fn->setPersonalityFn(PersonalityFn);
5103 if (!GC.empty()) Fn->setGC(GC);
5104 Fn->setPrefixData(Prefix);
5105 Fn->setPrologueData(Prologue);
5106 ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
5107
5108 // Add all of the arguments we parsed to the function.
5109 Function::arg_iterator ArgIt = Fn->arg_begin();
5110 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
5111 // If the argument has a name, insert it into the argument symbol table.
5112 if (ArgList[i].Name.empty()) continue;
5113
5114 // Set the name, if it conflicted, it will be auto-renamed.
5115 ArgIt->setName(ArgList[i].Name);
5116
5117 if (ArgIt->getName() != ArgList[i].Name)
5118 return Error(ArgList[i].Loc, "redefinition of argument '%" +
5119 ArgList[i].Name + "'");
5120 }
5121
5122 if (isDefine)
5123 return false;
5124
5125 // Check the declaration has no block address forward references.
5126 ValID ID;
5127 if (FunctionName.empty()) {
5128 ID.Kind = ValID::t_GlobalID;
5129 ID.UIntVal = NumberedVals.size() - 1;
5130 } else {
5131 ID.Kind = ValID::t_GlobalName;
5132 ID.StrVal = FunctionName;
5133 }
5134 auto Blocks = ForwardRefBlockAddresses.find(ID);
5135 if (Blocks != ForwardRefBlockAddresses.end())
5136 return Error(Blocks->first.Loc,
5137 "cannot take blockaddress inside a declaration");
5138 return false;
5139}
5140
5141bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
5142 ValID ID;
5143 if (FunctionNumber == -1) {
5144 ID.Kind = ValID::t_GlobalName;
5145 ID.StrVal = F.getName();
5146 } else {
5147 ID.Kind = ValID::t_GlobalID;
5148 ID.UIntVal = FunctionNumber;
5149 }
5150
5151 auto Blocks = P.ForwardRefBlockAddresses.find(ID);
5152 if (Blocks == P.ForwardRefBlockAddresses.end())
5153 return false;
5154
5155 for (const auto &I : Blocks->second) {
5156 const ValID &BBID = I.first;
5157 GlobalValue *GV = I.second;
5158
5159 assert((BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) &&(static_cast <bool> ((BBID.Kind == ValID::t_LocalID || BBID
.Kind == ValID::t_LocalName) && "Expected local id or name"
) ? void (0) : __assert_fail ("(BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) && \"Expected local id or name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 5160, __extension__ __PRETTY_FUNCTION__))
5160 "Expected local id or name")(static_cast <bool> ((BBID.Kind == ValID::t_LocalID || BBID
.Kind == ValID::t_LocalName) && "Expected local id or name"
) ? void (0) : __assert_fail ("(BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) && \"Expected local id or name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 5160, __extension__ __PRETTY_FUNCTION__))
;
5161 BasicBlock *BB;
5162 if (BBID.Kind == ValID::t_LocalName)
5163 BB = GetBB(BBID.StrVal, BBID.Loc);
5164 else
5165 BB = GetBB(BBID.UIntVal, BBID.Loc);
5166 if (!BB)
5167 return P.Error(BBID.Loc, "referenced value is not a basic block");
5168
5169 GV->replaceAllUsesWith(BlockAddress::get(&F, BB));
5170 GV->eraseFromParent();
5171 }
5172
5173 P.ForwardRefBlockAddresses.erase(Blocks);
5174 return false;
5175}
5176
5177/// ParseFunctionBody
5178/// ::= '{' BasicBlock+ UseListOrderDirective* '}'
5179bool LLParser::ParseFunctionBody(Function &Fn) {
5180 if (Lex.getKind() != lltok::lbrace)
2
Assuming the condition is false
3
Taking false branch
5181 return TokError("expected '{' in function body");
5182 Lex.Lex(); // eat the {.
5183
5184 int FunctionNumber = -1;
5185 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
4
Assuming the condition is false
5
Taking false branch
5186
5187 PerFunctionState PFS(*this, Fn, FunctionNumber);
5188
5189 // Resolve block addresses and allow basic blocks to be forward-declared
5190 // within this function.
5191 if (PFS.resolveForwardRefBlockAddresses())
6
Assuming the condition is false
7
Taking false branch
5192 return true;
5193 SaveAndRestore<PerFunctionState *> ScopeExit(BlockAddressPFS, &PFS);
5194
5195 // We need at least one basic block.
5196 if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_uselistorder)
8
Assuming the condition is false
9
Assuming the condition is false
10
Taking false branch
5197 return TokError("function body requires at least one basic block");
5198
5199 while (Lex.getKind() != lltok::rbrace &&
11
Loop condition is true. Entering loop body
14
Loop condition is true. Entering loop body
17
Loop condition is true. Entering loop body
20
Loop condition is true. Entering loop body
5200 Lex.getKind() != lltok::kw_uselistorder)
5201 if (ParseBasicBlock(PFS)) return true;
12
Assuming the condition is false
13
Taking false branch
15
Assuming the condition is false
16
Taking false branch
18
Assuming the condition is false
19
Taking false branch
21
Calling 'LLParser::ParseBasicBlock'
5202
5203 while (Lex.getKind() != lltok::rbrace)
5204 if (ParseUseListOrder(&PFS))
5205 return true;
5206
5207 // Eat the }.
5208 Lex.Lex();
5209
5210 // Verify function is ok.
5211 return PFS.FinishFunction();
5212}
5213
5214/// ParseBasicBlock
5215/// ::= LabelStr? Instruction*
5216bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
5217 // If this basic block starts out with a name, remember it.
5218 std::string Name;
5219 LocTy NameLoc = Lex.getLoc();
5220 if (Lex.getKind() == lltok::LabelStr) {
22
Taking false branch
5221 Name = Lex.getStrVal();
5222 Lex.Lex();
5223 }
5224
5225 BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
5226 if (!BB)
23
Taking false branch
5227 return Error(NameLoc,
5228 "unable to create block named '" + Name + "'");
5229
5230 std::string NameStr;
5231
5232 // Parse the instructions in this block until we get a terminator.
5233 Instruction *Inst;
24
'Inst' declared without an initial value
5234 do {
5235 // This instruction may have three possibilities for a name: a) none
5236 // specified, b) name specified "%foo =", c) number specified: "%4 =".
5237 LocTy NameLoc = Lex.getLoc();
5238 int NameID = -1;
5239 NameStr = "";
5240
5241 if (Lex.getKind() == lltok::LocalVarID) {
25
Assuming the condition is false
26
Taking false branch
5242 NameID = Lex.getUIntVal();
5243 Lex.Lex();
5244 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
5245 return true;
5246 } else if (Lex.getKind() == lltok::LocalVar) {
27
Assuming the condition is false
28
Taking false branch
5247 NameStr = Lex.getStrVal();
5248 Lex.Lex();
5249 if (ParseToken(lltok::equal, "expected '=' after instruction name"))
5250 return true;
5251 }
5252
5253 switch (ParseInstruction(Inst, BB, PFS)) {
29
Calling 'LLParser::ParseInstruction'
56
Returning from 'LLParser::ParseInstruction'
57
Control jumps to 'case InstNormal:' at line 5256
5254 default: llvm_unreachable("Unknown ParseInstruction result!")::llvm::llvm_unreachable_internal("Unknown ParseInstruction result!"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/AsmParser/LLParser.cpp"
, 5254)
;
5255 case InstError: return true;
5256 case InstNormal:
5257 BB->getInstList().push_back(Inst);
58
1st function call argument is an uninitialized value
5258
5259 // With a normal result, we check to see if the instruction is followed by
5260 // a comma and metadata.
5261 if (EatIfPresent(lltok::comma))
5262 if (ParseInstructionMetadata(*Inst))
5263 return true;
5264 break;
5265 case InstExtraComma:
5266 BB->getInstList().push_back(Inst);
5267
5268 // If the instruction parser ate an extra comma at the end of it, it
5269 // *must* be followed by metadata.
5270 if (ParseInstructionMetadata(*Inst))
5271 return true;
5272 break;
5273 }
5274
5275 // Set the name on the instruction.
5276 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
5277 } while (!isa<TerminatorInst>(Inst));
5278
5279 return false;
5280}
5281
5282//===----------------------------------------------------------------------===//
5283// Instruction Parsing.
5284//===----------------------------------------------------------------------===//
5285
5286/// ParseInstruction - Parse one of the many different instructions.
5287///
5288int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
5289 PerFunctionState &PFS) {
5290 lltok::Kind Token = Lex.getKind();
30
Calling 'LLLexer::getKind'
31
Returning from 'LLLexer::getKind'
5291 if (Token == lltok::Eof)
32
Assuming 'Token' is not equal to Eof
33
Taking false branch
5292 return TokError("found end of file when expecting more instructions");
5293 LocTy Loc = Lex.getLoc();
34
Calling 'LLLexer::getLoc'
39
Returning from 'LLLexer::getLoc'
5294 unsigned KeywordVal = Lex.getUIntVal();
40
Calling 'LLLexer::getUIntVal'
41
Returning from 'LLLexer::getUIntVal'
5295 Lex.Lex(); // Eat the keyword.
42
Calling 'LLLexer::Lex'
43
Returning from 'LLLexer::Lex'
5296
5297 switch (Token) {
44
Control jumps to the 'default' case at line 5298
5298 default: return Error(Loc, "expected instruction opcode");
45
Calling constructor for 'Twine'
52
Returning from constructor for 'Twine'
53
Calling 'LLParser::Error'
54
Returning from 'LLParser::Error'
55
Returning without writing to 'Inst'
5299 // Terminator Instructions.
5300 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
5301 case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
5302 case lltok::kw_br: return ParseBr(Inst, PFS);
5303 case lltok::kw_switch: return ParseSwitch(Inst, PFS);
5304 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
5305 case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
5306 case lltok::kw_resume: return ParseResume(Inst, PFS);
5307 case lltok::kw_cleanupret: return ParseCleanupRet(Inst, PFS);
5308 case lltok::kw_catchret: return ParseCatchRet(Inst, PFS);
5309 case lltok::kw_catchswitch: return ParseCatchSwitch(Inst, PFS);
5310 case lltok::kw_catchpad: return ParseCatchPad(Inst, PFS);
5311 case lltok::kw_cleanuppad: return ParseCleanupPad(Inst, PFS);
5312 // Binary Operators.
5313 case lltok::kw_add:
5314 case lltok::kw_sub:
5315 case lltok::kw_mul:
5316 case lltok::kw_shl: {
5317 bool NUW = EatIfPresent(lltok::kw_nuw);
5318 bool NSW = EatIfPresent(lltok::kw_nsw);
5319 if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
5320
5321 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
5322
5323 if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
5324 if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
5325 return false;
5326 }
5327 case lltok::kw_fadd:
5328 case lltok::kw_fsub:
5329 case lltok::kw_fmul:
5330 case lltok::kw_fdiv:
5331 case lltok::kw_frem: {
5332 FastMathFlags FMF = EatFastMathFlagsIfPresent();
5333 int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2);
5334 if (Res != 0)
5335 return Res;
5336 if (FMF.any())
5337 Inst->setFastMathFlags(FMF);
5338 return 0;
5339 }
5340
5341 case lltok::kw_sdiv:
5342 case lltok::kw_udiv:
5343 case lltok::kw_lshr:
5344 case lltok::kw_ashr: {
5345 bool Exact = EatIfPresent(lltok::kw_exact);
5346
5347 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
5348 if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
5349 return false;
5350 }
5351
5352 case lltok::kw_urem:
5353 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
5354 case lltok::kw_and:
5355 case lltok::kw_or:
5356 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
5357 case lltok::kw_icmp: return ParseCompare(Inst, PFS, KeywordVal);
5358 case lltok::kw_fcmp: {
5359 FastMathFlags FMF = EatFastMathFlagsIfPresent();
5360 int Res = ParseCompare(Inst, PFS, KeywordVal);
5361 if (Res != 0)
5362 return Res;
5363 if (FMF.any())
5364 Inst->setFastMathFlags(FMF);
5365 return 0;
5366 }
5367
5368 // Casts.
5369 case lltok::kw_trunc:
5370 case lltok::kw_zext:
5371 case lltok::kw_sext:
5372 case lltok::kw_fptrunc:
5373 case lltok::kw_fpext:
5374 case lltok::kw_bitcast:
5375 case lltok::kw_addrspacecast:
5376 case lltok::kw_uitofp:
5377 case lltok::kw_sitofp:
5378 case lltok::kw_fptoui:
5379 case lltok::kw_fptosi:
5380 case lltok::kw_inttoptr:
5381 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
5382 // Other.
5383 case lltok::kw_select: return ParseSelect(Inst, PFS);
5384 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
5385 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
5386 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
5387 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
5388 case lltok::kw_phi: return ParsePHI(Inst, PFS);
5389 case lltok::kw_landingpad: return ParseLandingPad(Inst, PFS);
5390 // Call.
5391 case lltok::kw_call: return ParseCall(Inst, PFS, CallInst::TCK_None);
5392 case lltok::kw_tail: return ParseCall(Inst, PFS, CallInst::TCK_Tail);
5393 case lltok::kw_musttail: return ParseCall(Inst, PFS, CallInst::TCK_MustTail);
5394 case lltok::kw_notail: return ParseCall(Inst, PFS, CallInst::TCK_NoTail);
5395 // Memory.
5396 case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
5397 case lltok::kw_load: return ParseLoad(Inst, PFS);
5398 case lltok::kw_store: return ParseStore(Inst, PFS);
5399 case lltok::kw_cmpxchg: return ParseCmpXchg(Inst, PFS);
5400 case lltok::kw_atomicrmw: return ParseAtomicRMW(Inst, PFS);
5401 case lltok::kw_fence: return ParseFence(Inst, PFS);
5402 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
5403 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
5404 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
5405 }
5406}
5407
5408/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
5409bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
5410 if (Opc == Instruction::FCmp) {
5411 switch (Lex.getKind()) {
5412 default: return TokError("expected fcmp predicate (e.g. 'oeq')");
5413 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
5414 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
5415 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
5416 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
5417 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
5418 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
5419 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
5420 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
5421 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
5422 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
5423 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
5424 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
5425 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
5426 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
5427 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
5428 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
5429 }
5430 } else {
5431 switch (Lex.getKind()) {
5432 default: return TokError("expected icmp predicate (e.g. 'eq')");
5433 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
5434 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
5435 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
5436 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
5437 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
5438 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
5439 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
5440 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
5441 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
5442 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
5443 }
5444 }
5445 Lex.Lex();
5446 return false;
5447}
5448
5449//===----------------------------------------------------------------------===//
5450// Terminator Instructions.
5451//===----------------------------------------------------------------------===//
5452
5453/// ParseRet - Parse a return instruction.
5454/// ::= 'ret' void (',' !dbg, !1)*
5455/// ::= 'ret' TypeAndValue (',' !dbg, !1)*
5456bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
5457 PerFunctionState &PFS) {
5458 SMLoc TypeLoc = Lex.getLoc();
5459 Type *Ty = nullptr;
5460 if (ParseType(Ty, true /*void allowed*/)) return true;
5461
5462 Type *ResType = PFS.getFunction().getReturnType();
5463
5464 if (Ty->isVoidTy()) {
5465 if (!ResType->isVoidTy())
5466 return Error(TypeLoc, "value doesn't match function result type '" +
5467 getTypeString(ResType) + "'");
5468
5469 Inst = ReturnInst::Create(Context);
5470 return false;
5471 }
5472
5473 Value *RV;
5474 if (ParseValue(Ty, RV, PFS)) return true;
5475
5476 if (ResType != RV->getType())
5477 return Error(TypeLoc, "value doesn't match function result type '" +
5478 getTypeString(ResType) + "'");
5479
5480 Inst = ReturnInst::Create(Context, RV);
5481 return false;
5482}
5483
5484/// ParseBr
5485/// ::= 'br' TypeAndValue
5486/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
5487bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
5488 LocTy Loc, Loc2;
5489 Value *Op0;
5490 BasicBlock *Op1, *Op2;
5491 if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
5492
5493 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
5494 Inst = BranchInst::Create(BB);
5495 return false;
5496 }
5497
5498 if (Op0->getType() != Type::getInt1Ty(Context))
5499 return Error(Loc, "branch condition must have 'i1' type");
5500
5501 if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
5502 ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
5503 ParseToken(lltok::comma, "expected ',' after true destination") ||
5504 ParseTypeAndBasicBlock(Op2, Loc2, PFS))
5505 return true;
5506
5507 Inst = BranchInst::Create(Op1, Op2, Op0);
5508 return false;
5509}
5510
5511/// ParseSwitch
5512/// Instruction
5513/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
5514/// JumpTable
5515/// ::= (TypeAndValue ',' TypeAndValue)*
5516bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
5517 LocTy CondLoc, BBLoc;
5518 Value *Cond;
5519 BasicBlock *DefaultBB;
5520 if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
5521 ParseToken(lltok::comma, "expected ',' after switch condition") ||
5522 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
5523 ParseToken(lltok::lsquare, "expected '[' with switch table"))
5524 return true;
5525
5526 if (!Cond->getType()->isIntegerTy())
5527 return Error(CondLoc, "switch condition must have integer type");
5528
5529 // Parse the jump table pairs.
5530 SmallPtrSet<Value*, 32> SeenCases;
5531 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
5532 while (Lex.getKind() != lltok::rsquare) {
5533 Value *Constant;
5534 BasicBlock *DestBB;
5535
5536 if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
5537 ParseToken(lltok::comma, "expected ',' after case value") ||
5538 ParseTypeAndBasicBlock(DestBB, PFS))
5539 return true;
5540
5541 if (!SeenCases.insert(Constant).second)
5542 return Error(CondLoc, "duplicate case value in switch");
5543 if (!isa<ConstantInt>(Constant))
5544 return Error(CondLoc, "case value is not a constant integer");
5545
5546 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
5547 }
5548
5549 Lex.Lex(); // Eat the ']'.
5550
5551 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
5552 for (unsigned i = 0, e = Table.size(); i != e; ++i)
5553 SI->addCase(Table[i].first, Table[i].second);
5554 Inst = SI;
5555 return false;
5556}
5557
5558/// ParseIndirectBr
5559/// Instruction
5560/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
5561bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
5562 LocTy AddrLoc;
5563 Value *Address;
5564 if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
5565 ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
5566 ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
5567 return true;
5568
5569 if (!Address->getType()->isPointerTy())
5570 return Error(AddrLoc, "indirectbr address must have pointer type");
5571
5572 // Parse the destination list.
5573 SmallVector<BasicBlock*, 16> DestList;
5574
5575 if (Lex.getKind() != lltok::rsquare) {
5576 BasicBlock *DestBB;
5577 if (ParseTypeAndBasicBlock(DestBB, PFS))
5578 return true;
5579 DestList.push_back(DestBB);
5580
5581 while (EatIfPresent(lltok::comma)) {
5582 if (ParseTypeAndBasicBlock(DestBB, PFS))
5583 return true;
5584 DestList.push_back(DestBB);
5585 }
5586 }
5587
5588 if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
5589 return true;
5590
5591 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
5592 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
5593 IBI->addDestination(DestList[i]);
5594 Inst = IBI;
5595 return false;
5596}
5597
5598/// ParseInvoke
5599/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
5600/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
5601bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
5602 LocTy CallLoc = Lex.getLoc();
5603 AttrBuilder RetAttrs, FnAttrs;
5604 std::vector<unsigned> FwdRefAttrGrps;
5605 LocTy NoBuiltinLoc;
5606 unsigned CC;
5607 Type *RetType = nullptr;
5608 LocTy RetTypeLoc;
5609 ValID CalleeID;
5610 SmallVector<ParamInfo, 16> ArgList;
5611 SmallVector<OperandBundleDef, 2> BundleList;
5612
5613 BasicBlock *NormalBB, *UnwindBB;
5614 if (ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
5615 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
5616 ParseValID(CalleeID) || ParseParameterList(ArgList, PFS) ||
5617 ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
5618 NoBuiltinLoc) ||
5619 ParseOptionalOperandBundles(BundleList, PFS) ||
5620 ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
5621 ParseTypeAndBasicBlock(NormalBB, PFS) ||
5622 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
5623 ParseTypeAndBasicBlock(UnwindBB, PFS))
5624 return true;
5625
5626 // If RetType is a non-function pointer type, then this is the short syntax
5627 // for the call, which means that RetType is just the return type. Infer the
5628 // rest of the function argument types from the arguments that are present.
5629 FunctionType *Ty = dyn_cast<FunctionType>(RetType);
5630 if (!Ty) {
5631 // Pull out the types of all of the arguments...
5632 std::vector<Type*> ParamTypes;
5633 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
5634 ParamTypes.push_back(ArgList[i].V->getType());
5635
5636 if (!FunctionType::isValidReturnType(RetType))
5637 return Error(RetTypeLoc, "Invalid result type for LLVM function");
5638
5639 Ty = FunctionType::get(RetType, ParamTypes, false);
5640 }
5641
5642 CalleeID.FTy = Ty;
5643
5644 // Look up the callee.
5645 Value *Callee;
5646 if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS,
5647 /*IsCall=*/true))
5648 return true;
5649
5650 // Set up the Attribute for the function.
5651 SmallVector<Value *, 8> Args;
5652 SmallVector<AttributeSet, 8> ArgAttrs;
5653
5654 // Loop through FunctionType's arguments and ensure they are specified
5655 // correctly. Also, gather any parameter attributes.
5656 FunctionType::param_iterator I = Ty->param_begin();
5657 FunctionType::param_iterator E = Ty->param_end();
5658 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5659 Type *ExpectedTy = nullptr;
5660 if (I != E) {
5661 ExpectedTy = *I++;
5662 } else if (!Ty->isVarArg()) {
5663 return Error(ArgList[i].Loc, "too many arguments specified");
5664 }
5665
5666 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
5667 return Error(ArgList[i].Loc, "argument is not of expected type '" +
5668 getTypeString(ExpectedTy) + "'");
5669 Args.push_back(ArgList[i].V);
5670 ArgAttrs.push_back(ArgList[i].Attrs);
5671 }
5672
5673 if (I != E)
5674 return Error(CallLoc, "not enough parameters specified for call");
5675
5676 if (FnAttrs.hasAlignmentAttr())
5677 return Error(CallLoc, "invoke instructions may not have an alignment");
5678
5679 // Finish off the Attribute and check them
5680 AttributeList PAL =
5681 AttributeList::get(Context, AttributeSet::get(Context, FnAttrs),
5682 AttributeSet::get(Context, RetAttrs), ArgAttrs);
5683
5684 InvokeInst *II =
5685 InvokeInst::Create(Ty, Callee, NormalBB, UnwindBB, Args, BundleList);
5686 II->setCallingConv(CC);
5687 II->setAttributes(PAL);
5688 ForwardRefAttrGroups[II] = FwdRefAttrGrps;
5689 Inst = II;
5690 return false;
5691}
5692
5693/// ParseResume
5694/// ::= 'resume' TypeAndValue
5695bool LLParser::ParseResume(Instruction *&Inst, PerFunctionState &PFS) {
5696 Value *Exn; LocTy ExnLoc;
5697 if (ParseTypeAndValue(Exn, ExnLoc, PFS))
5698 return true;
5699
5700 ResumeInst *RI = ResumeInst::Create(Exn);
5701 Inst = RI;
5702 return false;
5703}
5704
5705bool LLParser::ParseExceptionArgs(SmallVectorImpl<Value *> &Args,
5706 PerFunctionState &PFS) {
5707 if (ParseToken(lltok::lsquare, "expected '[' in catchpad/cleanuppad"))
5708 return true;
5709
5710 while (Lex.getKind() != lltok::rsquare) {
5711 // If this isn't the first argument, we need a comma.
5712 if (!Args.empty() &&
5713 ParseToken(lltok::comma, "expected ',' in argument list"))
5714 return