Bug Summary

File:llvm/lib/AsmParser/LLParser.cpp
Warning:line 3278, column 10
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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