Bug Summary

File:lib/AsmParser/LLParser.cpp
Warning:line 708, column 5
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~svn325874/build-llvm/lib/AsmParser -I /build/llvm-toolchain-snapshot-7~svn325874/lib/AsmParser -I /build/llvm-toolchain-snapshot-7~svn325874/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn325874/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~svn325874/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-23-163436-368-1 -x c++ /build/llvm-toolchain-snapshot-7~svn325874/lib/AsmParser/LLParser.cpp

/build/llvm-toolchain-snapshot-7~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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);
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~svn325874/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~svn325874/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~svn325874/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~svn325874/lib/AsmParser/LLParser.cpp"
, 677, __extension__ __PRETTY_FUNCTION__))
;
678 Lex.Lex();
679 unsigned MetadataID = 0;
680
681 MDNode *Init;
1
'Init' declared without an initial value
682 if (ParseUInt32(MetadataID) ||
2
Taking false branch
683 ParseToken(lltok::equal, "expected '=' here"))
684 return true;
685
686 // Detect common error, from old metadata syntax.
687 if (Lex.getKind() == lltok::Type)
3
Assuming the condition is false
4
Taking false branch
688 return TokError("unexpected type in metadata definition");
689
690 bool IsDistinct = EatIfPresent(lltok::kw_distinct);
691 if (Lex.getKind() == lltok::MetadataVar) {
5
Assuming the condition is true
6
Taking true branch
692 if (ParseSpecializedMDNode(Init, IsDistinct))
7
Calling 'LLParser::ParseSpecializedMDNode'
83
Returning from 'LLParser::ParseSpecializedMDNode'
84
Assuming the condition is false
85
Taking false branch
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()) {
86
Assuming the condition is false
87
Taking false branch
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~svn325874/lib/AsmParser/LLParser.cpp"
, 704, __extension__ __PRETTY_FUNCTION__))
;
705 } else {
706 if (NumberedMetadata.count(MetadataID))
88
Assuming the condition is false
89
Taking false branch
707 return TokError("Metadata id is already used");
708 NumberedMetadata[MetadataID].reset(Init);
90
1st function call argument is an uninitialized value
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~svn325874/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~svn325874/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~svn325874/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)
52
Calling 'LLLexer::getKind'
53
Returning from 'LLLexer::getKind'
54
Assuming the condition is false
55
Taking false branch
71
Calling 'LLLexer::getKind'
72
Returning from 'LLLexer::getKind'
73
Taking false branch
1298 return TokError(ErrMsg);
1299 Lex.Lex();
56
Calling 'LLLexer::Lex'
57
Returning from 'LLLexer::Lex'
74
Calling 'LLLexer::Lex'
75
Returning from 'LLLexer::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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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~svn325874/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
2615/// GetVal - Get a value with the specified name or ID, creating a
2616/// forward reference record if needed. This can return null if the value
2617/// exists but does not have the right type.
2618Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
2619 LocTy Loc) {
2620 // Look this name up in the normal function symbol table.
2621 Value *Val = F.getValueSymbolTable()->lookup(Name);
2622
2623 // If this is a forward reference for the value, see if we already created a
2624 // forward ref record.
2625 if (!Val) {
2626 auto I = ForwardRefVals.find(Name);
2627 if (I != ForwardRefVals.end())
2628 Val = I->second.first;
2629 }
2630
2631 // If we have the value in the symbol table or fwd-ref table, return it.
2632 if (Val) {
2633 if (Val->getType() == Ty) return Val;
2634 if (Ty->isLabelTy())
2635 P.Error(Loc, "'%" + Name + "' is not a basic block");
2636 else
2637 P.Error(Loc, "'%" + Name + "' defined with type '" +
2638 getTypeString(Val->getType()) + "'");
2639 return nullptr;
2640 }
2641
2642 // Don't make placeholders with invalid type.
2643 if (!Ty->isFirstClassType()) {
2644 P.Error(Loc, "invalid use of a non-first-class type");
2645 return nullptr;
2646 }
2647
2648 // Otherwise, create a new forward reference for this value and remember it.
2649 Value *FwdVal;
2650 if (Ty->isLabelTy()) {
2651 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
2652 } else {
2653 FwdVal = new Argument(Ty, Name);
2654 }
2655
2656 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
2657 return FwdVal;
2658}
2659
2660Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc) {
2661 // Look this name up in the normal function symbol table.
2662 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
2663
2664 // If this is a forward reference for the value, see if we already created a
2665 // forward ref record.
2666 if (!Val) {
2667 auto I = ForwardRefValIDs.find(ID);
2668 if (I != ForwardRefValIDs.end())
2669 Val = I->second.first;
2670 }
2671
2672 // If we have the value in the symbol table or fwd-ref table, return it.
2673 if (Val) {
2674 if (Val->getType() == Ty) return Val;
2675 if (Ty->isLabelTy())
2676 P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
2677 else
2678 P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
2679 getTypeString(Val->getType()) + "'");
2680 return nullptr;
2681 }
2682
2683 if (!Ty->isFirstClassType()) {
2684 P.Error(Loc, "invalid use of a non-first-class type");
2685 return nullptr;
2686 }
2687
2688 // Otherwise, create a new forward reference for this value and remember it.
2689 Value *FwdVal;
2690 if (Ty->isLabelTy()) {
2691 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
2692 } else {
2693 FwdVal = new Argument(Ty);
2694 }
2695
2696 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2697 return FwdVal;
2698}
2699
2700/// SetInstName - After an instruction is parsed and inserted into its
2701/// basic block, this installs its name.
2702bool LLParser::PerFunctionState::SetInstName(int NameID,
2703 const std::string &NameStr,
2704 LocTy NameLoc, Instruction *Inst) {
2705 // If this instruction has void type, it cannot have a name or ID specified.
2706 if (Inst->getType()->isVoidTy()) {
2707 if (NameID != -1 || !NameStr.empty())
2708 return P.Error(NameLoc, "instructions returning void cannot have a name");
2709 return false;
2710 }
2711
2712 // If this was a numbered instruction, verify that the instruction is the
2713 // expected value and resolve any forward references.
2714 if (NameStr.empty()) {
2715 // If neither a name nor an ID was specified, just use the next ID.
2716 if (NameID == -1)
2717 NameID = NumberedVals.size();
2718
2719 if (unsigned(NameID) != NumberedVals.size())
2720 return P.Error(NameLoc, "instruction expected to be numbered '%" +
2721 Twine(NumberedVals.size()) + "'");
2722
2723 auto FI = ForwardRefValIDs.find(NameID);
2724 if (FI != ForwardRefValIDs.end()) {
2725 Value *Sentinel = FI->second.first;
2726 if (Sentinel->getType() != Inst->getType())
2727 return P.Error(NameLoc, "instruction forward referenced with type '" +
2728 getTypeString(FI->second.first->getType()) + "'");
2729
2730 Sentinel->replaceAllUsesWith(Inst);
2731 Sentinel->deleteValue();
2732 ForwardRefValIDs.erase(FI);
2733 }
2734
2735 NumberedVals.push_back(Inst);
2736 return false;
2737 }
2738
2739 // Otherwise, the instruction had a name. Resolve forward refs and set it.
2740 auto FI = ForwardRefVals.find(NameStr);
2741 if (FI != ForwardRefVals.end()) {
2742 Value *Sentinel = FI->second.first;
2743 if (Sentinel->getType() != Inst->getType())
2744 return P.Error(NameLoc, "instruction forward referenced with type '" +
2745 getTypeString(FI->second.first->getType()) + "'");
2746
2747 Sentinel->replaceAllUsesWith(Inst);
2748 Sentinel->deleteValue();
2749 ForwardRefVals.erase(FI);
2750 }
2751
2752 // Set the name on the instruction.
2753 Inst->setName(NameStr);
2754
2755 if (Inst->getName() != NameStr)
2756 return P.Error(NameLoc, "multiple definition of local value named '" +
2757 NameStr + "'");
2758 return false;
2759}
2760
2761/// GetBB - Get a basic block with the specified name or ID, creating a
2762/// forward reference record if needed.
2763BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
2764 LocTy Loc) {
2765 return dyn_cast_or_null<BasicBlock>(GetVal(Name,
2766 Type::getLabelTy(F.getContext()), Loc));
2767}
2768
2769BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2770 return dyn_cast_or_null<BasicBlock>(GetVal(ID,
2771 Type::getLabelTy(F.getContext()), Loc));
2772}
2773
2774/// DefineBB - Define the specified basic block, which is either named or
2775/// unnamed. If there is an error, this returns null otherwise it returns
2776/// the block being defined.
2777BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
2778 LocTy Loc) {
2779 BasicBlock *BB;
2780 if (Name.empty())
2781 BB = GetBB(NumberedVals.size(), Loc);
2782 else
2783 BB = GetBB(Name, Loc);
2784 if (!BB) return nullptr; // Already diagnosed error.
2785
2786 // Move the block to the end of the function. Forward ref'd blocks are
2787 // inserted wherever they happen to be referenced.
2788 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
2789
2790 // Remove the block from forward ref sets.
2791 if (Name.empty()) {
2792 ForwardRefValIDs.erase(NumberedVals.size());
2793 NumberedVals.push_back(BB);
2794 } else {
2795 // BB forward references are already in the function symbol table.
2796 ForwardRefVals.erase(Name);
2797 }
2798
2799 return BB;
2800}
2801
2802//===----------------------------------------------------------------------===//
2803// Constants.
2804//===----------------------------------------------------------------------===//
2805
2806/// ParseValID - Parse an abstract value that doesn't necessarily have a
2807/// type implied. For example, if we parse "4" we don't know what integer type
2808/// it has. The value will later be combined with its type and checked for
2809/// sanity. PFS is used to convert function-local operands of metadata (since
2810/// metadata operands are not just parsed here but also converted to values).
2811/// PFS can be null when we are not parsing metadata values inside a function.
2812bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2813 ID.Loc = Lex.getLoc();
2814 switch (Lex.getKind()) {
2815 default: return TokError("expected value token");
2816 case lltok::GlobalID: // @42
2817 ID.UIntVal = Lex.getUIntVal();
2818 ID.Kind = ValID::t_GlobalID;
2819 break;
2820 case lltok::GlobalVar: // @foo
2821 ID.StrVal = Lex.getStrVal();
2822 ID.Kind = ValID::t_GlobalName;
2823 break;
2824 case lltok::LocalVarID: // %42
2825 ID.UIntVal = Lex.getUIntVal();
2826 ID.Kind = ValID::t_LocalID;
2827 break;
2828 case lltok::LocalVar: // %foo
2829 ID.StrVal = Lex.getStrVal();
2830 ID.Kind = ValID::t_LocalName;
2831 break;
2832 case lltok::APSInt:
2833 ID.APSIntVal = Lex.getAPSIntVal();
2834 ID.Kind = ValID::t_APSInt;
2835 break;
2836 case lltok::APFloat:
2837 ID.APFloatVal = Lex.getAPFloatVal();
2838 ID.Kind = ValID::t_APFloat;
2839 break;
2840 case lltok::kw_true:
2841 ID.ConstantVal = ConstantInt::getTrue(Context);
2842 ID.Kind = ValID::t_Constant;
2843 break;
2844 case lltok::kw_false:
2845 ID.ConstantVal = ConstantInt::getFalse(Context);
2846 ID.Kind = ValID::t_Constant;
2847 break;
2848 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2849 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2850 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2851 case lltok::kw_none: ID.Kind = ValID::t_None; break;
2852
2853 case lltok::lbrace: {
2854 // ValID ::= '{' ConstVector '}'
2855 Lex.Lex();
2856 SmallVector<Constant*, 16> Elts;
2857 if (ParseGlobalValueVector(Elts) ||
2858 ParseToken(lltok::rbrace, "expected end of struct constant"))
2859 return true;
2860
2861 ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2862 ID.UIntVal = Elts.size();
2863 memcpy(ID.ConstantStructElts.get(), Elts.data(),
2864 Elts.size() * sizeof(Elts[0]));
2865 ID.Kind = ValID::t_ConstantStruct;
2866 return false;
2867 }
2868 case lltok::less: {
2869 // ValID ::= '<' ConstVector '>' --> Vector.
2870 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
2871 Lex.Lex();
2872 bool isPackedStruct = EatIfPresent(lltok::lbrace);
2873
2874 SmallVector<Constant*, 16> Elts;
2875 LocTy FirstEltLoc = Lex.getLoc();
2876 if (ParseGlobalValueVector(Elts) ||
2877 (isPackedStruct &&
2878 ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2879 ParseToken(lltok::greater, "expected end of constant"))
2880 return true;
2881
2882 if (isPackedStruct) {
2883 ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2884 memcpy(ID.ConstantStructElts.get(), Elts.data(),
2885 Elts.size() * sizeof(Elts[0]));
2886 ID.UIntVal = Elts.size();
2887 ID.Kind = ValID::t_PackedConstantStruct;
2888 return false;
2889 }
2890
2891 if (Elts.empty())
2892 return Error(ID.Loc, "constant vector must not be empty");
2893
2894 if (!Elts[0]->getType()->isIntegerTy() &&
2895 !Elts[0]->getType()->isFloatingPointTy() &&
2896 !Elts[0]->getType()->isPointerTy())
2897 return Error(FirstEltLoc,
2898 "vector elements must have integer, pointer or floating point type");
2899
2900 // Verify that all the vector elements have the same type.
2901 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2902 if (Elts[i]->getType() != Elts[0]->getType())
2903 return Error(FirstEltLoc,
2904 "vector element #" + Twine(i) +
2905 " is not of type '" + getTypeString(Elts[0]->getType()));
2906
2907 ID.ConstantVal = ConstantVector::get(Elts);
2908 ID.Kind = ValID::t_Constant;
2909 return false;
2910 }
2911 case lltok::lsquare: { // Array Constant
2912 Lex.Lex();
2913 SmallVector<Constant*, 16> Elts;
2914 LocTy FirstEltLoc = Lex.getLoc();
2915 if (ParseGlobalValueVector(Elts) ||
2916 ParseToken(lltok::rsquare, "expected end of array constant"))
2917 return true;
2918
2919 // Handle empty element.
2920 if (Elts.empty()) {
2921 // Use undef instead of an array because it's inconvenient to determine
2922 // the element type at this point, there being no elements to examine.
2923 ID.Kind = ValID::t_EmptyArray;
2924 return false;
2925 }
2926
2927 if (!Elts[0]->getType()->isFirstClassType())
2928 return Error(FirstEltLoc, "invalid array element type: " +
2929 getTypeString(Elts[0]->getType()));
2930
2931 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2932
2933 // Verify all elements are correct type!
2934 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2935 if (Elts[i]->getType() != Elts[0]->getType())
2936 return Error(FirstEltLoc,
2937 "array element #" + Twine(i) +
2938 " is not of type '" + getTypeString(Elts[0]->getType()));
2939 }
2940
2941 ID.ConstantVal = ConstantArray::get(ATy, Elts);
2942 ID.Kind = ValID::t_Constant;
2943 return false;
2944 }
2945 case lltok::kw_c: // c "foo"
2946 Lex.Lex();
2947 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
2948 false);
2949 if (ParseToken(lltok::StringConstant, "expected string")) return true;
2950 ID.Kind = ValID::t_Constant;
2951 return false;
2952
2953 case lltok::kw_asm: {
2954 // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ','
2955 // STRINGCONSTANT
2956 bool HasSideEffect, AlignStack, AsmDialect;
2957 Lex.Lex();
2958 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2959 ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2960 ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
2961 ParseStringConstant(ID.StrVal) ||
2962 ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2963 ParseToken(lltok::StringConstant, "expected constraint string"))
2964 return true;
2965 ID.StrVal2 = Lex.getStrVal();
2966 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2967 (unsigned(AsmDialect)<<2);
2968 ID.Kind = ValID::t_InlineAsm;
2969 return false;
2970 }
2971
2972 case lltok::kw_blockaddress: {
2973 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2974 Lex.Lex();
2975
2976 ValID Fn, Label;
2977
2978 if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2979 ParseValID(Fn) ||
2980 ParseToken(lltok::comma, "expected comma in block address expression")||
2981 ParseValID(Label) ||
2982 ParseToken(lltok::rparen, "expected ')' in block address expression"))
2983 return true;
2984
2985 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2986 return Error(Fn.Loc, "expected function name in blockaddress");
2987 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2988 return Error(Label.Loc, "expected basic block name in blockaddress");
2989
2990 // Try to find the function (but skip it if it's forward-referenced).
2991 GlobalValue *GV = nullptr;
2992 if (Fn.Kind == ValID::t_GlobalID) {
2993 if (Fn.UIntVal < NumberedVals.size())
2994 GV = NumberedVals[Fn.UIntVal];
2995 } else if (!ForwardRefVals.count(Fn.StrVal)) {
2996 GV = M->getNamedValue(Fn.StrVal);
2997 }
2998 Function *F = nullptr;
2999 if (GV) {
3000 // Confirm that it's actually a function with a definition.
3001 if (!isa<Function>(GV))
3002 return Error(Fn.Loc, "expected function name in blockaddress");
3003 F = cast<Function>(GV);
3004 if (F->isDeclaration())
3005 return Error(Fn.Loc, "cannot take blockaddress inside a declaration");
3006 }
3007
3008 if (!F) {
3009 // Make a global variable as a placeholder for this reference.
3010 GlobalValue *&FwdRef =
3011 ForwardRefBlockAddresses.insert(std::make_pair(
3012 std::move(Fn),
3013 std::map<ValID, GlobalValue *>()))
3014 .first->second.insert(std::make_pair(std::move(Label), nullptr))
3015 .first->second;
3016 if (!FwdRef)
3017 FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
3018 GlobalValue::InternalLinkage, nullptr, "");
3019 ID.ConstantVal = FwdRef;
3020 ID.Kind = ValID::t_Constant;
3021 return false;
3022 }
3023
3024 // We found the function; now find the basic block. Don't use PFS, since we
3025 // might be inside a constant expression.
3026 BasicBlock *BB;
3027 if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
3028 if (Label.Kind == ValID::t_LocalID)
3029 BB = BlockAddressPFS->GetBB(Label.UIntVal, Label.Loc);
3030 else
3031 BB = BlockAddressPFS->GetBB(Label.StrVal, Label.Loc);
3032 if (!BB)
3033 return Error(Label.Loc, "referenced value is not a basic block");
3034 } else {
3035 if (Label.Kind == ValID::t_LocalID)
3036 return Error(Label.Loc, "cannot take address of numeric label after "
3037 "the function is defined");
3038 BB = dyn_cast_or_null<BasicBlock>(
3039 F->getValueSymbolTable()->lookup(Label.StrVal));
3040 if (!BB)
3041 return Error(Label.Loc, "referenced value is not a basic block");
3042 }
3043
3044 ID.ConstantVal = BlockAddress::get(F, BB);
3045 ID.Kind = ValID::t_Constant;
3046 return false;
3047 }
3048
3049 case lltok::kw_trunc:
3050 case lltok::kw_zext:
3051 case lltok::kw_sext:
3052 case lltok::kw_fptrunc:
3053 case lltok::kw_fpext:
3054 case lltok::kw_bitcast:
3055 case lltok::kw_addrspacecast:
3056 case lltok::kw_uitofp:
3057 case lltok::kw_sitofp:
3058 case lltok::kw_fptoui:
3059 case lltok::kw_fptosi:
3060 case lltok::kw_inttoptr:
3061 case lltok::kw_ptrtoint: {
3062 unsigned Opc = Lex.getUIntVal();
3063 Type *DestTy = nullptr;
3064 Constant *SrcVal;
3065 Lex.Lex();
3066 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
3067 ParseGlobalTypeAndValue(SrcVal) ||
3068 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
3069 ParseType(DestTy) ||
3070 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
3071 return true;
3072 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
3073 return Error(ID.Loc, "invalid cast opcode for cast from '" +
3074 getTypeString(SrcVal->getType()) + "' to '" +
3075 getTypeString(DestTy) + "'");
3076 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
3077 SrcVal, DestTy);
3078 ID.Kind = ValID::t_Constant;
3079 return false;
3080 }
3081 case lltok::kw_extractvalue: {
3082 Lex.Lex();
3083 Constant *Val;
3084 SmallVector<unsigned, 4> Indices;
3085 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
3086 ParseGlobalTypeAndValue(Val) ||
3087 ParseIndexList(Indices) ||
3088 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
3089 return true;
3090
3091 if (!Val->getType()->isAggregateType())
3092 return Error(ID.Loc, "extractvalue operand must be aggregate type");
3093 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
3094 return Error(ID.Loc, "invalid indices for extractvalue");
3095 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
3096 ID.Kind = ValID::t_Constant;
3097 return false;
3098 }
3099 case lltok::kw_insertvalue: {
3100 Lex.Lex();
3101 Constant *Val0, *Val1;
3102 SmallVector<unsigned, 4> Indices;
3103 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
3104 ParseGlobalTypeAndValue(Val0) ||
3105 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
3106 ParseGlobalTypeAndValue(Val1) ||
3107 ParseIndexList(Indices) ||
3108 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
3109 return true;
3110 if (!Val0->getType()->isAggregateType())
3111 return Error(ID.Loc, "insertvalue operand must be aggregate type");
3112 Type *IndexedType =
3113 ExtractValueInst::getIndexedType(Val0->getType(), Indices);
3114 if (!IndexedType)
3115 return Error(ID.Loc, "invalid indices for insertvalue");
3116 if (IndexedType != Val1->getType())
3117 return Error(ID.Loc, "insertvalue operand and field disagree in type: '" +
3118 getTypeString(Val1->getType()) +
3119 "' instead of '" + getTypeString(IndexedType) +
3120 "'");
3121 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
3122 ID.Kind = ValID::t_Constant;
3123 return false;
3124 }
3125 case lltok::kw_icmp:
3126 case lltok::kw_fcmp: {
3127 unsigned PredVal, Opc = Lex.getUIntVal();
3128 Constant *Val0, *Val1;
3129 Lex.Lex();
3130 if (ParseCmpPredicate(PredVal, Opc) ||
3131 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
3132 ParseGlobalTypeAndValue(Val0) ||
3133 ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
3134 ParseGlobalTypeAndValue(Val1) ||
3135 ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
3136 return true;
3137
3138 if (Val0->getType() != Val1->getType())
3139 return Error(ID.Loc, "compare operands must have the same type");
3140
3141 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
3142
3143 if (Opc == Instruction::FCmp) {
3144 if (!Val0->getType()->isFPOrFPVectorTy())
3145 return Error(ID.Loc, "fcmp requires floating point operands");
3146 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
3147 } else {
3148 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3148, __extension__ __PRETTY_FUNCTION__))
;
3149 if (!Val0->getType()->isIntOrIntVectorTy() &&
3150 !Val0->getType()->isPtrOrPtrVectorTy())
3151 return Error(ID.Loc, "icmp requires pointer or integer operands");
3152 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
3153 }
3154 ID.Kind = ValID::t_Constant;
3155 return false;
3156 }
3157
3158 // Binary Operators.
3159 case lltok::kw_add:
3160 case lltok::kw_fadd:
3161 case lltok::kw_sub:
3162 case lltok::kw_fsub:
3163 case lltok::kw_mul:
3164 case lltok::kw_fmul:
3165 case lltok::kw_udiv:
3166 case lltok::kw_sdiv:
3167 case lltok::kw_fdiv:
3168 case lltok::kw_urem:
3169 case lltok::kw_srem:
3170 case lltok::kw_frem:
3171 case lltok::kw_shl:
3172 case lltok::kw_lshr:
3173 case lltok::kw_ashr: {
3174 bool NUW = false;
3175 bool NSW = false;
3176 bool Exact = false;
3177 unsigned Opc = Lex.getUIntVal();
3178 Constant *Val0, *Val1;
3179 Lex.Lex();
3180 LocTy ModifierLoc = Lex.getLoc();
3181 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
3182 Opc == Instruction::Mul || Opc == Instruction::Shl) {
3183 if (EatIfPresent(lltok::kw_nuw))
3184 NUW = true;
3185 if (EatIfPresent(lltok::kw_nsw)) {
3186 NSW = true;
3187 if (EatIfPresent(lltok::kw_nuw))
3188 NUW = true;
3189 }
3190 } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
3191 Opc == Instruction::LShr || Opc == Instruction::AShr) {
3192 if (EatIfPresent(lltok::kw_exact))
3193 Exact = true;
3194 }
3195 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
3196 ParseGlobalTypeAndValue(Val0) ||
3197 ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
3198 ParseGlobalTypeAndValue(Val1) ||
3199 ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
3200 return true;
3201 if (Val0->getType() != Val1->getType())
3202 return Error(ID.Loc, "operands of constexpr must have same type");
3203 if (!Val0->getType()->isIntOrIntVectorTy()) {
3204 if (NUW)
3205 return Error(ModifierLoc, "nuw only applies to integer operations");
3206 if (NSW)
3207 return Error(ModifierLoc, "nsw only applies to integer operations");
3208 }
3209 // Check that the type is valid for the operator.
3210 switch (Opc) {
3211 case Instruction::Add:
3212 case Instruction::Sub:
3213 case Instruction::Mul:
3214 case Instruction::UDiv:
3215 case Instruction::SDiv:
3216 case Instruction::URem:
3217 case Instruction::SRem:
3218 case Instruction::Shl:
3219 case Instruction::AShr:
3220 case Instruction::LShr:
3221 if (!Val0->getType()->isIntOrIntVectorTy())
3222 return Error(ID.Loc, "constexpr requires integer operands");
3223 break;
3224 case Instruction::FAdd:
3225 case Instruction::FSub:
3226 case Instruction::FMul:
3227 case Instruction::FDiv:
3228 case Instruction::FRem:
3229 if (!Val0->getType()->isFPOrFPVectorTy())
3230 return Error(ID.Loc, "constexpr requires fp operands");
3231 break;
3232 default: llvm_unreachable("Unknown binary operator!")::llvm::llvm_unreachable_internal("Unknown binary operator!",
"/build/llvm-toolchain-snapshot-7~svn325874/lib/AsmParser/LLParser.cpp"
, 3232)
;
3233 }
3234 unsigned Flags = 0;
3235 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
3236 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
3237 if (Exact) Flags |= PossiblyExactOperator::IsExact;
3238 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
3239 ID.ConstantVal = C;
3240 ID.Kind = ValID::t_Constant;
3241 return false;
3242 }
3243
3244 // Logical Operations
3245 case lltok::kw_and:
3246 case lltok::kw_or:
3247 case lltok::kw_xor: {
3248 unsigned Opc = Lex.getUIntVal();
3249 Constant *Val0, *Val1;
3250 Lex.Lex();
3251 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
3252 ParseGlobalTypeAndValue(Val0) ||
3253 ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
3254 ParseGlobalTypeAndValue(Val1) ||
3255 ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
3256 return true;
3257 if (Val0->getType() != Val1->getType())
3258 return Error(ID.Loc, "operands of constexpr must have same type");
3259 if (!Val0->getType()->isIntOrIntVectorTy())
3260 return Error(ID.Loc,
3261 "constexpr requires integer or integer vector operands");
3262 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
3263 ID.Kind = ValID::t_Constant;
3264 return false;
3265 }
3266
3267 case lltok::kw_getelementptr:
3268 case lltok::kw_shufflevector:
3269 case lltok::kw_insertelement:
3270 case lltok::kw_extractelement:
3271 case lltok::kw_select: {
3272 unsigned Opc = Lex.getUIntVal();
3273 SmallVector<Constant*, 16> Elts;
3274 bool InBounds = false;
3275 Type *Ty;
3276 Lex.Lex();
3277
3278 if (Opc == Instruction::GetElementPtr)
3279 InBounds = EatIfPresent(lltok::kw_inbounds);
3280
3281 if (ParseToken(lltok::lparen, "expected '(' in constantexpr"))
3282 return true;
3283
3284 LocTy ExplicitTypeLoc = Lex.getLoc();
3285 if (Opc == Instruction::GetElementPtr) {
3286 if (ParseType(Ty) ||
3287 ParseToken(lltok::comma, "expected comma after getelementptr's type"))
3288 return true;
3289 }
3290
3291 Optional<unsigned> InRangeOp;
3292 if (ParseGlobalValueVector(
3293 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp : nullptr) ||
3294 ParseToken(lltok::rparen, "expected ')' in constantexpr"))
3295 return true;
3296
3297 if (Opc == Instruction::GetElementPtr) {
3298 if (Elts.size() == 0 ||
3299 !Elts[0]->getType()->isPtrOrPtrVectorTy())
3300 return Error(ID.Loc, "base of getelementptr must be a pointer");
3301
3302 Type *BaseType = Elts[0]->getType();
3303 auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
3304 if (Ty != BasePointerType->getElementType())
3305 return Error(
3306 ExplicitTypeLoc,
3307 "explicit pointee type doesn't match operand's pointee type");
3308
3309 unsigned GEPWidth =
3310 BaseType->isVectorTy() ? BaseType->getVectorNumElements() : 0;
3311
3312 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
3313 for (Constant *Val : Indices) {
3314 Type *ValTy = Val->getType();
3315 if (!ValTy->isIntOrIntVectorTy())
3316 return Error(ID.Loc, "getelementptr index must be an integer");
3317 if (ValTy->isVectorTy()) {
3318 unsigned ValNumEl = ValTy->getVectorNumElements();
3319 if (GEPWidth && (ValNumEl != GEPWidth))
3320 return Error(
3321 ID.Loc,
3322 "getelementptr vector index has a wrong number of elements");
3323 // GEPWidth may have been unknown because the base is a scalar,
3324 // but it is known now.
3325 GEPWidth = ValNumEl;
3326 }
3327 }
3328
3329 SmallPtrSet<Type*, 4> Visited;
3330 if (!Indices.empty() && !Ty->isSized(&Visited))
3331 return Error(ID.Loc, "base element of getelementptr must be sized");
3332
3333 if (!GetElementPtrInst::getIndexedType(Ty, Indices))
3334 return Error(ID.Loc, "invalid getelementptr indices");
3335
3336 if (InRangeOp) {
3337 if (*InRangeOp == 0)
3338 return Error(ID.Loc,
3339 "inrange keyword may not appear on pointer operand");
3340 --*InRangeOp;
3341 }
3342
3343 ID.ConstantVal = ConstantExpr::getGetElementPtr(Ty, Elts[0], Indices,
3344 InBounds, InRangeOp);
3345 } else if (Opc == Instruction::Select) {
3346 if (Elts.size() != 3)
3347 return Error(ID.Loc, "expected three operands to select");
3348 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
3349 Elts[2]))
3350 return Error(ID.Loc, Reason);
3351 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
3352 } else if (Opc == Instruction::ShuffleVector) {
3353 if (Elts.size() != 3)
3354 return Error(ID.Loc, "expected three operands to shufflevector");
3355 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3356 return Error(ID.Loc, "invalid operands to shufflevector");
3357 ID.ConstantVal =
3358 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
3359 } else if (Opc == Instruction::ExtractElement) {
3360 if (Elts.size() != 2)
3361 return Error(ID.Loc, "expected two operands to extractelement");
3362 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
3363 return Error(ID.Loc, "invalid extractelement operands");
3364 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
3365 } else {
3366 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3366, __extension__ __PRETTY_FUNCTION__))
;
3367 if (Elts.size() != 3)
3368 return Error(ID.Loc, "expected three operands to insertelement");
3369 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3370 return Error(ID.Loc, "invalid insertelement operands");
3371 ID.ConstantVal =
3372 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
3373 }
3374
3375 ID.Kind = ValID::t_Constant;
3376 return false;
3377 }
3378 }
3379
3380 Lex.Lex();
3381 return false;
3382}
3383
3384/// ParseGlobalValue - Parse a global value with the specified type.
3385bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
3386 C = nullptr;
3387 ValID ID;
3388 Value *V = nullptr;
3389 bool Parsed = ParseValID(ID) ||
3390 ConvertValIDToValue(Ty, ID, V, nullptr);
3391 if (V && !(C = dyn_cast<Constant>(V)))
3392 return Error(ID.Loc, "global values must be constants");
3393 return Parsed;
3394}
3395
3396bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
3397 Type *Ty = nullptr;
3398 return ParseType(Ty) ||
3399 ParseGlobalValue(Ty, V);
3400}
3401
3402bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
3403 C = nullptr;
3404
3405 LocTy KwLoc = Lex.getLoc();
3406 if (!EatIfPresent(lltok::kw_comdat))
3407 return false;
3408
3409 if (EatIfPresent(lltok::lparen)) {
3410 if (Lex.getKind() != lltok::ComdatVar)
3411 return TokError("expected comdat variable");
3412 C = getComdat(Lex.getStrVal(), Lex.getLoc());
3413 Lex.Lex();
3414 if (ParseToken(lltok::rparen, "expected ')' after comdat var"))
3415 return true;
3416 } else {
3417 if (GlobalName.empty())
3418 return TokError("comdat cannot be unnamed");
3419 C = getComdat(GlobalName, KwLoc);
3420 }
3421
3422 return false;
3423}
3424
3425/// ParseGlobalValueVector
3426/// ::= /*empty*/
3427/// ::= [inrange] TypeAndValue (',' [inrange] TypeAndValue)*
3428bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
3429 Optional<unsigned> *InRangeOp) {
3430 // Empty list.
3431 if (Lex.getKind() == lltok::rbrace ||
3432 Lex.getKind() == lltok::rsquare ||
3433 Lex.getKind() == lltok::greater ||
3434 Lex.getKind() == lltok::rparen)
3435 return false;
3436
3437 do {
3438 if (InRangeOp && !*InRangeOp && EatIfPresent(lltok::kw_inrange))
3439 *InRangeOp = Elts.size();
3440
3441 Constant *C;
3442 if (ParseGlobalTypeAndValue(C)) return true;
3443 Elts.push_back(C);
3444 } while (EatIfPresent(lltok::comma));
3445
3446 return false;
3447}
3448
3449bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
3450 SmallVector<Metadata *, 16> Elts;
3451 if (ParseMDNodeVector(Elts))
3452 return true;
3453
3454 MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
3455 return false;
3456}
3457
3458/// MDNode:
3459/// ::= !{ ... }
3460/// ::= !7
3461/// ::= !DILocation(...)
3462bool LLParser::ParseMDNode(MDNode *&N) {
3463 if (Lex.getKind() == lltok::MetadataVar)
3464 return ParseSpecializedMDNode(N);
3465
3466 return ParseToken(lltok::exclaim, "expected '!' here") ||
3467 ParseMDNodeTail(N);
3468}
3469
3470bool LLParser::ParseMDNodeTail(MDNode *&N) {
3471 // !{ ... }
3472 if (Lex.getKind() == lltok::lbrace)
3473 return ParseMDTuple(N);
3474
3475 // !42
3476 return ParseMDNodeID(N);
3477}
3478
3479namespace {
3480
3481/// Structure to represent an optional metadata field.
3482template <class FieldTy> struct MDFieldImpl {
3483 typedef MDFieldImpl ImplTy;
3484 FieldTy Val;
3485 bool Seen;
3486
3487 void assign(FieldTy Val) {
3488 Seen = true;
3489 this->Val = std::move(Val);
3490 }
3491
3492 explicit MDFieldImpl(FieldTy Default)
3493 : Val(std::move(Default)), Seen(false) {}
23
Calling 'move'
24
Returning from 'move'
28
Calling 'move'
29
Returning from 'move'
34
Calling 'move'
35
Returning from 'move'
45
Calling 'move'
46
Returning from 'move'
3494};
3495
3496/// Structure to represent an optional metadata field that
3497/// can be of either type (A or B) and encapsulates the
3498/// MD<typeofA>Field and MD<typeofB>Field structs, so not
3499/// to reimplement the specifics for representing each Field.
3500template <class FieldTypeA, class FieldTypeB> struct MDEitherFieldImpl {
3501 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
3502 FieldTypeA A;
3503 FieldTypeB B;
3504 bool Seen;
3505
3506 enum {
3507 IsInvalid = 0,
3508 IsTypeA = 1,
3509 IsTypeB = 2
3510 } WhatIs;
3511
3512 void assign(FieldTypeA A) {
3513 Seen = true;
3514 this->A = std::move(A);
3515 WhatIs = IsTypeA;
3516 }
3517
3518 void assign(FieldTypeB B) {
3519 Seen = true;
3520 this->B = std::move(B);
3521 WhatIs = IsTypeB;
3522 }
3523
3524 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
3525 : A(std::move(DefaultA)), B(std::move(DefaultB)), Seen(false),
39
Calling 'move'
40
Returning from 'move'
41
Calling 'move'
42
Returning from 'move'
3526 WhatIs(IsInvalid) {}
3527};
3528
3529struct MDUnsignedField : public MDFieldImpl<uint64_t> {
3530 uint64_t Max;
3531
3532 MDUnsignedField(uint64_t Default = 0, uint64_t Max = UINT64_MAX(18446744073709551615UL))
3533 : ImplTy(Default), Max(Max) {}
33
Calling constructor for 'MDFieldImpl'
36
Returning from constructor for 'MDFieldImpl'
3534};
3535
3536struct LineField : public MDUnsignedField {
3537 LineField() : MDUnsignedField(0, UINT32_MAX(4294967295U)) {}
3538};
3539
3540struct ColumnField : public MDUnsignedField {
3541 ColumnField() : MDUnsignedField(0, UINT16_MAX(65535)) {}
3542};
3543
3544struct DwarfTagField : public MDUnsignedField {
3545 DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
3546 DwarfTagField(dwarf::Tag DefaultTag)
3547 : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
3548};
3549
3550struct DwarfMacinfoTypeField : public MDUnsignedField {
3551 DwarfMacinfoTypeField() : MDUnsignedField(0, dwarf::DW_MACINFO_vendor_ext) {}
3552 DwarfMacinfoTypeField(dwarf::MacinfoRecordType DefaultType)
3553 : MDUnsignedField(DefaultType, dwarf::DW_MACINFO_vendor_ext) {}
3554};
3555
3556struct DwarfAttEncodingField : public MDUnsignedField {
3557 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
3558};
3559
3560struct DwarfVirtualityField : public MDUnsignedField {
3561 DwarfVirtualityField() : MDUnsignedField(0, dwarf::DW_VIRTUALITY_max) {}
3562};
3563
3564struct DwarfLangField : public MDUnsignedField {
3565 DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
3566};
3567
3568struct DwarfCCField : public MDUnsignedField {
3569 DwarfCCField() : MDUnsignedField(0, dwarf::DW_CC_hi_user) {}
3570};
3571
3572struct EmissionKindField : public MDUnsignedField {
3573 EmissionKindField() : MDUnsignedField(0, DICompileUnit::LastEmissionKind) {}
3574};
3575
3576struct DIFlagField : public MDFieldImpl<DINode::DIFlags> {
3577 DIFlagField() : MDFieldImpl(DINode::FlagZero) {}
3578};
3579
3580struct MDSignedField : public MDFieldImpl<int64_t> {
3581 int64_t Min;
3582 int64_t Max;
3583
3584 MDSignedField(int64_t Default = 0)
3585 : ImplTy(Default), Min(INT64_MIN(-9223372036854775807L -1)), Max(INT64_MAX(9223372036854775807L)) {}
27
Calling constructor for 'MDFieldImpl'
30
Returning from constructor for 'MDFieldImpl'
3586 MDSignedField(int64_t Default, int64_t Min, int64_t Max)
3587 : ImplTy(Default), Min(Min), Max(Max) {}
3588};
3589
3590struct MDBoolField : public MDFieldImpl<bool> {
3591 MDBoolField(bool Default = false) : ImplTy(Default) {}
44
Calling constructor for 'MDFieldImpl'
47
Returning from constructor for 'MDFieldImpl'
3592};
3593
3594struct MDField : public MDFieldImpl<Metadata *> {
3595 bool AllowNull;
3596
3597 MDField(bool AllowNull = true) : ImplTy(nullptr), AllowNull(AllowNull) {}
3598};
3599
3600struct MDConstant : public MDFieldImpl<ConstantAsMetadata *> {
3601 MDConstant() : ImplTy(nullptr) {}
3602};
3603
3604struct MDStringField : public MDFieldImpl<MDString *> {
3605 bool AllowEmpty;
3606 MDStringField(bool AllowEmpty = true)
3607 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
22
Calling constructor for 'MDFieldImpl'
25
Returning from constructor for 'MDFieldImpl'
3608};
3609
3610struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
3611 MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
3612};
3613
3614struct ChecksumKindField : public MDFieldImpl<DIFile::ChecksumKind> {
3615 ChecksumKindField(DIFile::ChecksumKind CSKind) : ImplTy(CSKind) {}
3616};
3617
3618struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
3619 MDSignedOrMDField(int64_t Default = 0, bool AllowNull = true)
3620 : ImplTy(MDSignedField(Default), MDField(AllowNull)) {}
3621
3622 MDSignedOrMDField(int64_t Default, int64_t Min, int64_t Max,
3623 bool AllowNull = true)
3624 : ImplTy(MDSignedField(Default, Min, Max), MDField(AllowNull)) {}
3625
3626 bool isMDSignedField() const { return WhatIs == IsTypeA; }
3627 bool isMDField() const { return WhatIs == IsTypeB; }
3628 int64_t getMDSignedValue() const {
3629 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3629, __extension__ __PRETTY_FUNCTION__))
;
3630 return A.Val;
3631 }
3632 Metadata *getMDFieldValue() const {
3633 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3633, __extension__ __PRETTY_FUNCTION__))
;
3634 return B.Val;
3635 }
3636};
3637
3638struct MDSignedOrUnsignedField
3639 : MDEitherFieldImpl<MDSignedField, MDUnsignedField> {
3640 MDSignedOrUnsignedField() : ImplTy(MDSignedField(0), MDUnsignedField(0)) {}
26
Calling default constructor for 'MDSignedField'
31
Returning from default constructor for 'MDSignedField'
32
Calling default constructor for 'MDUnsignedField'
37
Returning from default constructor for 'MDUnsignedField'
38
Calling constructor for 'MDEitherFieldImpl'
43
Returning from constructor for 'MDEitherFieldImpl'
3641
3642 bool isMDSignedField() const { return WhatIs == IsTypeA; }
3643 bool isMDUnsignedField() 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3645, __extension__ __PRETTY_FUNCTION__))
;
3646 return A.Val;
3647 }
3648 uint64_t getMDUnsignedValue() const {
3649 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__))
;
3650 return B.Val;
3651 }
3652};
3653
3654} // end anonymous namespace
3655
3656namespace llvm {
3657
3658template <>
3659bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3660 MDUnsignedField &Result) {
3661 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
3662 return TokError("expected unsigned integer");
3663
3664 auto &U = Lex.getAPSIntVal();
3665 if (U.ugt(Result.Max))
3666 return TokError("value for '" + Name + "' too large, limit is " +
3667 Twine(Result.Max));
3668 Result.assign(U.getZExtValue());
3669 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3669, __extension__ __PRETTY_FUNCTION__))
;
3670 Lex.Lex();
3671 return false;
3672}
3673
3674template <>
3675bool LLParser::ParseMDField(LocTy Loc, StringRef Name, LineField &Result) {
3676 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3677}
3678template <>
3679bool LLParser::ParseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
3680 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3681}
3682
3683template <>
3684bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
3685 if (Lex.getKind() == lltok::APSInt)
3686 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3687
3688 if (Lex.getKind() != lltok::DwarfTag)
3689 return TokError("expected DWARF tag");
3690
3691 unsigned Tag = dwarf::getTag(Lex.getStrVal());
3692 if (Tag == dwarf::DW_TAG_invalid)
3693 return TokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
3694 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3694, __extension__ __PRETTY_FUNCTION__))
;
3695
3696 Result.assign(Tag);
3697 Lex.Lex();
3698 return false;
3699}
3700
3701template <>
3702bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3703 DwarfMacinfoTypeField &Result) {
3704 if (Lex.getKind() == lltok::APSInt)
3705 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3706
3707 if (Lex.getKind() != lltok::DwarfMacinfo)
3708 return TokError("expected DWARF macinfo type");
3709
3710 unsigned Macinfo = dwarf::getMacinfo(Lex.getStrVal());
3711 if (Macinfo == dwarf::DW_MACINFO_invalid)
3712 return TokError(
3713 "invalid DWARF macinfo type" + Twine(" '") + Lex.getStrVal() + "'");
3714 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3714, __extension__ __PRETTY_FUNCTION__))
;
3715
3716 Result.assign(Macinfo);
3717 Lex.Lex();
3718 return false;
3719}
3720
3721template <>
3722bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3723 DwarfVirtualityField &Result) {
3724 if (Lex.getKind() == lltok::APSInt)
3725 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3726
3727 if (Lex.getKind() != lltok::DwarfVirtuality)
3728 return TokError("expected DWARF virtuality code");
3729
3730 unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
3731 if (Virtuality == dwarf::DW_VIRTUALITY_invalid)
3732 return TokError("invalid DWARF virtuality code" + Twine(" '") +
3733 Lex.getStrVal() + "'");
3734 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3734, __extension__ __PRETTY_FUNCTION__))
;
3735 Result.assign(Virtuality);
3736 Lex.Lex();
3737 return false;
3738}
3739
3740template <>
3741bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
3742 if (Lex.getKind() == lltok::APSInt)
3743 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3744
3745 if (Lex.getKind() != lltok::DwarfLang)
3746 return TokError("expected DWARF language");
3747
3748 unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
3749 if (!Lang)
3750 return TokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
3751 "'");
3752 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3752, __extension__ __PRETTY_FUNCTION__))
;
3753 Result.assign(Lang);
3754 Lex.Lex();
3755 return false;
3756}
3757
3758template <>
3759bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
3760 if (Lex.getKind() == lltok::APSInt)
3761 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3762
3763 if (Lex.getKind() != lltok::DwarfCC)
3764 return TokError("expected DWARF calling convention");
3765
3766 unsigned CC = dwarf::getCallingConvention(Lex.getStrVal());
3767 if (!CC)
3768 return TokError("invalid DWARF calling convention" + Twine(" '") + Lex.getStrVal() +
3769 "'");
3770 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3770, __extension__ __PRETTY_FUNCTION__))
;
3771 Result.assign(CC);
3772 Lex.Lex();
3773 return false;
3774}
3775
3776template <>
3777bool LLParser::ParseMDField(LocTy Loc, StringRef Name, EmissionKindField &Result) {
3778 if (Lex.getKind() == lltok::APSInt)
3779 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3780
3781 if (Lex.getKind() != lltok::EmissionKind)
3782 return TokError("expected emission kind");
3783
3784 auto Kind = DICompileUnit::getEmissionKind(Lex.getStrVal());
3785 if (!Kind)
3786 return TokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() +
3787 "'");
3788 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3788, __extension__ __PRETTY_FUNCTION__))
;
3789 Result.assign(*Kind);
3790 Lex.Lex();
3791 return false;
3792}
3793
3794template <>
3795bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3796 DwarfAttEncodingField &Result) {
3797 if (Lex.getKind() == lltok::APSInt)
3798 return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3799
3800 if (Lex.getKind() != lltok::DwarfAttEncoding)
3801 return TokError("expected DWARF type attribute encoding");
3802
3803 unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
3804 if (!Encoding)
3805 return TokError("invalid DWARF type attribute encoding" + Twine(" '") +
3806 Lex.getStrVal() + "'");
3807 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3807, __extension__ __PRETTY_FUNCTION__))
;
3808 Result.assign(Encoding);
3809 Lex.Lex();
3810 return false;
3811}
3812
3813/// DIFlagField
3814/// ::= uint32
3815/// ::= DIFlagVector
3816/// ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
3817template <>
3818bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
3819
3820 // Parser for a single flag.
3821 auto parseFlag = [&](DINode::DIFlags &Val) {
3822 if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
3823 uint32_t TempVal = static_cast<uint32_t>(Val);
3824 bool Res = ParseUInt32(TempVal);
3825 Val = static_cast<DINode::DIFlags>(TempVal);
3826 return Res;
3827 }
3828
3829 if (Lex.getKind() != lltok::DIFlag)
3830 return TokError("expected debug info flag");
3831
3832 Val = DINode::getFlag(Lex.getStrVal());
3833 if (!Val)
3834 return TokError(Twine("invalid debug info flag flag '") +
3835 Lex.getStrVal() + "'");
3836 Lex.Lex();
3837 return false;
3838 };
3839
3840 // Parse the flags and combine them together.
3841 DINode::DIFlags Combined = DINode::FlagZero;
3842 do {
3843 DINode::DIFlags Val;
3844 if (parseFlag(Val))
3845 return true;
3846 Combined |= Val;
3847 } while (EatIfPresent(lltok::bar));
3848
3849 Result.assign(Combined);
3850 return false;
3851}
3852
3853template <>
3854bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3855 MDSignedField &Result) {
3856 if (Lex.getKind() != lltok::APSInt)
3857 return TokError("expected signed integer");
3858
3859 auto &S = Lex.getAPSIntVal();
3860 if (S < Result.Min)
3861 return TokError("value for '" + Name + "' too small, limit is " +
3862 Twine(Result.Min));
3863 if (S > Result.Max)
3864 return TokError("value for '" + Name + "' too large, limit is " +
3865 Twine(Result.Max));
3866 Result.assign(S.getExtValue());
3867 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3867, __extension__ __PRETTY_FUNCTION__))
;
3868 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~svn325874/lib/AsmParser/LLParser.cpp"
, 3868, __extension__ __PRETTY_FUNCTION__))
;
3869 Lex.Lex();
3870 return false;
3871}
3872
3873template <>
3874bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
3875 switch (Lex.getKind()) {
3876 default:
3877 return TokError("expected 'true' or 'false'");
3878 case lltok::kw_true:
3879 Result.assign(true);
3880 break;
3881 case lltok::kw_false:
3882 Result.assign(false);
3883 break;
3884 }
3885 Lex.Lex();
3886 return false;
3887}
3888
3889template <>
3890bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDField &Result) {
3891 if (Lex.getKind() == lltok::kw_null) {
3892 if (!Result.AllowNull)
3893 return TokError("'" + Name + "' cannot be null");
3894 Lex.Lex();
3895 Result.assign(nullptr);
3896 return false;
3897 }
3898
3899 Metadata *MD;
3900 if (ParseMetadata(MD, nullptr))
3901 return true;
3902
3903 Result.assign(MD);
3904 return false;
3905}
3906
3907template <>
3908bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3909 MDSignedOrMDField &Result) {
3910 // Try to parse a signed int.
3911 if (Lex.getKind() == lltok::APSInt) {
3912 MDSignedField Res = Result.A;
3913 if (!ParseMDField(Loc, Name, Res)) {
3914 Result.assign(Res);
3915 return false;
3916 }
3917 return true;
3918 }
3919
3920 // Otherwise, try to parse as an MDField.
3921 MDField Res = Result.B;
3922 if (!ParseMDField(Loc, Name, Res)) {
3923 Result.assign(Res);
3924 return false;
3925 }
3926
3927 return true;
3928}
3929
3930template <>
3931bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3932 MDSignedOrUnsignedField &Result) {
3933 if (Lex.getKind() != lltok::APSInt)
3934 return false;
3935
3936 if (Lex.getAPSIntVal().isSigned()) {
3937 MDSignedField Res = Result.A;
3938 if (ParseMDField(Loc, Name, Res))
3939 return true;
3940 Result.assign(Res);
3941 return false;
3942 }
3943
3944 MDUnsignedField Res = Result.B;
3945 if (ParseMDField(Loc, Name, Res))
3946 return true;
3947 Result.assign(Res);
3948 return false;
3949}
3950
3951template <>
3952bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
3953 LocTy ValueLoc = Lex.getLoc();
3954 std::string S;
3955 if (ParseStringConstant(S))
3956 return true;
3957
3958 if (!Result.AllowEmpty && S.empty())
3959 return Error(ValueLoc, "'" + Name + "' cannot be empty");
3960
3961 Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
3962 return false;
3963}
3964
3965template <>
3966bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
3967 SmallVector<Metadata *, 4> MDs;
3968 if (ParseMDNodeVector(MDs))
3969 return true;
3970
3971 Result.assign(std::move(MDs));
3972 return false;
3973}
3974
3975template <>
3976bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3977 ChecksumKindField &Result) {
3978 Optional<DIFile::ChecksumKind> CSKind =
3979 DIFile::getChecksumKind(Lex.getStrVal());
3980
3981 if (Lex.getKind() != lltok::ChecksumKind || !CSKind)
3982 return TokError(
3983 "invalid checksum kind" + Twine(" '") + Lex.getStrVal() + "'");
3984
3985 Result.assign(*CSKind);
3986 Lex.Lex();
3987 return false;
3988}
3989
3990} // end namespace llvm
3991
3992template <class ParserTy>
3993bool LLParser::ParseMDFieldsImplBody(ParserTy parseField) {
3994 do {
3995 if (Lex.getKind() != lltok::LabelStr)
3996 return TokError("expected field label here");
3997
3998 if (parseField())
3999 return true;
4000 } while (EatIfPresent(lltok::comma));
4001
4002 return false;
4003}
4004
4005template <class ParserTy>
4006bool LLParser::ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc) {
4007 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~svn325874/lib/AsmParser/LLParser.cpp"
, 4007, __extension__ __PRETTY_FUNCTION__))
;
48
Within the expansion of the macro 'assert':
a
Calling 'LLLexer::getKind'
b
Returning from 'LLLexer::getKind'
4008 Lex.Lex();
49
Calling 'LLLexer::Lex'
50
Returning from 'LLLexer::Lex'
4009
4010 if (ParseToken(lltok::lparen, "expected '(' here"))
51
Calling 'LLParser::ParseToken'
58
Returning from 'LLParser::ParseToken'
59
Taking false branch
4011 return true;
4012 if (Lex.getKind() != lltok::rparen)
60
Calling 'LLLexer::getKind'
61
Returning from 'LLLexer::getKind'
62
Assuming the condition is false
63
Taking false branch
4013 if (ParseMDFieldsImplBody(parseField))
4014 return true;
4015
4016 ClosingLoc = Lex.getLoc();
64
Calling 'LLLexer::getLoc'
69
Returning from 'LLLexer::getLoc'
4017 return ParseToken(lltok::rparen, "expected ')' here");
70
Calling 'LLParser::ParseToken'
76
Returning from 'LLParser::ParseToken'
4018}
4019
4020template <class FieldTy>
4021bool LLParser::ParseMDField(StringRef Name, FieldTy &Result) {
4022 if (Result.Seen)
4023 return TokError("field '" + Name + "' cannot be specified more than once");
4024
4025 LocTy Loc = Lex.getLoc();
4026 Lex.Lex();
4027 return ParseMDField(Loc, Name, Result);
4028}
4029
4030bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
4031 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~svn325874/lib/AsmParser/LLParser.cpp"
, 4031, __extension__ __PRETTY_FUNCTION__))
;
8
Within the expansion of the macro 'assert':
a
Calling 'LLLexer::getKind'
b
Returning from 'LLLexer::getKind'
4032
4033#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4034 if (Lex.getStrVal() == #CLASS) \
4035 return Parse##CLASS(N, IsDistinct);
4036#include "llvm/IR/Metadata.def"
4037
4038 return TokError("expected metadata type");
4039}
4040
4041#define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4042#define NOP_FIELD(NAME, TYPE, INIT)
4043#define REQUIRE_FIELD(NAME, TYPE, INIT) \
4044 if (!NAME.Seen) \
4045 return Error(ClosingLoc, "missing required field '" #NAME "'");
4046#define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4047 if (Lex.getStrVal() == #NAME) \
4048 return ParseMDField(#NAME, NAME);
4049#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)
\
4050 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4051 do { \
4052 LocTy ClosingLoc; \
4053 if (ParseMDFieldsImpl([&]() -> bool { \
4054 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4055 return TokError(Twine("invalid field '") + Lex.getStrVal() + "'"); \
4056 }, ClosingLoc)) \
4057 return true; \
4058 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4059 } while (false)
4060#define GET_OR_DISTINCT(CLASS, ARGS)(IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS) \
4061 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4062
4063/// ParseDILocationFields:
4064/// ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6)
4065bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
4066#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4067 OPTIONAL(line, LineField, ); \
4068 OPTIONAL(column, ColumnField, ); \
4069 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4070 OPTIONAL(inlinedAt, MDField, );
4071 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)
;
4072#undef VISIT_MD_FIELDS
4073
4074 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))
4075 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))
;
4076 return false;
4077}
4078
4079/// ParseGenericDINode:
4080/// ::= !GenericDINode(tag: 15, header: "...", operands: {...})
4081bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
4082#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4083 REQUIRED(tag, DwarfTagField, ); \
4084 OPTIONAL(header, MDStringField, ); \
4085 OPTIONAL(operands, MDFieldList, );
4086 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)
;
4087#undef VISIT_MD_FIELDS
4088
4089 Result = GET_OR_DISTINCT(GenericDINode,(IsDistinct ? GenericDINode::getDistinct (Context, tag.Val, header
.Val, operands.Val) : GenericDINode::get (Context, tag.Val, header
.Val, operands.Val))
4090 (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))
;
4091 return false;
4092}
4093
4094/// ParseDISubrange:
4095/// ::= !DISubrange(count: 30, lowerBound: 2)
4096/// ::= !DISubrange(count: !node, lowerBound: 2)
4097bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
4098#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4099 REQUIRED(count, MDSignedOrMDField, (-1, -1, INT64_MAX(9223372036854775807L), false)); \
4100 OPTIONAL(lowerBound, MDSignedField, );
4101 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)
;
4102#undef VISIT_MD_FIELDS
4103
4104 if (count.isMDSignedField())
4105 Result = GET_OR_DISTINCT((IsDistinct ? DISubrange::getDistinct (Context, count.getMDSignedValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDSignedValue
(), lowerBound.Val))
4106 DISubrange, (Context, count.getMDSignedValue(), lowerBound.Val))(IsDistinct ? DISubrange::getDistinct (Context, count.getMDSignedValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDSignedValue
(), lowerBound.Val))
;
4107 else if (count.isMDField())
4108 Result = GET_OR_DISTINCT((IsDistinct ? DISubrange::getDistinct (Context, count.getMDFieldValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDFieldValue
(), lowerBound.Val))
4109 DISubrange, (Context, count.getMDFieldValue(), lowerBound.Val))(IsDistinct ? DISubrange::getDistinct (Context, count.getMDFieldValue
(), lowerBound.Val) : DISubrange::get (Context, count.getMDFieldValue
(), lowerBound.Val))
;
4110 else
4111 return true;
4112
4113 return false;
4114}
4115
4116/// ParseDIEnumerator:
4117/// ::= !DIEnumerator(value: 30, isUnsigned: true, name: "SomeKind")
4118bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
4119#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4120 REQUIRED(name, MDStringField, ); \
4121 REQUIRED(value, MDSignedOrUnsignedField, ); \
4122 OPTIONAL(isUnsigned, MDBoolField, (false));
4123 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)
;
21
Within the expansion of the macro 'PARSE_MD_FIELDS':
a
Calling default constructor for 'MDStringField'
b
Returning from default constructor for 'MDStringField'
c
Calling default constructor for 'MDSignedOrUnsignedField'
d
Returning from default constructor for 'MDSignedOrUnsignedField'
e
Calling default constructor for 'MDBoolField'
f
Returning from default constructor for 'MDBoolField'
g
Calling defaulted default constructor for 'SMLoc'
h
Returning from default constructor for 'SMLoc'
i
Calling 'LLParser::ParseMDFieldsImpl'
j
Returning from 'LLParser::ParseMDFieldsImpl'
k
Calling constructor for 'Twine'
l
Returning from constructor for 'Twine'
m
Calling 'LLParser::Error'
n
Returning from 'LLParser::Error'
4124#undef VISIT_MD_FIELDS
4125
4126 if (isUnsigned.Val && value.isMDSignedField())
4127 return TokError("unsigned enumerator with negative value");
4128
4129 int64_t Value = value.isMDSignedField()
4130 ? value.getMDSignedValue()
4131 : static_cast<int64_t>(value.getMDUnsignedValue());
4132 Result =
4133 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))
;
4134
4135 return false;
4136}
4137
4138/// ParseDIBasicType:
4139/// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
4140bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
4141#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4142 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
4143 OPTIONAL(name, MDStringField, ); \
4144 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4145 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4146 OPTIONAL(encoding, DwarfAttEncodingField, );
4147 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)
;
4148#undef VISIT_MD_FIELDS
4149
4150 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
))
4151 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
))
;
4152 return false;
4153}
4154
4155/// ParseDIDerivedType:
4156/// ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
4157/// line: 7, scope: !1, baseType: !2, size: 32,
4158/// align: 32, offset: 0, flags: 0, extraData: !3,
4159/// dwarfAddressSpace: 3)
4160bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
4161#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4162 REQUIRED(tag, DwarfTagField, ); \
4163 OPTIONAL(name, MDStringField, ); \
4164 OPTIONAL(file, MDField, ); \
4165 OPTIONAL(line, LineField, ); \
4166 OPTIONAL(scope, MDField, ); \
4167 REQUIRED(baseType, MDField, ); \
4168 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4169 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4170 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4171 OPTIONAL(flags, DIFlagField, ); \
4172 OPTIONAL(extraData, MDField, ); \
4173 OPTIONAL(dwarfAddressSpace, MDUnsignedField, (UINT32_MAX(4294967295U), UINT32_MAX(4294967295U)));
4174 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)
;
4175#undef VISIT_MD_FIELDS
4176
4177 Optional<unsigned> DWARFAddressSpace;
4178 if (dwarfAddressSpace.Val != UINT32_MAX(4294967295U))
4179 DWARFAddressSpace = dwarfAddressSpace.Val;
4180
4181 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))
4182 (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))
4183 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))
4184 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))
4185 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))
;
4186 return false;
4187}
4188
4189bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
4190#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4191 REQUIRED(tag, DwarfTagField, ); \
4192 OPTIONAL(name, MDStringField, ); \
4193 OPTIONAL(file, MDField, ); \
4194 OPTIONAL(line, LineField, ); \
4195 OPTIONAL(scope, MDField, ); \
4196 OPTIONAL(baseType, MDField, ); \
4197 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4198 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4199 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX(18446744073709551615UL))); \
4200 OPTIONAL(flags, DIFlagField, ); \
4201 OPTIONAL(elements, MDField, ); \
4202 OPTIONAL(runtimeLang, DwarfLangField, ); \
4203 OPTIONAL(vtableHolder, MDField, ); \
4204 OPTIONAL(templateParams, MDField, ); \
4205 OPTIONAL(identifier, MDStringField, ); \
4206 OPTIONAL(discriminator, MDField, );
4207 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)
;
4208#undef VISIT_MD_FIELDS
4209
4210 // If this has an identifier try to build an ODR type.
4211 if (identifier.Val)
4212 if (auto *CT = DICompositeType::buildODRType(
4213 Context, *identifier.Val, tag.Val, name.Val, file.Val, line.Val,
4214 scope.Val, baseType.Val, size.Val, align.Val, offset.Val, flags.Val,
4215 elements.Val, runtimeLang.Val, vtableHolder.Val,
4216 templateParams.Val, discriminator.Val)) {
4217 Result = CT;
4218 return false;
4219 }
4220
4221 // Create a new node, and save it in the context if it belongs in the type
4222 // map.
4223 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))
4224 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))
4225 (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))
4226 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))
4227 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))
4228 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))
;
4229 return false;
4230}
4231
4232bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
4233#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4234 OPTIONAL(flags, DIFlagField, ); \
4235 OPTIONAL(cc, DwarfCCField, ); \
4236 REQUIRED(types, MDField, );
4237 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)
;
4238#undef VISIT_MD_FIELDS
4239
4240 Result = GET_OR_DISTINCT(DISubroutineType,(IsDistinct ? DISubroutineType::getDistinct (Context, flags.Val
, cc.Val, types.Val) : DISubroutineType::get (Context, flags.
Val, cc.Val, types.Val))
4241 (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))
;
4242 return false;
4243}
4244
4245/// ParseDIFileType:
4246/// ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir"
4247/// checksumkind: CSK_MD5,
4248/// checksum: "000102030405060708090a0b0c0d0e0f")
4249bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
4250 // The default constructed value for checksumkind is required, but will never
4251 // be used, as the parser checks if the field was actually Seen before using
4252 // the Val.
4253#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4254 REQUIRED(filename, MDStringField, ); \
4255 REQUIRED(directory, MDStringField, ); \
4256 OPTIONAL(checksumkind, ChecksumKindField, (DIFile::CSK_MD5)); \
4257 OPTIONAL(checksum, MDStringField, );
4258 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)
;
4259#undef VISIT_MD_FIELDS
4260
4261 Optional<DIFile::ChecksumInfo<MDString *>> OptChecksum;
4262 if (checksumkind.Seen && checksum.Seen)
4263 OptChecksum.emplace(checksumkind.Val, checksum.Val);
4264 else if (checksumkind.Seen || checksum.Seen)
4265 return Lex.Error("'checksumkind' and 'checksum' must be provided together");
4266
4267 Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val,(IsDistinct ? DIFile::getDistinct (Context, filename.Val, directory
.Val, OptChecksum) : DIFile::get (Context, filename.Val, directory
.Val, OptChecksum))
4268 OptChecksum))(IsDistinct ? DIFile::getDistinct (Context, filename.Val, directory
.Val, OptChecksum) : DIFile::get (Context, filename.Val, directory
.Val, OptChecksum))
;
4269 return false;
4270}
4271
4272/// ParseDICompileUnit:
4273/// ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
4274/// isOptimized: true, flags: "-O2", runtimeVersion: 1,
4275/// splitDebugFilename: "abc.debug",
4276/// emissionKind: FullDebug, enums: !1, retainedTypes: !2,
4277/// globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd)
4278bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
4279 if (!IsDistinct)
4280 return Lex.Error("missing 'distinct', required for !DICompileUnit");
4281
4282#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4283 REQUIRED(language, DwarfLangField, ); \
4284 REQUIRED(file, MDField, (/* AllowNull */ false)); \
4285 OPTIONAL(producer, MDStringField, ); \
4286 OPTIONAL(isOptimized, MDBoolField, ); \
4287 OPTIONAL(flags, MDStringField, ); \
4288 OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4289 OPTIONAL(splitDebugFilename, MDStringField, ); \
4290 OPTIONAL(emissionKind, EmissionKindField, ); \
4291 OPTIONAL(enums, MDField, ); \
4292 OPTIONAL(retainedTypes, MDField, ); \
4293 OPTIONAL(globals, MDField, ); \
4294 OPTIONAL(imports, MDField, ); \
4295 OPTIONAL(macros, MDField, ); \
4296 OPTIONAL(dwoId, MDUnsignedField, ); \
4297 OPTIONAL(splitDebugInlining, MDBoolField, = true); \
4298 OPTIONAL(debugInfoForProfiling, MDBoolField, = false); \
4299 OPTIONAL(gnuPubnames, MDBoolField, = false);
4300 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)
;
4301#undef VISIT_MD_FIELDS
4302
4303 Result = DICompileUnit::getDistinct(
4304 Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
4305 runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
4306 retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
4307 splitDebugInlining.Val, debugInfoForProfiling.Val, gnuPubnames.Val);
4308 return false;
4309}
4310
4311/// ParseDISubprogram:
4312/// ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
4313/// file: !1, line: 7, type: !2, isLocal: false,
4314/// isDefinition: true, scopeLine: 8, containingType: !3,
4315/// virtuality: DW_VIRTUALTIY_pure_virtual,
4316/// virtualIndex: 10, thisAdjustment: 4, flags: 11,
4317/// isOptimized: false, templateParams: !4, declaration: !5,
4318/// variables: !6, thrownTypes: !7)
4319bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
4320 auto Loc = Lex.getLoc();
4321#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4322 OPTIONAL(scope, MDField, ); \
4323 OPTIONAL(name, MDStringField, ); \
4324 OPTIONAL(linkageName, MDStringField, ); \
4325 OPTIONAL(file, MDField, ); \
4326 OPTIONAL(line, LineField, ); \
4327 OPTIONAL(type, MDField, ); \
4328 OPTIONAL(isLocal, MDBoolField, ); \
4329 OPTIONAL(isDefinition, MDBoolField, (true)); \
4330 OPTIONAL(scopeLine, LineField, ); \
4331 OPTIONAL(containingType, MDField, ); \
4332 OPTIONAL(virtuality, DwarfVirtualityField, ); \
4333 OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4334 OPTIONAL(thisAdjustment, MDSignedField, (0, INT32_MIN(-2147483647-1), INT32_MAX(2147483647))); \
4335 OPTIONAL(flags, DIFlagField, ); \
4336 OPTIONAL(isOptimized, MDBoolField, ); \
4337 OPTIONAL(unit, MDField, ); \
4338 OPTIONAL(templateParams, MDField, ); \
4339 OPTIONAL(declaration, MDField, ); \
4340 OPTIONAL(variables, MDField, ); \
4341 OPTIONAL(thrownTypes, MDField, );
4342 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)
;
4343#undef VISIT_MD_FIELDS
4344
4345 if (isDefinition.Val && !IsDistinct)
4346 return Lex.Error(
4347 Loc,
4348 "missing 'distinct', required for !DISubprogram when 'isDefinition'");
4349
4350 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))
4351 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))
4352 (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))
4353 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))
4354 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))
4355 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))
4356 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))
;
4357 return false;
4358}
4359
4360/// ParseDILexicalBlock:
4361/// ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
4362bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
4363#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4364 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4365 OPTIONAL(file, MDField, ); \
4366 OPTIONAL(line, LineField, ); \
4367 OPTIONAL(column, ColumnField, );
4368 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)
;
4369#undef VISIT_MD_FIELDS
4370
4371 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))
4372 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))
;
4373 return false;
4374}
4375
4376/// ParseDILexicalBlockFile:
4377/// ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
4378bool LLParser::ParseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
4379#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4380 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4381 OPTIONAL(file, MDField, ); \
4382 REQUIRED(discriminator, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4383 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)
;
4384#undef VISIT_MD_FIELDS
4385
4386 Result = GET_OR_DISTINCT(DILexicalBlockFile,(IsDistinct ? DILexicalBlockFile::getDistinct (Context, scope
.Val, file.Val, discriminator.Val) : DILexicalBlockFile::get (
Context, scope.Val, file.Val, discriminator.Val))
4387 (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))
;
4388 return false;
4389}
4390
4391/// ParseDINamespace:
4392/// ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
4393bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
4394#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4395 REQUIRED(scope, MDField, ); \
4396 OPTIONAL(name, MDStringField, ); \
4397 OPTIONAL(exportSymbols, MDBoolField, );
4398 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)
;
4399#undef VISIT_MD_FIELDS
4400
4401 Result = GET_OR_DISTINCT(DINamespace,(IsDistinct ? DINamespace::getDistinct (Context, scope.Val, name
.Val, exportSymbols.Val) : DINamespace::get (Context, scope.Val
, name.Val, exportSymbols.Val))
4402 (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))
;
4403 return false;
4404}
4405
4406/// ParseDIMacro:
4407/// ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value: "SomeValue")
4408bool LLParser::ParseDIMacro(MDNode *&Result, bool IsDistinct) {
4409#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4410 REQUIRED(type, DwarfMacinfoTypeField, ); \
4411 OPTIONAL(line, LineField, ); \
4412 REQUIRED(name, MDStringField, ); \
4413 OPTIONAL(value, MDStringField, );
4414 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)
;
4415#undef VISIT_MD_FIELDS
4416
4417 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))
4418 (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))
;
4419 return false;
4420}
4421
4422/// ParseDIMacroFile:
4423/// ::= !DIMacroFile(line: 9, file: !2, nodes: !3)
4424bool LLParser::ParseDIMacroFile(MDNode *&Result, bool IsDistinct) {
4425#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4426 OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file)); \
4427 OPTIONAL(line, LineField, ); \
4428 REQUIRED(file, MDField, ); \
4429 OPTIONAL(nodes, MDField, );
4430 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)
;
4431#undef VISIT_MD_FIELDS
4432
4433 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))
4434 (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))
;
4435 return false;
4436}
4437
4438/// ParseDIModule:
4439/// ::= !DIModule(scope: !0, name: "SomeModule", configMacros: "-DNDEBUG",
4440/// includePath: "/usr/include", isysroot: "/")
4441bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
4442#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4443 REQUIRED(scope, MDField, ); \
4444 REQUIRED(name, MDStringField, ); \
4445 OPTIONAL(configMacros, MDStringField, ); \
4446 OPTIONAL(includePath, MDStringField, ); \
4447 OPTIONAL(isysroot, MDStringField, );
4448 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)
;
4449#undef VISIT_MD_FIELDS
4450
4451 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))
4452 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))
;
4453 return false;
4454}
4455
4456/// ParseDITemplateTypeParameter:
4457/// ::= !DITemplateTypeParameter(name: "Ty", type: !1)
4458bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
4459#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4460 OPTIONAL(name, MDStringField, ); \
4461 REQUIRED(type, MDField, );
4462 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)
;
4463#undef VISIT_MD_FIELDS
4464
4465 Result =
4466 GET_OR_DISTINCT(DITemplateTypeParameter, (Context, name.Val, type.Val))(IsDistinct ? DITemplateTypeParameter::getDistinct (Context, name
.Val, type.Val) : DITemplateTypeParameter::get (Context, name
.Val, type.Val))
;
4467 return false;
4468}
4469
4470/// ParseDITemplateValueParameter:
4471/// ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
4472/// name: "V", type: !1, value: i32 7)
4473bool LLParser::ParseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
4474#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4475 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter)); \
4476 OPTIONAL(name, MDStringField, ); \
4477 OPTIONAL(type, MDField, ); \
4478 REQUIRED(value, MDField, );
4479 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)
;
4480#undef VISIT_MD_FIELDS
4481
4482 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))
4483 (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))
;
4484 return false;
4485}
4486
4487/// ParseDIGlobalVariable:
4488/// ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
4489/// file: !1, line: 7, type: !2, isLocal: false,
4490/// isDefinition: true, declaration: !3, align: 8)
4491bool LLParser::ParseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
4492#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4493 REQUIRED(name, MDStringField, (/* AllowEmpty */ false)); \
4494 OPTIONAL(scope, MDField, ); \
4495 OPTIONAL(linkageName, MDStringField, ); \
4496 OPTIONAL(file, MDField, ); \
4497 OPTIONAL(line, LineField, ); \
4498 OPTIONAL(type, MDField, ); \
4499 OPTIONAL(isLocal, MDBoolField, ); \
4500 OPTIONAL(isDefinition, MDBoolField, (true)); \
4501 OPTIONAL(declaration, MDField, ); \
4502 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4503 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)
;
4504#undef VISIT_MD_FIELDS
4505
4506 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))
4507 (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))
4508 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))
4509 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))
;
4510 return false;
4511}
4512
4513/// ParseDILocalVariable:
4514/// ::= !DILocalVariable(arg: 7, scope: !0, name: "foo",
4515/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
4516/// align: 8)
4517/// ::= !DILocalVariable(scope: !0, name: "foo",
4518/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
4519/// align: 8)
4520bool LLParser::ParseDILocalVariable(MDNode *&Result, bool IsDistinct) {
4521#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4522 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4523 OPTIONAL(name, MDStringField, ); \
4524 OPTIONAL(arg, MDUnsignedField, (0, UINT16_MAX(65535))); \
4525 OPTIONAL(file, MDField, ); \
4526 OPTIONAL(line, LineField, ); \
4527 OPTIONAL(type, MDField, ); \
4528 OPTIONAL(flags, DIFlagField, ); \
4529 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX(4294967295U)));
4530 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)
;
4531#undef VISIT_MD_FIELDS
4532
4533 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))
4534 (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))
4535 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))
;
4536 return false;
4537}
4538
4539/// ParseDIExpression:
4540/// ::= !DIExpression(0, 7, -1)
4541bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
4542 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~svn325874/lib/AsmParser/LLParser.cpp"
, 4542, __extension__ __PRETTY_FUNCTION__))
;
4543 Lex.Lex();
4544
4545 if (ParseToken(lltok::lparen, "expected '(' here"))
4546 return true;
4547
4548 SmallVector<uint64_t, 8> Elements;
4549 if (Lex.getKind() != lltok::rparen)
4550 do {
4551 if (Lex.getKind() == lltok::DwarfOp) {
4552 if (unsigned Op = dwarf::getOperationEncoding(Lex.getStrVal())) {
4553 Lex.Lex();
4554 Elements.push_back(Op);
4555 continue;
4556 }
4557 return TokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
4558 }
4559
4560 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
4561 return TokError("expected unsigned integer");
4562
4563 auto &U = Lex.getAPSIntVal();
4564 if (U.ugt(UINT64_MAX(18446744073709551615UL)))
4565 return TokError("element too large, limit is " + Twine(UINT64_MAX(18446744073709551615UL)));
4566 Elements.push_back(U.getZExtValue());
4567 Lex.Lex();
4568 } while (EatIfPresent(lltok::comma));
4569
4570 if (ParseToken(lltok::rparen, "expected ')' here"))
4571 return true;
4572
4573 Result = GET_OR_DISTINCT(DIExpression, (Context, Elements))(IsDistinct ? DIExpression::getDistinct (Context, Elements) :
DIExpression::get (Context, Elements))
;
4574 return false;
4575}
4576
4577/// ParseDIGlobalVariableExpression:
4578/// ::= !DIGlobalVariableExpression(var: !0, expr: !1)
4579bool LLParser::ParseDIGlobalVariableExpression(MDNode *&Result,
4580 bool IsDistinct) {
4581#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4582 REQUIRED(var, MDField, ); \
4583 REQUIRED(expr, MDField, );
4584 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)
;
4585#undef VISIT_MD_FIELDS
4586
4587 Result =
4588 GET_OR_DISTINCT(DIGlobalVariableExpression, (Context, var.Val, expr.Val))(IsDistinct ? DIGlobalVariableExpression::getDistinct (Context
, var.Val, expr.Val) : DIGlobalVariableExpression::get (Context
, var.Val, expr.Val))
;
4589 return false;
4590}
4591
4592/// ParseDIObjCProperty:
4593/// ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
4594/// getter: "getFoo", attributes: 7, type: !2)
4595bool LLParser::ParseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
4596#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4597 OPTIONAL(name, MDStringField, ); \
4598 OPTIONAL(file, MDField, ); \
4599 OPTIONAL(line, LineField, ); \
4600 OPTIONAL(setter, MDStringField, ); \
4601 OPTIONAL(getter, MDStringField, ); \
4602 OPTIONAL(attributes, MDUnsignedField, (0, UINT32_MAX(4294967295U))); \
4603 OPTIONAL(type, MDField, );
4604 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)
;
4605#undef VISIT_MD_FIELDS
4606
4607 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))
4608 (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))
4609 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))
;
4610 return false;
4611}
4612
4613/// ParseDIImportedEntity:
4614/// ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
4615/// line: 7, name: "foo")
4616bool LLParser::ParseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
4617#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4618 REQUIRED(tag, DwarfTagField, ); \
4619 REQUIRED(scope, MDField, ); \
4620 OPTIONAL(entity, MDField, ); \
4621 OPTIONAL(file, MDField, ); \
4622 OPTIONAL(line, LineField, ); \
4623 OPTIONAL(name, MDStringField, );
4624 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)
;
4625#undef VISIT_MD_FIELDS
4626
4627 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))
4628 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))
4629 (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))
;
4630 return false;
4631}
4632
4633#undef PARSE_MD_FIELD
4634#undef NOP_FIELD
4635#undef REQUIRE_FIELD
4636#undef DECLARE_FIELD
4637
4638/// ParseMetadataAsValue
4639/// ::= metadata i32 %local
4640/// ::= metadata i32 @global
4641/// ::= metadata i32 7
4642/// ::= metadata !0
4643/// ::= metadata !{...}
4644/// ::= metadata !"string"
4645bool LLParser::ParseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
4646 // Note: the type 'metadata' has already been parsed.
4647 Metadata *MD;
4648 if (ParseMetadata(MD, &PFS))
4649 return true;
4650
4651 V = MetadataAsValue::get(Context, MD);
4652 return false;
4653}
4654
4655/// ParseValueAsMetadata
4656/// ::= i32 %local
4657/// ::= i32 @global
4658/// ::= i32 7
4659bool LLParser::ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
4660 PerFunctionState *PFS) {
4661 Type *Ty;
4662 LocTy Loc;
4663 if (ParseType(Ty, TypeMsg, Loc))
4664 return true;
4665 if (Ty->isMetadataTy())
4666 return Error(Loc, "invalid metadata-value-metadata roundtrip");
4667
4668 Value *V;
4669 if (ParseValue(Ty, V, PFS))
4670 return true;
4671
4672 MD = ValueAsMetadata::get(V);
4673 return false;
4674}
4675
4676/// ParseMetadata
4677/// ::= i32 %local
4678/// ::= i32 @global
4679/// ::= i32 7
4680/// ::= !42
4681/// ::= !{...}
4682/// ::= !"string"
4683/// ::= !DILocation(...)
4684bool LLParser::ParseMetadata(Metadata *&MD, PerFunctionState *PFS) {
4685 if (Lex.getKind() == lltok::MetadataVar) {
4686 MDNode *N;
4687 if (ParseSpecializedMDNode(N))
4688 return true;
4689 MD = N;
4690 return false;
4691 }
4692
4693 // ValueAsMetadata:
4694 // <type> <value>
4695 if (Lex.getKind() != lltok::exclaim)
4696 return ParseValueAsMetadata(MD, "expected metadata operand", PFS);
4697
4698 // '!'.
4699 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~svn325874/lib/AsmParser/LLParser.cpp"
, 4699, __extension__ __PRETTY_FUNCTION__))
;
4700 Lex.Lex();
4701
4702 // MDString:
4703 // ::= '!' STRINGCONSTANT
4704 if (Lex.getKind() == lltok::StringConstant) {
4705 MDString *S;
4706 if (ParseMDString(S))
4707 return true;
4708 MD = S;
4709 return false;
4710 }
4711
4712 // MDNode:
4713 // !{ ... }
4714 // !7
4715 MDNode *N;
4716 if (ParseMDNodeTail(N))
4717 return true;
4718 MD = N;
4719 return false;
4720}
4721
4722//===----------------------------------------------------------------------===//
4723// Function Parsing.
4724//===----------------------------------------------------------------------===//
4725
4726bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
4727 PerFunctionState *PFS) {
4728 if (Ty->isFunctionTy())
4729 return Error(ID.Loc, "functions are not values, refer to them as pointers");
4730
4731 switch (ID.Kind) {
4732 case ValID::t_LocalID:
4733 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
4734 V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc);
4735 return V == nullptr;
4736 case ValID::t_LocalName:
4737 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
4738 V = PFS->GetVal(ID.StrVal, Ty, ID.Loc);
4739 return V == nullptr;
4740 case ValID::t_InlineAsm: {
4741 if (!ID.FTy || !InlineAsm::Verify(ID.FTy, ID.StrVal2))
4742 return Error(ID.Loc, "invalid type for inline asm constraint string");
4743 V = InlineAsm::get(ID.FTy, ID.StrVal, ID.StrVal2, ID.UIntVal & 1,
4744 (ID.UIntVal >> 1) & 1,
4745 (InlineAsm::AsmDialect(ID.UIntVal >> 2)));
4746 return false;
4747 }
4748 case ValID::t_GlobalName:
4749 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
4750 return V == nullptr;
4751 case ValID::t_GlobalID:
4752 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
4753 return V == nullptr;
4754 case ValID::t_APSInt:
4755 if (!Ty->isIntegerTy())
4756 return Error(ID.Loc, "integer constant must have integer type");
4757 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
4758 V = ConstantInt::get(Context, ID.APSIntVal);
4759 return false;
4760 case ValID::t_APFloat:
4761 if (!Ty->isFloatingPointTy() ||
4762 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
4763 return Error(ID.Loc, "floating point constant invalid for type");
4764
4765 // The lexer has no type info, so builds all half, float, and double FP
4766 // constants as double. Fix this here. Long double does not need this.
4767 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
4768 bool Ignored;
4769 if (Ty->isHalfTy())
4770 ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
4771 &Ignored);
4772 else if (Ty->isFloatTy())
4773 ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
4774 &Ignored);
4775 }
4776 V = ConstantFP::get(Context, ID.APFloatVal);
4777
4778 if (V->getType() != Ty)
4779 return Error(ID.Loc, "floating point constant does not have type '" +
4780 getTypeString(Ty) + "'");
4781
4782 return false;
4783 case ValID::t_Null:
4784 if (!Ty->isPointerTy())
4785 return Error(ID.Loc, "null must be a pointer type");
4786 V = ConstantPointerNull::get(cast<PointerType>(Ty));
4787 return false;
4788 case ValID::t_Undef:
4789 // FIXME: LabelTy should not be a first-class type.
4790 if (!Ty->isFirstClassType() || Ty->isLabelTy())
4791 return Error(ID.Loc, "invalid type for undef constant");
4792 V = UndefValue::get(Ty);
4793 return false;
4794 case ValID::t_EmptyArray:
4795 if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
4796 return Error(ID.Loc, "invalid empty array initializer");
4797 V = UndefValue::get(Ty);
4798 return false;
4799 case ValID::t_Zero:
4800 // FIXME: LabelTy should not be a first-class type.
4801 if (!Ty->isFirstClassType() || Ty->isLabelTy())
4802 return Error(ID.Loc, "invalid type for null constant");
4803 V = Constant::getNullValue(Ty);
4804 return false;
4805 case ValID::t_None:
4806 if (!Ty->isTokenTy())
4807 return Error(ID.Loc, "invalid type for none constant");
4808 V = Constant::getNullValue(Ty);
4809 return false;
4810 case ValID::t_Constant:
4811 if (ID.ConstantVal->getType() != Ty)
4812 return Error(ID.Loc, "constant expression type mismatch");
4813
4814 V = ID.ConstantVal;
4815 return false;
4816 case ValID::t_ConstantStruct:
4817 case ValID::t_PackedConstantStruct:
4818 if (StructType *ST = dyn_cast<StructType>(Ty)) {
4819 if (ST->getNumElements() != ID.UIntVal)
4820 return Error(ID.Loc,
4821 "initializer with struct type has wrong # elements");
4822 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
4823 return Error(ID.Loc, "packed'ness of initializer and type don't match");
4824
4825 // Verify that the elements are compatible with the structtype.
4826 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
4827 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
4828 return Error(ID.Loc, "element " + Twine(i) +
4829 " of struct initializer doesn't match struct element type");
4830
4831 V = ConstantStruct::get(
4832 ST, makeArrayRef(ID.ConstantStructElts.get(), ID.UIntVal));
4833 } else
4834 return Error(ID.Loc, "constant expression type mismatch");
4835 return false;
4836 }
4837 llvm_unreachable("Invalid ValID")::llvm::llvm_unreachable_internal("Invalid ValID", "/build/llvm-toolchain-snapshot-7~svn325874/lib/AsmParser/LLParser.cpp"
, 4837)
;
4838}
4839
4840bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
4841 C = nullptr;
4842 ValID ID;
4843 auto Loc = Lex.getLoc();
4844 if (ParseValID(ID, /*PFS=*/nullptr))
4845 return true;
4846 switch (ID.Kind) {
4847 case ValID::t_APSInt:
4848 case ValID::t_APFloat:
4849 case ValID::t_Undef:
4850 case ValID::t_Constant:
4851 case ValID::t_ConstantStruct:
4852 case ValID::t_PackedConstantStruct: {
4853 Value *V;
4854 if (ConvertValIDToValue(Ty, ID, V, /*PFS=*/nullptr))
4855 return true;
4856 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~svn325874/lib/AsmParser/LLParser.cpp"
, 4856, __extension__ __PRETTY_FUNCTION__))
;
4857 C = cast<Constant>(V);
4858 return false;
4859 }
4860 case ValID::t_Null:
4861 C = Constant::getNullValue(Ty);
4862 return false;
4863 default:
4864 return Error(Loc, "expected a constant value");
4865 }
4866}
4867
4868bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
4869 V = nullptr;
4870 ValID ID;
4871 return ParseValID(ID, PFS) || ConvertValIDToValue(Ty, ID, V, PFS);
4872}
4873
4874bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) {
4875 Type *Ty = nullptr;
4876 return ParseType(Ty) ||
4877 ParseValue(Ty, V, PFS);
4878}
4879
4880bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
4881 PerFunctionState &PFS) {
4882 Value *V;
4883 Loc = Lex.getLoc();
4884 if (ParseTypeAndValue(V, PFS)) return true;
4885 if (!isa<BasicBlock>(V))
4886 return Error(Loc, "expected a basic block");
4887 BB = cast<BasicBlock>(V);
4888 return false;
4889}
4890
4891/// FunctionHeader
4892/// ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
4893/// OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
4894/// '(' ArgList ')' OptFuncAttrs OptSection OptionalAlign OptGC
4895/// OptionalPrefix OptionalPrologue OptPersonalityFn
4896bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
4897 // Parse the linkage.
4898 LocTy LinkageLoc = Lex.getLoc();
4899 unsigned Linkage;
4900 unsigned Visibility;
4901 unsigned DLLStorageClass;
4902 bool DSOLocal;
4903 AttrBuilder RetAttrs;
4904 unsigned CC;
4905 bool HasLinkage;
4906 Type *RetType = nullptr;
4907 LocTy RetTypeLoc = Lex.getLoc();
4908 if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
4909 DSOLocal) ||
4910 ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
4911 ParseType(RetType, RetTypeLoc, true /*void allowed*/))
4912 return true;
4913
4914 // Verify that the linkage is ok.
4915 switch ((GlobalValue::LinkageTypes)Linkage) {
4916 case GlobalValue::ExternalLinkage:
4917 break; // always ok.
4918 case GlobalValue::ExternalWeakLinkage:
4919 if (isDefine)
4920 return Error(LinkageLoc, "invalid linkage for function definition");
4921 break;
4922 case GlobalValue::PrivateLinkage:
4923 case GlobalValue::InternalLinkage:
4924 case GlobalValue::AvailableExternallyLinkage:
4925 case GlobalValue::LinkOnceAnyLinkage:
4926 case GlobalValue::LinkOnceODRLinkage:
4927 case GlobalValue::WeakAnyLinkage:
4928 case GlobalValue::WeakODRLinkage:
4929 if (!isDefine)
4930 return Error(LinkageLoc, "invalid linkage for function declaration");
4931 break;
4932 case GlobalValue::AppendingLinkage:
4933 case GlobalValue::CommonLinkage:
4934 return Error(LinkageLoc, "invalid function linkage type");
4935 }
4936
4937 if (!isValidVisibilityForLinkage(Visibility, Linkage))
4938 return Error(LinkageLoc,
4939 "symbol with local linkage must have default visibility");
4940
4941 if (!FunctionType::isValidReturnType(RetType))
4942 return Error(RetTypeLoc, "invalid function return type");
4943
4944 LocTy NameLoc = Lex.getLoc();
4945
4946 std::string FunctionName;
4947 if (Lex.getKind() == lltok::GlobalVar) {
4948 FunctionName = Lex.getStrVal();
4949 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
4950 unsigned NameID = Lex.getUIntVal();
4951
4952 if (NameID != NumberedVals.size())
4953 return TokError("function expected to be numbered '%" +
4954 Twine(NumberedVals.size()) + "'");
4955 } else {
4956 return TokError("expected function name");
4957 }
4958
4959 Lex.Lex();
4960
4961 if (Lex.getKind() != lltok::lparen)
4962 return TokError("expected '(' in function argument list");
4963
4964 SmallVector<ArgInfo, 8> ArgList;
4965 bool isVarArg;
4966 AttrBuilder FuncAttrs;
4967 std::vector<unsigned> FwdRefAttrGrps;
4968 LocTy BuiltinLoc;
4969 std::string Section;
4970 unsigned Alignment;
4971 std::string GC;
4972 GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
4973 Constant *Prefix = nullptr;
4974 Constant *Prologue = nullptr;
4975 Constant *PersonalityFn = nullptr;
4976 Comdat *C;
4977
4978 if (ParseArgumentList(ArgList, isVarArg) ||
4979 ParseOptionalUnnamedAddr(UnnamedAddr) ||
4980 ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
4981 BuiltinLoc) ||
4982 (EatIfPresent(lltok::kw_section) &&
4983 ParseStringConstant(Section)) ||
4984 parseOptionalComdat(FunctionName, C) ||
4985 ParseOptionalAlignment(Alignment) ||
4986 (EatIfPresent(lltok::kw_gc) &&
4987 ParseStringConstant(GC)) ||
4988 (EatIfPresent(lltok::kw_prefix) &&
4989 ParseGlobalTypeAndValue(Prefix)) ||
4990 (EatIfPresent(lltok::kw_prologue) &&
4991 ParseGlobalTypeAndValue(Prologue)) ||
4992 (EatIfPresent(lltok::kw_personality) &&
4993 ParseGlobalTypeAndValue(PersonalityFn)))
4994 return true;
4995
4996 if (FuncAttrs.contains(Attribute::Builtin))
4997 return Error(BuiltinLoc, "'builtin' attribute not valid on function");
4998
4999 // If the alignment was parsed as an attribute, move to the alignment field.
5000 if (FuncAttrs.hasAlignmentAttr()) {
5001 Alignment = FuncAttrs.getAlignment();
5002 FuncAttrs.removeAttribute(Attribute::Alignment);
5003 }
5004
5005 // Okay, if we got here, the function is syntactically valid. Convert types
5006 // and do semantic checks.
5007 std::vector<Type*> ParamTypeList;
5008 SmallVector<AttributeSet, 8> Attrs;
5009
5010 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5011 ParamTypeList.push_back(ArgList[i].Ty);
5012 Attrs.push_back(ArgList[i].Attrs);
5013 }
5014
5015 AttributeList PAL =
5016 AttributeList::get(Context, AttributeSet::get(Context, FuncAttrs),
5017 AttributeSet::get(Context, RetAttrs), Attrs);
5018
5019 if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
5020 return Error(RetTypeLoc, "functions with 'sret' argument must return void");
5021
5022 FunctionType *FT =
5023 FunctionType::get(RetType, ParamTypeList, isVarArg);
5024 PointerType *PFT = PointerType::getUnqual(FT);
5025
5026 Fn = nullptr;
5027 if (!FunctionName.empty()) {
5028 // If this was a definition of a forward reference, remove the definition
5029 // from the forward reference table and fill in the forward ref.
5030 auto FRVI = ForwardRefVals.find(FunctionName);
5031 if (FRVI != ForwardRefVals.end()) {
5032 Fn = M->getFunction(FunctionName);
5033 if (!Fn)
5034 return Error(FRVI->second.second, "invalid forward reference to "
5035 "function as global value!");
5036 if (Fn->getType() != PFT)
5037 return Error(FRVI->second.second, "invalid forward reference to "
5038 "function '" + FunctionName + "' with wrong type!");
5039
5040 ForwardRefVals.erase(FRVI);
5041 } else if ((Fn = M->getFunction(FunctionName))) {
5042 // Reject redefinitions.
5043 return Error(NameLoc, "invalid redefinition of function '" +
5044 FunctionName + "'");
5045 } else if (M->getNamedValue(FunctionName)) {
5046 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
5047 }
5048
5049 } else {
5050 // If this is a definition of a forward referenced function, make sure the
5051 // types agree.
5052 auto I = ForwardRefValIDs.find(NumberedVals.size());
5053 if (I != ForwardRefValIDs.end()) {
5054 Fn = cast<Function>(I->second.first);
5055 if (Fn->getType() != PFT)
5056 return Error(NameLoc, "type of definition and forward reference of '@" +
5057 Twine(NumberedVals.size()) + "' disagree");
5058 ForwardRefValIDs.erase(I);
5059 }
5060 }
5061
5062 if (!Fn)
5063 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
5064 else // Move the forward-reference to the correct spot in the module.
5065 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
5066
5067 if (FunctionName.empty())
5068 NumberedVals.push_back(Fn);
5069
5070 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
5071 maybeSetDSOLocal(DSOLocal, *Fn);
5072 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
5073 Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
5074 Fn->setCallingConv(CC);
5075 Fn->setAttributes(PAL);
5076 Fn->setUnnamedAddr(UnnamedAddr);
5077 Fn->setAlignment(Alignment);
5078 Fn->setSection(Section);
5079 Fn->setComdat(C);
5080 Fn->setPersonalityFn(PersonalityFn);
5081 if (!GC.empty()) Fn->setGC(GC);
5082 Fn->setPrefixData(Prefix);
5083 Fn->setPrologueData(Prologue);
5084 ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
5085
5086 // Add all of the arguments we parsed to the function.
5087 Function::arg_iterator ArgIt = Fn->arg_begin();
5088 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
5089 // If the argument has a name, insert it into the argument symbol table.
5090 if (ArgList[i].Name.empty()) continue;
5091
5092 // Set the name, if it conflicted, it will be auto-renamed.
5093 ArgIt->setName(ArgList[i].Name);
5094
5095 if (ArgIt->getName() != ArgList[i].Name)
5096 return Error(ArgList[i].Loc, "redefinition of argument '%" +
5097 ArgList[i].Name + "'");
5098 }
5099
5100 if (isDefine)
5101 return false;
5102
5103 // Check the declaration has no block address forward references.
5104 ValID ID;
5105 if (FunctionName.empty()) {
5106 ID.Kind = ValID::t_GlobalID;
5107 ID.UIntVal = NumberedVals.size() - 1;
5108 } else {
5109 ID.Kind = ValID::t_GlobalName;
5110 ID.StrVal = FunctionName;
5111 }
5112 auto Blocks = ForwardRefBlockAddresses.find(ID);
5113 if (Blocks != ForwardRefBlockAddresses.end())
5114 return Error(Blocks->first.Loc,
5115 "cannot take blockaddress inside a declaration");
5116 return false;
5117}
5118
5119bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
5120 ValID ID;
5121 if (FunctionNumber == -1) {
5122 ID.Kind = ValID::t_GlobalName;
5123 ID.StrVal = F.getName();
5124 } else {
5125 ID.Kind = ValID::t_GlobalID;
5126 ID.UIntVal = FunctionNumber;
5127 }
5128
5129 auto Blocks = P.ForwardRefBlockAddresses.find(ID);
5130 if (Blocks == P.ForwardRefBlockAddresses.end())
5131 return false;
5132
5133 for (const auto &I : Blocks->second) {
5134 const ValID &BBID = I.first;
5135 GlobalValue *GV = I.second;
5136
5137 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~svn325874/lib/AsmParser/LLParser.cpp"
, 5138, __extension__ __PRETTY_FUNCTION__))
5138 "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~svn325874/lib/AsmParser/LLParser.cpp"
, 5138, __extension__ __PRETTY_FUNCTION__))
;
5139 BasicBlock *BB;
5140 if (BBID.Kind == ValID::t_LocalName)
5141 BB = GetBB(BBID.StrVal, BBID.Loc);
5142 else
5143 BB = GetBB(BBID.UIntVal, BBID.Loc);
5144 if (!BB)
5145 return P.Error(BBID.Loc, "referenced value is not a basic block");
5146
5147 GV->replaceAllUsesWith(BlockAddress::get(&F, BB));
5148 GV->eraseFromParent();
5149 }
5150
5151 P.ForwardRefBlockAddresses.erase(Blocks);
5152 return false;
5153}
5154
5155/// ParseFunctionBody
5156/// ::= '{' BasicBlock+ UseListOrderDirective* '}'
5157bool LLParser::ParseFunctionBody(Function &Fn) {
5158 if (Lex.getKind() != lltok::lbrace)
5159 return TokError("expected '{' in function body");
5160 Lex.Lex(); // eat the {.
5161
5162 int FunctionNumber = -1;
5163 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
5164
5165 PerFunctionState PFS(*this, Fn, FunctionNumber);
5166
5167 // Resolve block addresses and allow basic blocks to be forward-declared
5168 // within this function.
5169 if (PFS.resolveForwardRefBlockAddresses())
5170 return true;
5171 SaveAndRestore<PerFunctionState *> ScopeExit(BlockAddressPFS, &PFS);
5172
5173 // We need at least one basic block.
5174 if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_uselistorder)
5175 return TokError("function body requires at least one basic block");
5176
5177 while (Lex.getKind() != lltok::rbrace &&
5178 Lex.getKind() != lltok::kw_uselistorder)
5179 if (ParseBasicBlock(PFS)) return true;
5180
5181 while (Lex.getKind() != lltok::rbrace)
5182 if (ParseUseListOrder(&PFS))
5183 return true;
5184
5185 // Eat the }.
5186 Lex.Lex();
5187
5188 // Verify function is ok.
5189 return PFS.FinishFunction();
5190}
5191
5192/// ParseBasicBlock
5193/// ::= LabelStr? Instruction*
5194bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
5195 // If this basic block starts out with a name, remember it.
5196 std::string Name;
5197 LocTy NameLoc = Lex.getLoc();
5198 if (Lex.getKind() == lltok::LabelStr) {
5199 Name = Lex.getStrVal();
5200 Lex.Lex();
5201 }
5202
5203 BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
5204 if (!BB)
5205 return Error(NameLoc,
5206 "unable to create block named '" + Name + "'");
5207
5208 std::string NameStr;
5209
5210 // Parse the instructions in this block until we get a terminator.
5211 Instruction *Inst;
5212 do {
5213 // This instruction may have three possibilities for a name: a) none
5214 // specified, b) name specified "%foo =", c) number specified: "%4 =".
5215 LocTy NameLoc = Lex.getLoc();
5216 int NameID = -1;
5217 NameStr = "";
5218
5219 if (Lex.getKind() == lltok::LocalVarID) {
5220 NameID = Lex.getUIntVal();
5221 Lex.Lex();
5222 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
5223 return true;
5224 } else if (Lex.getKind() == lltok::LocalVar) {
5225 NameStr = Lex.getStrVal();
5226 Lex.Lex();
5227 if (ParseToken(lltok::equal, "expected '=' after instruction name"))
5228 return true;
5229 }
5230
5231 switch (ParseInstruction(Inst, BB, PFS)) {
5232 default: llvm_unreachable("Unknown ParseInstruction result!")::llvm::llvm_unreachable_internal("Unknown ParseInstruction result!"
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/AsmParser/LLParser.cpp"
, 5232)
;
5233 case InstError: return true;
5234 case InstNormal:
5235 BB->getInstList().push_back(Inst);
5236
5237 // With a normal result, we check to see if the instruction is followed by
5238 // a comma and metadata.
5239 if (EatIfPresent(lltok::comma))
5240 if (ParseInstructionMetadata(*Inst))
5241 return true;
5242 break;
5243 case InstExtraComma:
5244 BB->getInstList().push_back(Inst);
5245
5246 // If the instruction parser ate an extra comma at the end of it, it
5247 // *must* be followed by metadata.
5248 if (ParseInstructionMetadata(*Inst))
5249 return true;
5250 break;
5251 }
5252
5253 // Set the name on the instruction.
5254 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
5255 } while (!isa<TerminatorInst>(Inst));
5256
5257 return false;
5258}
5259
5260//===----------------------------------------------------------------------===//
5261// Instruction Parsing.
5262//===----------------------------------------------------------------------===//
5263
5264/// ParseInstruction - Parse one of the many different instructions.
5265///
5266int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
5267 PerFunctionState &PFS) {
5268 lltok::Kind Token = Lex.getKind();
5269 if (Token == lltok::Eof)
5270 return TokError("found end of file when expecting more instructions");
5271 LocTy Loc = Lex.getLoc();
5272 unsigned KeywordVal = Lex.getUIntVal();
5273 Lex.Lex(); // Eat the keyword.
5274
5275 switch (Token) {
5276 default: return Error(Loc, "expected instruction opcode");
5277 // Terminator Instructions.
5278 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
5279 case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
5280 case lltok::kw_br: return ParseBr(Inst, PFS);
5281 case lltok::kw_switch: return ParseSwitch(Inst, PFS);
5282 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
5283 case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
5284 case lltok::kw_resume: return ParseResume(Inst, PFS);
5285 case lltok::kw_cleanupret: return ParseCleanupRet(Inst, PFS);
5286 case lltok::kw_catchret: return ParseCatchRet(Inst, PFS);
5287 case lltok::kw_catchswitch: return ParseCatchSwitch(Inst, PFS);
5288 case lltok::kw_catchpad: return ParseCatchPad(Inst, PFS);
5289 case lltok::kw_cleanuppad: return ParseCleanupPad(Inst, PFS);
5290 // Binary Operators.
5291 case lltok::kw_add:
5292 case lltok::kw_sub:
5293 case lltok::kw_mul:
5294 case lltok::kw_shl: {
5295 bool NUW = EatIfPresent(lltok::kw_nuw);
5296 bool NSW = EatIfPresent(lltok::kw_nsw);
5297 if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
5298
5299 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
5300
5301 if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
5302 if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
5303 return false;
5304 }
5305 case lltok::kw_fadd:
5306 case lltok::kw_fsub:
5307 case lltok::kw_fmul:
5308 case lltok::kw_fdiv:
5309 case lltok::kw_frem: {
5310 FastMathFlags FMF = EatFastMathFlagsIfPresent();
5311 int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2);
5312 if (Res != 0)
5313 return Res;
5314 if (FMF.any())
5315 Inst->setFastMathFlags(FMF);
5316 return 0;
5317 }
5318
5319 case lltok::kw_sdiv:
5320 case lltok::kw_udiv:
5321 case lltok::kw_lshr:
5322 case lltok::kw_ashr: {
5323 bool Exact = EatIfPresent(lltok::kw_exact);
5324
5325 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
5326 if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
5327 return false;
5328 }
5329
5330 case lltok::kw_urem:
5331 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
5332 case lltok::kw_and:
5333 case lltok::kw_or:
5334 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
5335 case lltok::kw_icmp: return ParseCompare(Inst, PFS, KeywordVal);
5336 case lltok::kw_fcmp: {
5337 FastMathFlags FMF = EatFastMathFlagsIfPresent();
5338 int Res = ParseCompare(Inst, PFS, KeywordVal);
5339 if (Res != 0)
5340 return Res;
5341 if (FMF.any())
5342 Inst->setFastMathFlags(FMF);
5343 return 0;
5344 }
5345
5346 // Casts.
5347 case lltok::kw_trunc:
5348 case lltok::kw_zext:
5349 case lltok::kw_sext:
5350 case lltok::kw_fptrunc:
5351 case lltok::kw_fpext:
5352 case lltok::kw_bitcast:
5353 case lltok::kw_addrspacecast:
5354 case lltok::kw_uitofp:
5355 case lltok::kw_sitofp:
5356 case lltok::kw_fptoui:
5357 case lltok::kw_fptosi:
5358 case lltok::kw_inttoptr:
5359 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
5360 // Other.
5361 case lltok::kw_select: return ParseSelect(Inst, PFS);
5362 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
5363 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
5364 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
5365 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
5366 case lltok::kw_phi: return ParsePHI(Inst, PFS);
5367 case lltok::kw_landingpad: return ParseLandingPad(Inst, PFS);
5368 // Call.
5369 case lltok::kw_call: return ParseCall(Inst, PFS, CallInst::TCK_None);
5370 case lltok::kw_tail: return ParseCall(Inst, PFS, CallInst::TCK_Tail);
5371 case lltok::kw_musttail: return ParseCall(Inst, PFS, CallInst::TCK_MustTail);
5372 case lltok::kw_notail: return ParseCall(Inst, PFS, CallInst::TCK_NoTail);
5373 // Memory.
5374 case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
5375 case lltok::kw_load: return ParseLoad(Inst, PFS);
5376 case lltok::kw_store: return ParseStore(Inst, PFS);
5377 case lltok::kw_cmpxchg: return ParseCmpXchg(Inst, PFS);
5378 case lltok::kw_atomicrmw: return ParseAtomicRMW(Inst, PFS);
5379 case lltok::kw_fence: return ParseFence(Inst, PFS);
5380 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
5381 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
5382 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
5383 }
5384}
5385
5386/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
5387bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
5388 if (Opc == Instruction::FCmp) {
5389 switch (Lex.getKind()) {
5390 default: return TokError("expected fcmp predicate (e.g. 'oeq')");
5391 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
5392 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
5393 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
5394 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
5395 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
5396 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
5397 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
5398 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
5399 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
5400 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
5401 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
5402 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
5403 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
5404 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
5405 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
5406 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
5407 }
5408 } else {
5409 switch (Lex.getKind()) {
5410 default: return TokError("expected icmp predicate (e.g. 'eq')");
5411 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
5412 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
5413 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
5414 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
5415 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
5416 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
5417 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
5418 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
5419 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
5420 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
5421 }
5422 }
5423 Lex.Lex();
5424 return false;
5425}
5426
5427//===----------------------------------------------------------------------===//
5428// Terminator Instructions.
5429//===----------------------------------------------------------------------===//
5430
5431/// ParseRet - Parse a return instruction.
5432/// ::= 'ret' void (',' !dbg, !1)*
5433/// ::= 'ret' TypeAndValue (',' !dbg, !1)*
5434bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
5435 PerFunctionState &PFS) {
5436 SMLoc TypeLoc = Lex.getLoc();
5437 Type *Ty = nullptr;
5438 if (ParseType(Ty, true /*void allowed*/)) return true;
5439
5440 Type *ResType = PFS.getFunction().getReturnType();
5441
5442 if (Ty->isVoidTy()) {
5443 if (!ResType->isVoidTy())
5444 return Error(TypeLoc, "value doesn't match function result type '" +
5445 getTypeString(ResType) + "'");
5446
5447 Inst = ReturnInst::Create(Context);
5448 return false;
5449 }
5450
5451 Value *RV;
5452 if (ParseValue(Ty, RV, PFS)) return true;
5453
5454 if (ResType != RV->getType())
5455 return Error(TypeLoc, "value doesn't match function result type '" +
5456 getTypeString(ResType) + "'");
5457
5458 Inst = ReturnInst::Create(Context, RV);
5459 return false;
5460}
5461
5462/// ParseBr
5463/// ::= 'br' TypeAndValue
5464/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
5465bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
5466 LocTy Loc, Loc2;
5467 Value *Op0;
5468 BasicBlock *Op1, *Op2;
5469 if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
5470
5471 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
5472 Inst = BranchInst::Create(BB);
5473 return false;
5474 }
5475
5476 if (Op0->getType() != Type::getInt1Ty(Context))
5477 return Error(Loc, "branch condition must have 'i1' type");
5478
5479 if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
5480 ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
5481 ParseToken(lltok::comma, "expected ',' after true destination") ||
5482 ParseTypeAndBasicBlock(Op2, Loc2, PFS))
5483 return true;
5484
5485 Inst = BranchInst::Create(Op1, Op2, Op0);
5486 return false;
5487}
5488
5489/// ParseSwitch
5490/// Instruction
5491/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
5492/// JumpTable
5493/// ::= (TypeAndValue ',' TypeAndValue)*
5494bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
5495 LocTy CondLoc, BBLoc;
5496 Value *Cond;
5497 BasicBlock *DefaultBB;
5498 if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
5499 ParseToken(lltok::comma, "expected ',' after switch condition") ||
5500 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
5501 ParseToken(lltok::lsquare, "expected '[' with switch table"))
5502 return true;
5503
5504 if (!Cond->getType()->isIntegerTy())
5505 return Error(CondLoc, "switch condition must have integer type");
5506
5507 // Parse the jump table pairs.
5508 SmallPtrSet<Value*, 32> SeenCases;
5509 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
5510 while (Lex.getKind() != lltok::rsquare) {
5511 Value *Constant;
5512 BasicBlock *DestBB;
5513
5514 if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
5515 ParseToken(lltok::comma, "expected ',' after case value") ||
5516 ParseTypeAndBasicBlock(DestBB, PFS))
5517 return true;
5518
5519 if (!SeenCases.insert(Constant).second)
5520 return Error(CondLoc, "duplicate case value in switch");
5521 if (!isa<ConstantInt>(Constant))
5522 return Error(CondLoc, "case value is not a constant integer");
5523
5524 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
5525 }
5526
5527 Lex.Lex(); // Eat the ']'.
5528
5529 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
5530 for (unsigned i = 0, e = Table.size(); i != e; ++i)
5531 SI->addCase(Table[i].first, Table[i].second);
5532 Inst = SI;
5533 return false;
5534}
5535
5536/// ParseIndirectBr
5537/// Instruction
5538/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
5539bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
5540 LocTy AddrLoc;
5541 Value *Address;
5542 if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
5543 ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
5544 ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
5545 return true;
5546
5547 if (!Address->getType()->isPointerTy())
5548 return Error(AddrLoc, "indirectbr address must have pointer type");
5549
5550 // Parse the destination list.
5551 SmallVector<BasicBlock*, 16> DestList;
5552
5553 if (Lex.getKind() != lltok::rsquare) {
5554 BasicBlock *DestBB;
5555 if (ParseTypeAndBasicBlock(DestBB, PFS))
5556 return true;
5557 DestList.push_back(DestBB);
5558
5559 while (EatIfPresent(lltok::comma)) {
5560 if (ParseTypeAndBasicBlock(DestBB, PFS))
5561 return true;
5562 DestList.push_back(DestBB);
5563 }
5564 }
5565
5566 if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
5567 return true;
5568
5569 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
5570 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
5571 IBI->addDestination(DestList[i]);
5572 Inst = IBI;
5573 return false;
5574}
5575
5576/// ParseInvoke
5577/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
5578/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
5579bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
5580 LocTy CallLoc = Lex.getLoc();
5581 AttrBuilder RetAttrs, FnAttrs;
5582 std::vector<unsigned> FwdRefAttrGrps;
5583 LocTy NoBuiltinLoc;
5584 unsigned CC;
5585 Type *RetType = nullptr;
5586 LocTy RetTypeLoc;
5587 ValID CalleeID;
5588 SmallVector<ParamInfo, 16> ArgList;
5589 SmallVector<OperandBundleDef, 2> BundleList;
5590
5591 BasicBlock *NormalBB, *UnwindBB;
5592 if (ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
5593 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
5594 ParseValID(CalleeID) || ParseParameterList(ArgList, PFS) ||
5595 ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
5596 NoBuiltinLoc) ||
5597 ParseOptionalOperandBundles(BundleList, PFS) ||
5598 ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
5599 ParseTypeAndBasicBlock(NormalBB, PFS) ||
5600 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
5601 ParseTypeAndBasicBlock(UnwindBB, PFS))
5602 return true;
5603
5604 // If RetType is a non-function pointer type, then this is the short syntax
5605 // for the call, which means that RetType is just the return type. Infer the
5606 // rest of the function argument types from the arguments that are present.
5607 FunctionType *Ty = dyn_cast<FunctionType>(RetType);
5608 if (!Ty) {
5609 // Pull out the types of all of the arguments...
5610 std::vector<Type*> ParamTypes;
5611 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
5612 ParamTypes.push_back(ArgList[i].V->getType());
5613
5614 if (!FunctionType::isValidReturnType(RetType))
5615 return Error(RetTypeLoc, "Invalid result type for LLVM function");
5616
5617 Ty = FunctionType::get(RetType, ParamTypes, false);
5618 }
5619
5620 CalleeID.FTy = Ty;
5621
5622 // Look up the callee.
5623 Value *Callee;
5624 if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
5625 return true;
5626
5627 // Set up the Attribute for the function.
5628 SmallVector<Value *, 8> Args;
5629 SmallVector<AttributeSet, 8> ArgAttrs;
5630
5631 // Loop through FunctionType's arguments and ensure they are specified
5632 // correctly. Also, gather any parameter attributes.
5633 FunctionType::param_iterator I = Ty->param_begin();
5634 FunctionType::param_iterator E = Ty->param_end();
5635 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5636 Type *ExpectedTy = nullptr;
5637 if (I != E) {
5638 ExpectedTy = *I++;
5639 } else if (!Ty->isVarArg()) {
5640 return Error(ArgList[i].Loc, "too many arguments specified");
5641 }
5642
5643 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
5644 return Error(ArgList[i].Loc, "argument is not of expected type '" +
5645 getTypeString(ExpectedTy) + "'");
5646 Args.push_back(ArgList[i].V);
5647 ArgAttrs.push_back(ArgList[i].Attrs);
5648 }
5649
5650 if (I != E)
5651 return Error(CallLoc, "not