blob: 96601100e34b06f6cefe7fb12133523d41f743c0 [file] [log] [blame]
Mehdi Aminief27db82016-12-12 19:34:26 +00001//===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "MetadataLoader.h"
11#include "ValueList.h"
12
13#include "llvm/ADT/APFloat.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/ADT/ArrayRef.h"
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallString.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/Triple.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/Bitcode/BitcodeReader.h"
25#include "llvm/Bitcode/BitstreamReader.h"
26#include "llvm/Bitcode/LLVMBitCodes.h"
27#include "llvm/IR/Argument.h"
28#include "llvm/IR/Attributes.h"
29#include "llvm/IR/AutoUpgrade.h"
30#include "llvm/IR/BasicBlock.h"
31#include "llvm/IR/CallSite.h"
32#include "llvm/IR/CallingConv.h"
33#include "llvm/IR/Comdat.h"
34#include "llvm/IR/Constant.h"
35#include "llvm/IR/Constants.h"
36#include "llvm/IR/DebugInfo.h"
37#include "llvm/IR/DebugInfoMetadata.h"
38#include "llvm/IR/DebugLoc.h"
39#include "llvm/IR/DerivedTypes.h"
40#include "llvm/IR/DiagnosticInfo.h"
41#include "llvm/IR/DiagnosticPrinter.h"
42#include "llvm/IR/Function.h"
43#include "llvm/IR/GVMaterializer.h"
44#include "llvm/IR/GlobalAlias.h"
45#include "llvm/IR/GlobalIFunc.h"
46#include "llvm/IR/GlobalIndirectSymbol.h"
47#include "llvm/IR/GlobalObject.h"
48#include "llvm/IR/GlobalValue.h"
49#include "llvm/IR/GlobalVariable.h"
50#include "llvm/IR/InlineAsm.h"
51#include "llvm/IR/InstrTypes.h"
52#include "llvm/IR/Instruction.h"
53#include "llvm/IR/Instructions.h"
54#include "llvm/IR/Intrinsics.h"
55#include "llvm/IR/LLVMContext.h"
56#include "llvm/IR/Module.h"
57#include "llvm/IR/ModuleSummaryIndex.h"
58#include "llvm/IR/OperandTraits.h"
59#include "llvm/IR/Operator.h"
60#include "llvm/IR/TrackingMDRef.h"
61#include "llvm/IR/Type.h"
62#include "llvm/IR/ValueHandle.h"
63#include "llvm/Support/AtomicOrdering.h"
64#include "llvm/Support/Casting.h"
65#include "llvm/Support/CommandLine.h"
66#include "llvm/Support/Compiler.h"
67#include "llvm/Support/Debug.h"
68#include "llvm/Support/Error.h"
69#include "llvm/Support/ErrorHandling.h"
70#include "llvm/Support/ManagedStatic.h"
71#include "llvm/Support/MemoryBuffer.h"
72#include "llvm/Support/raw_ostream.h"
73#include <algorithm>
74#include <cassert>
75#include <cstddef>
76#include <cstdint>
77#include <deque>
78#include <limits>
79#include <map>
80#include <memory>
81#include <string>
82#include <system_error>
83#include <tuple>
84#include <utility>
85#include <vector>
86
87using namespace llvm;
88
89namespace {
90
91static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
92
93class BitcodeReaderMetadataList {
94 unsigned NumFwdRefs;
95 bool AnyFwdRefs;
96 unsigned MinFwdRef;
97 unsigned MaxFwdRef;
98
99 /// Array of metadata references.
100 ///
101 /// Don't use std::vector here. Some versions of libc++ copy (instead of
102 /// move) on resize, and TrackingMDRef is very expensive to copy.
103 SmallVector<TrackingMDRef, 1> MetadataPtrs;
104
105 /// Structures for resolving old type refs.
106 struct {
107 SmallDenseMap<MDString *, TempMDTuple, 1> Unknown;
108 SmallDenseMap<MDString *, DICompositeType *, 1> Final;
109 SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
110 SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
111 } OldTypeRefs;
112
113 LLVMContext &Context;
114
115public:
116 BitcodeReaderMetadataList(LLVMContext &C)
117 : NumFwdRefs(0), AnyFwdRefs(false), Context(C) {}
118
119 // vector compatibility methods
120 unsigned size() const { return MetadataPtrs.size(); }
121 void resize(unsigned N) { MetadataPtrs.resize(N); }
122 void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
123 void clear() { MetadataPtrs.clear(); }
124 Metadata *back() const { return MetadataPtrs.back(); }
125 void pop_back() { MetadataPtrs.pop_back(); }
126 bool empty() const { return MetadataPtrs.empty(); }
127
128 Metadata *operator[](unsigned i) const {
129 assert(i < MetadataPtrs.size());
130 return MetadataPtrs[i];
131 }
132
133 Metadata *lookup(unsigned I) const {
134 if (I < MetadataPtrs.size())
135 return MetadataPtrs[I];
136 return nullptr;
137 }
138
139 void shrinkTo(unsigned N) {
140 assert(N <= size() && "Invalid shrinkTo request!");
141 assert(!AnyFwdRefs && "Unexpected forward refs");
142 MetadataPtrs.resize(N);
143 }
144
145 /// Return the given metadata, creating a replaceable forward reference if
146 /// necessary.
147 Metadata *getMetadataFwdRef(unsigned Idx);
148
149 /// Return the the given metadata only if it is fully resolved.
150 ///
151 /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
152 /// would give \c false.
153 Metadata *getMetadataIfResolved(unsigned Idx);
154
155 MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
156 void assignValue(Metadata *MD, unsigned Idx);
157 void tryToResolveCycles();
158 bool hasFwdRefs() const { return AnyFwdRefs; }
159
160 /// Upgrade a type that had an MDString reference.
161 void addTypeRef(MDString &UUID, DICompositeType &CT);
162
163 /// Upgrade a type that had an MDString reference.
164 Metadata *upgradeTypeRef(Metadata *MaybeUUID);
165
166 /// Upgrade a type ref array that may have MDString references.
167 Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
168
169private:
170 Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
171};
172
173void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
174 if (Idx == size()) {
175 push_back(MD);
176 return;
177 }
178
179 if (Idx >= size())
180 resize(Idx + 1);
181
182 TrackingMDRef &OldMD = MetadataPtrs[Idx];
183 if (!OldMD) {
184 OldMD.reset(MD);
185 return;
186 }
187
188 // If there was a forward reference to this value, replace it.
189 TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
190 PrevMD->replaceAllUsesWith(MD);
191 --NumFwdRefs;
192}
193
194Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
195 if (Idx >= size())
196 resize(Idx + 1);
197
198 if (Metadata *MD = MetadataPtrs[Idx])
199 return MD;
200
201 // Track forward refs to be resolved later.
202 if (AnyFwdRefs) {
203 MinFwdRef = std::min(MinFwdRef, Idx);
204 MaxFwdRef = std::max(MaxFwdRef, Idx);
205 } else {
206 AnyFwdRefs = true;
207 MinFwdRef = MaxFwdRef = Idx;
208 }
209 ++NumFwdRefs;
210
211 // Create and return a placeholder, which will later be RAUW'd.
212 Metadata *MD = MDNode::getTemporary(Context, None).release();
213 MetadataPtrs[Idx].reset(MD);
214 return MD;
215}
216
217Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
218 Metadata *MD = lookup(Idx);
219 if (auto *N = dyn_cast_or_null<MDNode>(MD))
220 if (!N->isResolved())
221 return nullptr;
222 return MD;
223}
224
225MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
226 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
227}
228
229void BitcodeReaderMetadataList::tryToResolveCycles() {
230 if (NumFwdRefs)
231 // Still forward references... can't resolve cycles.
232 return;
233
234 bool DidReplaceTypeRefs = false;
235
236 // Give up on finding a full definition for any forward decls that remain.
237 for (const auto &Ref : OldTypeRefs.FwdDecls)
238 OldTypeRefs.Final.insert(Ref);
239 OldTypeRefs.FwdDecls.clear();
240
241 // Upgrade from old type ref arrays. In strange cases, this could add to
242 // OldTypeRefs.Unknown.
243 for (const auto &Array : OldTypeRefs.Arrays) {
244 DidReplaceTypeRefs = true;
245 Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
246 }
247 OldTypeRefs.Arrays.clear();
248
249 // Replace old string-based type refs with the resolved node, if possible.
250 // If we haven't seen the node, leave it to the verifier to complain about
251 // the invalid string reference.
252 for (const auto &Ref : OldTypeRefs.Unknown) {
253 DidReplaceTypeRefs = true;
254 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
255 Ref.second->replaceAllUsesWith(CT);
256 else
257 Ref.second->replaceAllUsesWith(Ref.first);
258 }
259 OldTypeRefs.Unknown.clear();
260
261 // Make sure all the upgraded types are resolved.
262 if (DidReplaceTypeRefs) {
263 AnyFwdRefs = true;
264 MinFwdRef = 0;
265 MaxFwdRef = MetadataPtrs.size() - 1;
266 }
267
268 if (!AnyFwdRefs)
269 // Nothing to do.
270 return;
271
272 // Resolve any cycles.
273 for (unsigned I = MinFwdRef, E = MaxFwdRef + 1; I != E; ++I) {
274 auto &MD = MetadataPtrs[I];
275 auto *N = dyn_cast_or_null<MDNode>(MD);
276 if (!N)
277 continue;
278
279 assert(!N->isTemporary() && "Unexpected forward reference");
280 N->resolveCycles();
281 }
282
283 // Make sure we return early again until there's another forward ref.
284 AnyFwdRefs = false;
285}
286
287void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
288 DICompositeType &CT) {
289 assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
290 if (CT.isForwardDecl())
291 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
292 else
293 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
294}
295
296Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
297 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
298 if (LLVM_LIKELY(!UUID))
299 return MaybeUUID;
300
301 if (auto *CT = OldTypeRefs.Final.lookup(UUID))
302 return CT;
303
304 auto &Ref = OldTypeRefs.Unknown[UUID];
305 if (!Ref)
306 Ref = MDNode::getTemporary(Context, None);
307 return Ref.get();
308}
309
310Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
311 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
312 if (!Tuple || Tuple->isDistinct())
313 return MaybeTuple;
314
315 // Look through the array immediately if possible.
316 if (!Tuple->isTemporary())
317 return resolveTypeRefArray(Tuple);
318
319 // Create and return a placeholder to use for now. Eventually
320 // resolveTypeRefArrays() will be resolve this forward reference.
321 OldTypeRefs.Arrays.emplace_back(
322 std::piecewise_construct, std::forward_as_tuple(Tuple),
323 std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
324 return OldTypeRefs.Arrays.back().second.get();
325}
326
327Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
328 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
329 if (!Tuple || Tuple->isDistinct())
330 return MaybeTuple;
331
332 // Look through the DITypeRefArray, upgrading each DITypeRef.
333 SmallVector<Metadata *, 32> Ops;
334 Ops.reserve(Tuple->getNumOperands());
335 for (Metadata *MD : Tuple->operands())
336 Ops.push_back(upgradeTypeRef(MD));
337
338 return MDTuple::get(Context, Ops);
339}
340
341namespace {
342
343class PlaceholderQueue {
344 // Placeholders would thrash around when moved, so store in a std::deque
345 // instead of some sort of vector.
346 std::deque<DistinctMDOperandPlaceholder> PHs;
347
348public:
349 DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
350 void flush(BitcodeReaderMetadataList &MetadataList);
351};
352
353} // end anonymous namespace
354
355DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
356 PHs.emplace_back(ID);
357 return PHs.back();
358}
359
360void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
361 while (!PHs.empty()) {
362 PHs.front().replaceUseWith(
363 MetadataList.getMetadataFwdRef(PHs.front().getID()));
364 PHs.pop_front();
365 }
366}
367
368} // anonynous namespace
369
370class MetadataLoader::MetadataLoaderImpl {
371 BitcodeReaderMetadataList MetadataList;
372 BitcodeReaderValueList &ValueList;
373 BitstreamCursor &Stream;
374 LLVMContext &Context;
375 Module &TheModule;
376 std::function<Type *(unsigned)> getTypeByID;
377
378 /// Functions that need to be matched with subprograms when upgrading old
379 /// metadata.
380 SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
381
382 // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
383 DenseMap<unsigned, unsigned> MDKindMap;
384
Mehdi Amini86623052016-12-16 19:16:29 +0000385 bool StripTBAA = false;
Mehdi Aminief27db82016-12-12 19:34:26 +0000386 bool HasSeenOldLoopTags = false;
387
388 Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
389 unsigned &NextMetadataNo);
390 Error parseGlobalObjectAttachment(GlobalObject &GO,
391 ArrayRef<uint64_t> Record);
392 Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
393
394public:
395 MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
396 BitcodeReaderValueList &ValueList,
397 std::function<Type *(unsigned)> getTypeByID)
398 : MetadataList(TheModule.getContext()), ValueList(ValueList),
399 Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule),
400 getTypeByID(getTypeByID) {}
401
402 Error parseMetadata(bool ModuleLevel);
403
404 bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
405 Metadata *getMetadataFwdRef(unsigned Idx) {
406 return MetadataList.getMetadataFwdRef(Idx);
407 }
408
409 MDNode *getMDNodeFwdRefOrNull(unsigned Idx) {
410 return MetadataList.getMDNodeFwdRefOrNull(Idx);
411 }
412
413 DISubprogram *lookupSubprogramForFunction(Function *F) {
414 return FunctionsWithSPs.lookup(F);
415 }
416
417 bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }
418
419 Error parseMetadataAttachment(
420 Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
421
422 Error parseMetadataKinds();
423
Mehdi Amini86623052016-12-16 19:16:29 +0000424 void setStripTBAA(bool Value) { StripTBAA = Value; }
425 bool isStrippingTBAA() { return StripTBAA; }
426
Mehdi Aminief27db82016-12-12 19:34:26 +0000427 unsigned size() const { return MetadataList.size(); }
428 void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
429};
430
431Error error(const Twine &Message) {
432 return make_error<StringError>(
433 Message, make_error_code(BitcodeError::CorruptedBitcode));
434}
435
436/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
437/// module level metadata.
438Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
439 if (!ModuleLevel && MetadataList.hasFwdRefs())
440 return error("Invalid metadata: fwd refs into function blocks");
441
442 if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
443 return error("Invalid record");
444
445 unsigned NextMetadataNo = MetadataList.size();
446 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
447 SmallVector<uint64_t, 64> Record;
448
449 PlaceholderQueue Placeholders;
450 bool IsDistinct;
451 auto getMD = [&](unsigned ID) -> Metadata * {
452 if (!IsDistinct)
453 return MetadataList.getMetadataFwdRef(ID);
454 if (auto *MD = MetadataList.getMetadataIfResolved(ID))
455 return MD;
456 return &Placeholders.getPlaceholderOp(ID);
457 };
458 auto getMDOrNull = [&](unsigned ID) -> Metadata * {
459 if (ID)
460 return getMD(ID - 1);
461 return nullptr;
462 };
463 auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
464 if (ID)
465 return MetadataList.getMetadataFwdRef(ID - 1);
466 return nullptr;
467 };
468 auto getMDString = [&](unsigned ID) -> MDString * {
469 // This requires that the ID is not really a forward reference. In
470 // particular, the MDString must already have been resolved.
471 return cast_or_null<MDString>(getMDOrNull(ID));
472 };
473
474 // Support for old type refs.
475 auto getDITypeRefOrNull = [&](unsigned ID) {
476 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
477 };
478
479#define GET_OR_DISTINCT(CLASS, ARGS) \
480 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
481
482 // Read all the records.
483 while (true) {
484 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
485
486 switch (Entry.Kind) {
487 case BitstreamEntry::SubBlock: // Handled for us already.
488 case BitstreamEntry::Error:
489 return error("Malformed block");
490 case BitstreamEntry::EndBlock:
491 // Upgrade old-style CU <-> SP pointers to point from SP to CU.
492 for (auto CU_SP : CUSubprograms)
493 if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
494 for (auto &Op : SPs->operands())
495 if (auto *SP = dyn_cast_or_null<MDNode>(Op))
496 SP->replaceOperandWith(7, CU_SP.first);
497
498 MetadataList.tryToResolveCycles();
499 Placeholders.flush(MetadataList);
500 return Error::success();
501 case BitstreamEntry::Record:
502 // The interesting case.
503 break;
504 }
505
506 // Read a record.
507 Record.clear();
508 StringRef Blob;
509 unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
510 IsDistinct = false;
511 switch (Code) {
512 default: // Default behavior: ignore.
513 break;
514 case bitc::METADATA_NAME: {
515 // Read name of the named metadata.
516 SmallString<8> Name(Record.begin(), Record.end());
517 Record.clear();
518 Code = Stream.ReadCode();
519
520 unsigned NextBitCode = Stream.readRecord(Code, Record);
521 if (NextBitCode != bitc::METADATA_NAMED_NODE)
522 return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
523
524 // Read named metadata elements.
525 unsigned Size = Record.size();
526 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
527 for (unsigned i = 0; i != Size; ++i) {
528 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
529 if (!MD)
530 return error("Invalid record");
531 NMD->addOperand(MD);
532 }
533 break;
534 }
535 case bitc::METADATA_OLD_FN_NODE: {
536 // FIXME: Remove in 4.0.
537 // This is a LocalAsMetadata record, the only type of function-local
538 // metadata.
539 if (Record.size() % 2 == 1)
540 return error("Invalid record");
541
542 // If this isn't a LocalAsMetadata record, we're dropping it. This used
543 // to be legal, but there's no upgrade path.
544 auto dropRecord = [&] {
545 MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo++);
546 };
547 if (Record.size() != 2) {
548 dropRecord();
549 break;
550 }
551
552 Type *Ty = getTypeByID(Record[0]);
553 if (Ty->isMetadataTy() || Ty->isVoidTy()) {
554 dropRecord();
555 break;
556 }
557
558 MetadataList.assignValue(
559 LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
560 NextMetadataNo++);
561 break;
562 }
563 case bitc::METADATA_OLD_NODE: {
564 // FIXME: Remove in 4.0.
565 if (Record.size() % 2 == 1)
566 return error("Invalid record");
567
568 unsigned Size = Record.size();
569 SmallVector<Metadata *, 8> Elts;
570 for (unsigned i = 0; i != Size; i += 2) {
571 Type *Ty = getTypeByID(Record[i]);
572 if (!Ty)
573 return error("Invalid record");
574 if (Ty->isMetadataTy())
575 Elts.push_back(getMD(Record[i + 1]));
576 else if (!Ty->isVoidTy()) {
577 auto *MD =
578 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
579 assert(isa<ConstantAsMetadata>(MD) &&
580 "Expected non-function-local metadata");
581 Elts.push_back(MD);
582 } else
583 Elts.push_back(nullptr);
584 }
585 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo++);
586 break;
587 }
588 case bitc::METADATA_VALUE: {
589 if (Record.size() != 2)
590 return error("Invalid record");
591
592 Type *Ty = getTypeByID(Record[0]);
593 if (Ty->isMetadataTy() || Ty->isVoidTy())
594 return error("Invalid record");
595
596 MetadataList.assignValue(
597 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
598 NextMetadataNo++);
599 break;
600 }
601 case bitc::METADATA_DISTINCT_NODE:
602 IsDistinct = true;
603 LLVM_FALLTHROUGH;
604 case bitc::METADATA_NODE: {
605 SmallVector<Metadata *, 8> Elts;
606 Elts.reserve(Record.size());
607 for (unsigned ID : Record)
608 Elts.push_back(getMDOrNull(ID));
609 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
610 : MDNode::get(Context, Elts),
611 NextMetadataNo++);
612 break;
613 }
614 case bitc::METADATA_LOCATION: {
615 if (Record.size() != 5)
616 return error("Invalid record");
617
618 IsDistinct = Record[0];
619 unsigned Line = Record[1];
620 unsigned Column = Record[2];
621 Metadata *Scope = getMD(Record[3]);
622 Metadata *InlinedAt = getMDOrNull(Record[4]);
623 MetadataList.assignValue(
624 GET_OR_DISTINCT(DILocation,
625 (Context, Line, Column, Scope, InlinedAt)),
626 NextMetadataNo++);
627 break;
628 }
629 case bitc::METADATA_GENERIC_DEBUG: {
630 if (Record.size() < 4)
631 return error("Invalid record");
632
633 IsDistinct = Record[0];
634 unsigned Tag = Record[1];
635 unsigned Version = Record[2];
636
637 if (Tag >= 1u << 16 || Version != 0)
638 return error("Invalid record");
639
640 auto *Header = getMDString(Record[3]);
641 SmallVector<Metadata *, 8> DwarfOps;
642 for (unsigned I = 4, E = Record.size(); I != E; ++I)
643 DwarfOps.push_back(getMDOrNull(Record[I]));
644 MetadataList.assignValue(
645 GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
646 NextMetadataNo++);
647 break;
648 }
649 case bitc::METADATA_SUBRANGE: {
650 if (Record.size() != 3)
651 return error("Invalid record");
652
653 IsDistinct = Record[0];
654 MetadataList.assignValue(
655 GET_OR_DISTINCT(DISubrange,
656 (Context, Record[1], unrotateSign(Record[2]))),
657 NextMetadataNo++);
658 break;
659 }
660 case bitc::METADATA_ENUMERATOR: {
661 if (Record.size() != 3)
662 return error("Invalid record");
663
664 IsDistinct = Record[0];
665 MetadataList.assignValue(
666 GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
667 getMDString(Record[2]))),
668 NextMetadataNo++);
669 break;
670 }
671 case bitc::METADATA_BASIC_TYPE: {
672 if (Record.size() != 6)
673 return error("Invalid record");
674
675 IsDistinct = Record[0];
676 MetadataList.assignValue(
677 GET_OR_DISTINCT(DIBasicType,
678 (Context, Record[1], getMDString(Record[2]),
679 Record[3], Record[4], Record[5])),
680 NextMetadataNo++);
681 break;
682 }
683 case bitc::METADATA_DERIVED_TYPE: {
684 if (Record.size() != 12)
685 return error("Invalid record");
686
687 IsDistinct = Record[0];
688 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
689 MetadataList.assignValue(
690 GET_OR_DISTINCT(DIDerivedType,
691 (Context, Record[1], getMDString(Record[2]),
692 getMDOrNull(Record[3]), Record[4],
693 getDITypeRefOrNull(Record[5]),
694 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
695 Record[9], Flags, getDITypeRefOrNull(Record[11]))),
696 NextMetadataNo++);
697 break;
698 }
699 case bitc::METADATA_COMPOSITE_TYPE: {
700 if (Record.size() != 16)
701 return error("Invalid record");
702
703 // If we have a UUID and this is not a forward declaration, lookup the
704 // mapping.
705 IsDistinct = Record[0] & 0x1;
706 bool IsNotUsedInTypeRef = Record[0] >= 2;
707 unsigned Tag = Record[1];
708 MDString *Name = getMDString(Record[2]);
709 Metadata *File = getMDOrNull(Record[3]);
710 unsigned Line = Record[4];
711 Metadata *Scope = getDITypeRefOrNull(Record[5]);
712 Metadata *BaseType = getDITypeRefOrNull(Record[6]);
713 uint64_t SizeInBits = Record[7];
714 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
715 return error("Alignment value is too large");
716 uint32_t AlignInBits = Record[8];
717 uint64_t OffsetInBits = Record[9];
718 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
719 Metadata *Elements = getMDOrNull(Record[11]);
720 unsigned RuntimeLang = Record[12];
721 Metadata *VTableHolder = getDITypeRefOrNull(Record[13]);
722 Metadata *TemplateParams = getMDOrNull(Record[14]);
723 auto *Identifier = getMDString(Record[15]);
724 DICompositeType *CT = nullptr;
725 if (Identifier)
726 CT = DICompositeType::buildODRType(
727 Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
728 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
729 VTableHolder, TemplateParams);
730
731 // Create a node if we didn't get a lazy ODR type.
732 if (!CT)
733 CT = GET_OR_DISTINCT(DICompositeType,
734 (Context, Tag, Name, File, Line, Scope, BaseType,
735 SizeInBits, AlignInBits, OffsetInBits, Flags,
736 Elements, RuntimeLang, VTableHolder,
737 TemplateParams, Identifier));
738 if (!IsNotUsedInTypeRef && Identifier)
739 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
740
741 MetadataList.assignValue(CT, NextMetadataNo++);
742 break;
743 }
744 case bitc::METADATA_SUBROUTINE_TYPE: {
745 if (Record.size() < 3 || Record.size() > 4)
746 return error("Invalid record");
747 bool IsOldTypeRefArray = Record[0] < 2;
748 unsigned CC = (Record.size() > 3) ? Record[3] : 0;
749
750 IsDistinct = Record[0] & 0x1;
751 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
752 Metadata *Types = getMDOrNull(Record[2]);
753 if (LLVM_UNLIKELY(IsOldTypeRefArray))
754 Types = MetadataList.upgradeTypeRefArray(Types);
755
756 MetadataList.assignValue(
757 GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
758 NextMetadataNo++);
759 break;
760 }
761
762 case bitc::METADATA_MODULE: {
763 if (Record.size() != 6)
764 return error("Invalid record");
765
766 IsDistinct = Record[0];
767 MetadataList.assignValue(
768 GET_OR_DISTINCT(DIModule,
769 (Context, getMDOrNull(Record[1]),
770 getMDString(Record[2]), getMDString(Record[3]),
771 getMDString(Record[4]), getMDString(Record[5]))),
772 NextMetadataNo++);
773 break;
774 }
775
776 case bitc::METADATA_FILE: {
777 if (Record.size() != 3)
778 return error("Invalid record");
779
780 IsDistinct = Record[0];
781 MetadataList.assignValue(
782 GET_OR_DISTINCT(DIFile, (Context, getMDString(Record[1]),
783 getMDString(Record[2]))),
784 NextMetadataNo++);
785 break;
786 }
787 case bitc::METADATA_COMPILE_UNIT: {
788 if (Record.size() < 14 || Record.size() > 17)
789 return error("Invalid record");
790
791 // Ignore Record[0], which indicates whether this compile unit is
792 // distinct. It's always distinct.
793 IsDistinct = true;
794 auto *CU = DICompileUnit::getDistinct(
795 Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
796 Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
797 Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
798 getMDOrNull(Record[12]), getMDOrNull(Record[13]),
799 Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
800 Record.size() <= 14 ? 0 : Record[14],
801 Record.size() <= 16 ? true : Record[16]);
802
803 MetadataList.assignValue(CU, NextMetadataNo++);
804
805 // Move the Upgrade the list of subprograms.
806 if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
807 CUSubprograms.push_back({CU, SPs});
808 break;
809 }
810 case bitc::METADATA_SUBPROGRAM: {
811 if (Record.size() < 18 || Record.size() > 20)
812 return error("Invalid record");
813
814 IsDistinct =
815 (Record[0] & 1) || Record[8]; // All definitions should be distinct.
816 // Version 1 has a Function as Record[15].
817 // Version 2 has removed Record[15].
818 // Version 3 has the Unit as Record[15].
819 // Version 4 added thisAdjustment.
820 bool HasUnit = Record[0] >= 2;
821 if (HasUnit && Record.size() < 19)
822 return error("Invalid record");
823 Metadata *CUorFn = getMDOrNull(Record[15]);
824 unsigned Offset = Record.size() >= 19 ? 1 : 0;
825 bool HasFn = Offset && !HasUnit;
826 bool HasThisAdj = Record.size() >= 20;
827 DISubprogram *SP = GET_OR_DISTINCT(
828 DISubprogram, (Context,
829 getDITypeRefOrNull(Record[1]), // scope
830 getMDString(Record[2]), // name
831 getMDString(Record[3]), // linkageName
832 getMDOrNull(Record[4]), // file
833 Record[5], // line
834 getMDOrNull(Record[6]), // type
835 Record[7], // isLocal
836 Record[8], // isDefinition
837 Record[9], // scopeLine
838 getDITypeRefOrNull(Record[10]), // containingType
839 Record[11], // virtuality
840 Record[12], // virtualIndex
841 HasThisAdj ? Record[19] : 0, // thisAdjustment
842 static_cast<DINode::DIFlags>(Record[13] // flags
843 ),
844 Record[14], // isOptimized
845 HasUnit ? CUorFn : nullptr, // unit
846 getMDOrNull(Record[15 + Offset]), // templateParams
847 getMDOrNull(Record[16 + Offset]), // declaration
848 getMDOrNull(Record[17 + Offset]) // variables
849 ));
850 MetadataList.assignValue(SP, NextMetadataNo++);
851
852 // Upgrade sp->function mapping to function->sp mapping.
853 if (HasFn) {
854 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
855 if (auto *F = dyn_cast<Function>(CMD->getValue())) {
856 if (F->isMaterializable())
857 // Defer until materialized; unmaterialized functions may not have
858 // metadata.
859 FunctionsWithSPs[F] = SP;
860 else if (!F->empty())
861 F->setSubprogram(SP);
862 }
863 }
864 break;
865 }
866 case bitc::METADATA_LEXICAL_BLOCK: {
867 if (Record.size() != 5)
868 return error("Invalid record");
869
870 IsDistinct = Record[0];
871 MetadataList.assignValue(
872 GET_OR_DISTINCT(DILexicalBlock,
873 (Context, getMDOrNull(Record[1]),
874 getMDOrNull(Record[2]), Record[3], Record[4])),
875 NextMetadataNo++);
876 break;
877 }
878 case bitc::METADATA_LEXICAL_BLOCK_FILE: {
879 if (Record.size() != 4)
880 return error("Invalid record");
881
882 IsDistinct = Record[0];
883 MetadataList.assignValue(
884 GET_OR_DISTINCT(DILexicalBlockFile,
885 (Context, getMDOrNull(Record[1]),
886 getMDOrNull(Record[2]), Record[3])),
887 NextMetadataNo++);
888 break;
889 }
890 case bitc::METADATA_NAMESPACE: {
891 if (Record.size() != 5)
892 return error("Invalid record");
893
894 IsDistinct = Record[0] & 1;
895 bool ExportSymbols = Record[0] & 2;
896 MetadataList.assignValue(
897 GET_OR_DISTINCT(DINamespace,
898 (Context, getMDOrNull(Record[1]),
899 getMDOrNull(Record[2]), getMDString(Record[3]),
900 Record[4], ExportSymbols)),
901 NextMetadataNo++);
902 break;
903 }
904 case bitc::METADATA_MACRO: {
905 if (Record.size() != 5)
906 return error("Invalid record");
907
908 IsDistinct = Record[0];
909 MetadataList.assignValue(
910 GET_OR_DISTINCT(DIMacro,
911 (Context, Record[1], Record[2],
912 getMDString(Record[3]), getMDString(Record[4]))),
913 NextMetadataNo++);
914 break;
915 }
916 case bitc::METADATA_MACRO_FILE: {
917 if (Record.size() != 5)
918 return error("Invalid record");
919
920 IsDistinct = Record[0];
921 MetadataList.assignValue(
922 GET_OR_DISTINCT(DIMacroFile,
923 (Context, Record[1], Record[2],
924 getMDOrNull(Record[3]), getMDOrNull(Record[4]))),
925 NextMetadataNo++);
926 break;
927 }
928 case bitc::METADATA_TEMPLATE_TYPE: {
929 if (Record.size() != 3)
930 return error("Invalid record");
931
932 IsDistinct = Record[0];
933 MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
934 (Context, getMDString(Record[1]),
935 getDITypeRefOrNull(Record[2]))),
936 NextMetadataNo++);
937 break;
938 }
939 case bitc::METADATA_TEMPLATE_VALUE: {
940 if (Record.size() != 5)
941 return error("Invalid record");
942
943 IsDistinct = Record[0];
944 MetadataList.assignValue(
945 GET_OR_DISTINCT(DITemplateValueParameter,
946 (Context, Record[1], getMDString(Record[2]),
947 getDITypeRefOrNull(Record[3]),
948 getMDOrNull(Record[4]))),
949 NextMetadataNo++);
950 break;
951 }
952 case bitc::METADATA_GLOBAL_VAR: {
953 if (Record.size() < 11 || Record.size() > 12)
954 return error("Invalid record");
955
956 IsDistinct = Record[0];
957
958 // Upgrade old metadata, which stored a global variable reference or a
959 // ConstantInt here.
960 Metadata *Expr = getMDOrNull(Record[9]);
961 uint32_t AlignInBits = 0;
962 if (Record.size() > 11) {
963 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
964 return error("Alignment value is too large");
965 AlignInBits = Record[11];
966 }
967 GlobalVariable *Attach = nullptr;
968 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
969 if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
970 Attach = GV;
971 Expr = nullptr;
972 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
973 Expr = DIExpression::get(Context,
974 {dwarf::DW_OP_constu, CI->getZExtValue(),
975 dwarf::DW_OP_stack_value});
976 } else {
977 Expr = nullptr;
978 }
979 }
980
981 DIGlobalVariable *DGV = GET_OR_DISTINCT(
982 DIGlobalVariable,
983 (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
984 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
Adrian Prantl74a835c2016-12-16 04:25:54 +0000985 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
Mehdi Aminief27db82016-12-12 19:34:26 +0000986 getMDOrNull(Record[10]), AlignInBits));
Mehdi Aminief27db82016-12-12 19:34:26 +0000987
Adrian Prantl74a835c2016-12-16 04:25:54 +0000988 if (Expr || Attach) {
989 auto *DGVE = DIGlobalVariableExpression::getDistinct(Context, DGV, Expr);
990 MetadataList.assignValue(DGVE, NextMetadataNo++);
991 if (Attach)
992 Attach->addDebugInfo(DGVE);
993 } else
994 MetadataList.assignValue(DGV, NextMetadataNo++);
Mehdi Aminief27db82016-12-12 19:34:26 +0000995
996 break;
997 }
998 case bitc::METADATA_LOCAL_VAR: {
999 // 10th field is for the obseleted 'inlinedAt:' field.
1000 if (Record.size() < 8 || Record.size() > 10)
1001 return error("Invalid record");
1002
1003 IsDistinct = Record[0] & 1;
1004 bool HasAlignment = Record[0] & 2;
1005 // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
1006 // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
1007 // this is newer version of record which doesn't have artifical tag.
1008 bool HasTag = !HasAlignment && Record.size() > 8;
1009 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1010 uint32_t AlignInBits = 0;
1011 if (HasAlignment) {
1012 if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1013 return error("Alignment value is too large");
1014 AlignInBits = Record[8 + HasTag];
1015 }
1016 MetadataList.assignValue(
1017 GET_OR_DISTINCT(DILocalVariable,
1018 (Context, getMDOrNull(Record[1 + HasTag]),
1019 getMDString(Record[2 + HasTag]),
1020 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1021 getDITypeRefOrNull(Record[5 + HasTag]),
1022 Record[6 + HasTag], Flags, AlignInBits)),
1023 NextMetadataNo++);
1024 break;
1025 }
1026 case bitc::METADATA_EXPRESSION: {
1027 if (Record.size() < 1)
1028 return error("Invalid record");
1029
1030 IsDistinct = Record[0] & 1;
1031 bool HasOpFragment = Record[0] & 2;
1032 auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1033 if (!HasOpFragment)
1034 if (unsigned N = Elts.size())
1035 if (N >= 3 && Elts[N - 3] == dwarf::DW_OP_bit_piece)
1036 Elts[N - 3] = dwarf::DW_OP_LLVM_fragment;
1037
1038 MetadataList.assignValue(
1039 GET_OR_DISTINCT(DIExpression,
1040 (Context, makeArrayRef(Record).slice(1))),
1041 NextMetadataNo++);
1042 break;
1043 }
Adrian Prantl74a835c2016-12-16 04:25:54 +00001044 case bitc::METADATA_GLOBAL_VAR_EXPR: {
1045 if (Record.size() != 3)
1046 return error("Invalid record");
1047
1048 IsDistinct = Record[0];
1049 MetadataList.assignValue(GET_OR_DISTINCT(DIGlobalVariableExpression,
1050 (Context, getMDOrNull(Record[1]),
1051 getMDOrNull(Record[2]))),
1052 NextMetadataNo++);
1053 break;
1054 }
Mehdi Aminief27db82016-12-12 19:34:26 +00001055 case bitc::METADATA_OBJC_PROPERTY: {
1056 if (Record.size() != 8)
1057 return error("Invalid record");
1058
1059 IsDistinct = Record[0];
1060 MetadataList.assignValue(
1061 GET_OR_DISTINCT(DIObjCProperty,
1062 (Context, getMDString(Record[1]),
1063 getMDOrNull(Record[2]), Record[3],
1064 getMDString(Record[4]), getMDString(Record[5]),
1065 Record[6], getDITypeRefOrNull(Record[7]))),
1066 NextMetadataNo++);
1067 break;
1068 }
1069 case bitc::METADATA_IMPORTED_ENTITY: {
1070 if (Record.size() != 6)
1071 return error("Invalid record");
1072
1073 IsDistinct = Record[0];
1074 MetadataList.assignValue(
1075 GET_OR_DISTINCT(DIImportedEntity,
1076 (Context, Record[1], getMDOrNull(Record[2]),
1077 getDITypeRefOrNull(Record[3]), Record[4],
1078 getMDString(Record[5]))),
1079 NextMetadataNo++);
1080 break;
1081 }
1082 case bitc::METADATA_STRING_OLD: {
1083 std::string String(Record.begin(), Record.end());
1084
1085 // Test for upgrading !llvm.loop.
1086 HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
1087
1088 Metadata *MD = MDString::get(Context, String);
1089 MetadataList.assignValue(MD, NextMetadataNo++);
1090 break;
1091 }
1092 case bitc::METADATA_STRINGS:
1093 if (Error Err = parseMetadataStrings(Record, Blob, NextMetadataNo))
1094 return Err;
1095 break;
1096 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
1097 if (Record.size() % 2 == 0)
1098 return error("Invalid record");
1099 unsigned ValueID = Record[0];
1100 if (ValueID >= ValueList.size())
1101 return error("Invalid record");
1102 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1103 if (Error Err = parseGlobalObjectAttachment(
1104 *GO, ArrayRef<uint64_t>(Record).slice(1)))
1105 return Err;
1106 break;
1107 }
1108 case bitc::METADATA_KIND: {
1109 // Support older bitcode files that had METADATA_KIND records in a
1110 // block with METADATA_BLOCK_ID.
1111 if (Error Err = parseMetadataKindRecord(Record))
1112 return Err;
1113 break;
1114 }
1115 }
1116 }
1117#undef GET_OR_DISTINCT
1118}
1119
1120Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
1121 ArrayRef<uint64_t> Record, StringRef Blob, unsigned &NextMetadataNo) {
1122 // All the MDStrings in the block are emitted together in a single
1123 // record. The strings are concatenated and stored in a blob along with
1124 // their sizes.
1125 if (Record.size() != 2)
1126 return error("Invalid record: metadata strings layout");
1127
1128 unsigned NumStrings = Record[0];
1129 unsigned StringsOffset = Record[1];
1130 if (!NumStrings)
1131 return error("Invalid record: metadata strings with no strings");
1132 if (StringsOffset > Blob.size())
1133 return error("Invalid record: metadata strings corrupt offset");
1134
1135 StringRef Lengths = Blob.slice(0, StringsOffset);
1136 SimpleBitstreamCursor R(Lengths);
1137
1138 StringRef Strings = Blob.drop_front(StringsOffset);
1139 do {
1140 if (R.AtEndOfStream())
1141 return error("Invalid record: metadata strings bad length");
1142
1143 unsigned Size = R.ReadVBR(6);
1144 if (Strings.size() < Size)
1145 return error("Invalid record: metadata strings truncated chars");
1146
1147 MetadataList.assignValue(MDString::get(Context, Strings.slice(0, Size)),
1148 NextMetadataNo++);
1149 Strings = Strings.drop_front(Size);
1150 } while (--NumStrings);
1151
1152 return Error::success();
1153}
1154
1155Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1156 GlobalObject &GO, ArrayRef<uint64_t> Record) {
1157 assert(Record.size() % 2 == 0);
1158 for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
1159 auto K = MDKindMap.find(Record[I]);
1160 if (K == MDKindMap.end())
1161 return error("Invalid ID");
1162 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1163 if (!MD)
1164 return error("Invalid metadata attachment");
1165 GO.addMetadata(K->second, *MD);
1166 }
1167 return Error::success();
1168}
1169
1170/// Parse metadata attachments.
1171Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
1172 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1173 if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
1174 return error("Invalid record");
1175
1176 SmallVector<uint64_t, 64> Record;
1177
1178 while (true) {
1179 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1180
1181 switch (Entry.Kind) {
1182 case BitstreamEntry::SubBlock: // Handled for us already.
1183 case BitstreamEntry::Error:
1184 return error("Malformed block");
1185 case BitstreamEntry::EndBlock:
1186 return Error::success();
1187 case BitstreamEntry::Record:
1188 // The interesting case.
1189 break;
1190 }
1191
1192 // Read a metadata attachment record.
1193 Record.clear();
1194 switch (Stream.readRecord(Entry.ID, Record)) {
1195 default: // Default behavior: ignore.
1196 break;
1197 case bitc::METADATA_ATTACHMENT: {
1198 unsigned RecordLength = Record.size();
1199 if (Record.empty())
1200 return error("Invalid record");
1201 if (RecordLength % 2 == 0) {
1202 // A function attachment.
1203 if (Error Err = parseGlobalObjectAttachment(F, Record))
1204 return Err;
1205 continue;
1206 }
1207
1208 // An instruction attachment.
1209 Instruction *Inst = InstructionList[Record[0]];
1210 for (unsigned i = 1; i != RecordLength; i = i + 2) {
1211 unsigned Kind = Record[i];
1212 DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
1213 if (I == MDKindMap.end())
1214 return error("Invalid ID");
Mehdi Amini86623052016-12-16 19:16:29 +00001215 if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1216 continue;
1217
Mehdi Aminief27db82016-12-12 19:34:26 +00001218 Metadata *Node = MetadataList.getMetadataFwdRef(Record[i + 1]);
1219 if (isa<LocalAsMetadata>(Node))
1220 // Drop the attachment. This used to be legal, but there's no
1221 // upgrade path.
1222 break;
1223 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
1224 if (!MD)
1225 return error("Invalid metadata attachment");
1226
1227 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1228 MD = upgradeInstructionLoopAttachment(*MD);
1229
1230 if (I->second == LLVMContext::MD_tbaa) {
1231 assert(!MD->isTemporary() && "should load MDs before attachments");
1232 MD = UpgradeTBAANode(*MD);
1233 }
1234 Inst->setMetadata(I->second, MD);
1235 }
1236 break;
1237 }
1238 }
1239 }
1240}
1241
1242/// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1243Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1244 SmallVectorImpl<uint64_t> &Record) {
1245 if (Record.size() < 2)
1246 return error("Invalid record");
1247
1248 unsigned Kind = Record[0];
1249 SmallString<8> Name(Record.begin() + 1, Record.end());
1250
1251 unsigned NewKind = TheModule.getMDKindID(Name.str());
1252 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1253 return error("Conflicting METADATA_KIND records");
1254 return Error::success();
1255}
1256
1257/// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1258Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
1259 if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
1260 return error("Invalid record");
1261
1262 SmallVector<uint64_t, 64> Record;
1263
1264 // Read all the records.
1265 while (true) {
1266 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1267
1268 switch (Entry.Kind) {
1269 case BitstreamEntry::SubBlock: // Handled for us already.
1270 case BitstreamEntry::Error:
1271 return error("Malformed block");
1272 case BitstreamEntry::EndBlock:
1273 return Error::success();
1274 case BitstreamEntry::Record:
1275 // The interesting case.
1276 break;
1277 }
1278
1279 // Read a record.
1280 Record.clear();
1281 unsigned Code = Stream.readRecord(Entry.ID, Record);
1282 switch (Code) {
1283 default: // Default behavior: ignore.
1284 break;
1285 case bitc::METADATA_KIND: {
1286 if (Error Err = parseMetadataKindRecord(Record))
1287 return Err;
1288 break;
1289 }
1290 }
1291 }
1292}
1293
1294MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
1295 Pimpl = std::move(RHS.Pimpl);
1296 return *this;
1297}
1298MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
1299 : Pimpl(std::move(RHS.Pimpl)) {}
1300
1301MetadataLoader::~MetadataLoader() = default;
1302MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
1303 BitcodeReaderValueList &ValueList,
1304 std::function<Type *(unsigned)> getTypeByID)
Nico Weberb3901bd2016-12-12 22:46:40 +00001305 : Pimpl(llvm::make_unique<MetadataLoaderImpl>(Stream, TheModule, ValueList,
1306 getTypeByID)) {}
Mehdi Aminief27db82016-12-12 19:34:26 +00001307
1308Error MetadataLoader::parseMetadata(bool ModuleLevel) {
1309 return Pimpl->parseMetadata(ModuleLevel);
1310}
1311
1312bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
1313
1314/// Return the given metadata, creating a replaceable forward reference if
1315/// necessary.
1316Metadata *MetadataLoader::getMetadataFwdRef(unsigned Idx) {
1317 return Pimpl->getMetadataFwdRef(Idx);
1318}
1319
1320MDNode *MetadataLoader::getMDNodeFwdRefOrNull(unsigned Idx) {
1321 return Pimpl->getMDNodeFwdRefOrNull(Idx);
1322}
1323
1324DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
1325 return Pimpl->lookupSubprogramForFunction(F);
1326}
1327
1328Error MetadataLoader::parseMetadataAttachment(
1329 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1330 return Pimpl->parseMetadataAttachment(F, InstructionList);
1331}
1332
1333Error MetadataLoader::parseMetadataKinds() {
1334 return Pimpl->parseMetadataKinds();
1335}
1336
Mehdi Amini86623052016-12-16 19:16:29 +00001337void MetadataLoader::setStripTBAA(bool StripTBAA) {
1338 return Pimpl->setStripTBAA(StripTBAA);
1339}
1340
1341bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
1342
Mehdi Aminief27db82016-12-12 19:34:26 +00001343unsigned MetadataLoader::size() const { return Pimpl->size(); }
1344void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }