Line data Source code
1 : //===- 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/DenseSet.h"
18 : #include "llvm/ADT/None.h"
19 : #include "llvm/ADT/STLExtras.h"
20 : #include "llvm/ADT/SmallString.h"
21 : #include "llvm/ADT/SmallVector.h"
22 : #include "llvm/ADT/Statistic.h"
23 : #include "llvm/ADT/StringRef.h"
24 : #include "llvm/ADT/Twine.h"
25 : #include "llvm/Bitcode/BitcodeReader.h"
26 : #include "llvm/Bitcode/BitstreamReader.h"
27 : #include "llvm/Bitcode/LLVMBitCodes.h"
28 : #include "llvm/IR/Argument.h"
29 : #include "llvm/IR/Attributes.h"
30 : #include "llvm/IR/AutoUpgrade.h"
31 : #include "llvm/IR/BasicBlock.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/DiagnosticPrinter.h"
41 : #include "llvm/IR/Function.h"
42 : #include "llvm/IR/GVMaterializer.h"
43 : #include "llvm/IR/GlobalAlias.h"
44 : #include "llvm/IR/GlobalIFunc.h"
45 : #include "llvm/IR/GlobalIndirectSymbol.h"
46 : #include "llvm/IR/GlobalObject.h"
47 : #include "llvm/IR/GlobalValue.h"
48 : #include "llvm/IR/GlobalVariable.h"
49 : #include "llvm/IR/InlineAsm.h"
50 : #include "llvm/IR/InstrTypes.h"
51 : #include "llvm/IR/Instruction.h"
52 : #include "llvm/IR/Instructions.h"
53 : #include "llvm/IR/IntrinsicInst.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/TrackingMDRef.h"
60 : #include "llvm/IR/Type.h"
61 : #include "llvm/IR/ValueHandle.h"
62 : #include "llvm/Support/AtomicOrdering.h"
63 : #include "llvm/Support/Casting.h"
64 : #include "llvm/Support/CommandLine.h"
65 : #include "llvm/Support/Compiler.h"
66 : #include "llvm/Support/Debug.h"
67 : #include "llvm/Support/Error.h"
68 : #include "llvm/Support/ErrorHandling.h"
69 : #include "llvm/Support/ManagedStatic.h"
70 : #include "llvm/Support/MemoryBuffer.h"
71 : #include "llvm/Support/raw_ostream.h"
72 : #include <algorithm>
73 : #include <cassert>
74 : #include <cstddef>
75 : #include <cstdint>
76 : #include <deque>
77 : #include <limits>
78 : #include <map>
79 : #include <memory>
80 : #include <string>
81 : #include <system_error>
82 : #include <tuple>
83 : #include <utility>
84 : #include <vector>
85 :
86 : using namespace llvm;
87 :
88 : #define DEBUG_TYPE "bitcode-reader"
89 :
90 : STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded");
91 : STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created");
92 : STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded");
93 :
94 : /// Flag whether we need to import full type definitions for ThinLTO.
95 : /// Currently needed for Darwin and LLDB.
96 : static cl::opt<bool> ImportFullTypeDefinitions(
97 : "import-full-type-definitions", cl::init(false), cl::Hidden,
98 : cl::desc("Import full type definitions for ThinLTO."));
99 :
100 : static cl::opt<bool> DisableLazyLoading(
101 : "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
102 : cl::desc("Force disable the lazy-loading on-demand of metadata when "
103 : "loading bitcode for importing."));
104 :
105 : namespace {
106 :
107 85 : static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
108 :
109 : class BitcodeReaderMetadataList {
110 : /// Array of metadata references.
111 : ///
112 : /// Don't use std::vector here. Some versions of libc++ copy (instead of
113 : /// move) on resize, and TrackingMDRef is very expensive to copy.
114 : SmallVector<TrackingMDRef, 1> MetadataPtrs;
115 :
116 : /// The set of indices in MetadataPtrs above of forward references that were
117 : /// generated.
118 : SmallDenseSet<unsigned, 1> ForwardReference;
119 :
120 : /// The set of indices in MetadataPtrs above of Metadata that need to be
121 : /// resolved.
122 : SmallDenseSet<unsigned, 1> UnresolvedNodes;
123 :
124 : /// Structures for resolving old type refs.
125 : struct {
126 : SmallDenseMap<MDString *, TempMDTuple, 1> Unknown;
127 : SmallDenseMap<MDString *, DICompositeType *, 1> Final;
128 : SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
129 : SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
130 : } OldTypeRefs;
131 :
132 : LLVMContext &Context;
133 :
134 : public:
135 6958 : BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {}
136 :
137 : // vector compatibility methods
138 64127 : unsigned size() const { return MetadataPtrs.size(); }
139 313 : void resize(unsigned N) { MetadataPtrs.resize(N); }
140 25469 : void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
141 : void clear() { MetadataPtrs.clear(); }
142 : Metadata *back() const { return MetadataPtrs.back(); }
143 : void pop_back() { MetadataPtrs.pop_back(); }
144 15 : bool empty() const { return MetadataPtrs.empty(); }
145 :
146 : Metadata *operator[](unsigned i) const {
147 : assert(i < MetadataPtrs.size());
148 : return MetadataPtrs[i];
149 : }
150 :
151 : Metadata *lookup(unsigned I) const {
152 9820 : if (I < MetadataPtrs.size())
153 : return MetadataPtrs[I];
154 : return nullptr;
155 : }
156 :
157 : void shrinkTo(unsigned N) {
158 : assert(N <= size() && "Invalid shrinkTo request!");
159 : assert(ForwardReference.empty() && "Unexpected forward refs");
160 : assert(UnresolvedNodes.empty() && "Unexpected unresolved node");
161 13164 : MetadataPtrs.resize(N);
162 : }
163 :
164 : /// Return the given metadata, creating a replaceable forward reference if
165 : /// necessary.
166 : Metadata *getMetadataFwdRef(unsigned Idx);
167 :
168 : /// Return the given metadata only if it is fully resolved.
169 : ///
170 : /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
171 : /// would give \c false.
172 : Metadata *getMetadataIfResolved(unsigned Idx);
173 :
174 : MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
175 : void assignValue(Metadata *MD, unsigned Idx);
176 : void tryToResolveCycles();
177 26358 : bool hasFwdRefs() const { return !ForwardReference.empty(); }
178 : int getNextFwdRef() {
179 : assert(hasFwdRefs());
180 8 : return *ForwardReference.begin();
181 : }
182 :
183 : /// Upgrade a type that had an MDString reference.
184 : void addTypeRef(MDString &UUID, DICompositeType &CT);
185 :
186 : /// Upgrade a type that had an MDString reference.
187 : Metadata *upgradeTypeRef(Metadata *MaybeUUID);
188 :
189 : /// Upgrade a type ref array that may have MDString references.
190 : Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
191 :
192 : private:
193 : Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
194 : };
195 :
196 26679 : void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
197 : if (auto *MDN = dyn_cast<MDNode>(MD))
198 : if (!MDN->isResolved())
199 : UnresolvedNodes.insert(Idx);
200 :
201 26679 : if (Idx == size()) {
202 25469 : push_back(MD);
203 25469 : return;
204 : }
205 :
206 1210 : if (Idx >= size())
207 0 : resize(Idx + 1);
208 :
209 1210 : TrackingMDRef &OldMD = MetadataPtrs[Idx];
210 1210 : if (!OldMD) {
211 285 : OldMD.reset(MD);
212 285 : return;
213 : }
214 :
215 : // If there was a forward reference to this value, replace it.
216 : TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
217 : PrevMD->replaceAllUsesWith(MD);
218 : ForwardReference.erase(Idx);
219 : }
220 :
221 21686 : Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
222 21686 : if (Idx >= size())
223 310 : resize(Idx + 1);
224 :
225 43372 : if (Metadata *MD = MetadataPtrs[Idx])
226 : return MD;
227 :
228 : // Track forward refs to be resolved later.
229 : ForwardReference.insert(Idx);
230 :
231 : // Create and return a placeholder, which will later be RAUW'd.
232 : ++NumMDNodeTemporary;
233 925 : Metadata *MD = MDNode::getTemporary(Context, None).release();
234 1850 : MetadataPtrs[Idx].reset(MD);
235 925 : return MD;
236 : }
237 :
238 7460 : Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
239 : Metadata *MD = lookup(Idx);
240 5723 : if (auto *N = dyn_cast_or_null<MDNode>(MD))
241 : if (!N->isResolved())
242 16 : return nullptr;
243 : return MD;
244 : }
245 :
246 : MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
247 14130 : return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
248 : }
249 :
250 4069 : void BitcodeReaderMetadataList::tryToResolveCycles() {
251 4069 : if (!ForwardReference.empty())
252 : // Still forward references... can't resolve cycles.
253 : return;
254 :
255 : // Give up on finding a full definition for any forward decls that remain.
256 8138 : for (const auto &Ref : OldTypeRefs.FwdDecls)
257 0 : OldTypeRefs.Final.insert(Ref);
258 4069 : OldTypeRefs.FwdDecls.clear();
259 :
260 : // Upgrade from old type ref arrays. In strange cases, this could add to
261 : // OldTypeRefs.Unknown.
262 4069 : for (const auto &Array : OldTypeRefs.Arrays)
263 0 : Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
264 : OldTypeRefs.Arrays.clear();
265 :
266 : // Replace old string-based type refs with the resolved node, if possible.
267 : // If we haven't seen the node, leave it to the verifier to complain about
268 : // the invalid string reference.
269 8140 : for (const auto &Ref : OldTypeRefs.Unknown) {
270 4 : if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
271 : Ref.second->replaceAllUsesWith(CT);
272 : else
273 0 : Ref.second->replaceAllUsesWith(Ref.first);
274 : }
275 4069 : OldTypeRefs.Unknown.clear();
276 :
277 4069 : if (UnresolvedNodes.empty())
278 : // Nothing to do.
279 : return;
280 :
281 : // Resolve any cycles.
282 1456 : for (unsigned I : UnresolvedNodes) {
283 1425 : auto &MD = MetadataPtrs[I];
284 : auto *N = dyn_cast_or_null<MDNode>(MD);
285 : if (!N)
286 : continue;
287 :
288 : assert(!N->isTemporary() && "Unexpected forward reference");
289 1425 : N->resolveCycles();
290 : }
291 :
292 : // Make sure we return early again until there's another unresolved ref.
293 : UnresolvedNodes.clear();
294 : }
295 :
296 6 : void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
297 : DICompositeType &CT) {
298 : assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
299 6 : if (CT.isForwardDecl())
300 0 : OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
301 : else
302 6 : OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
303 6 : }
304 :
305 2372 : Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
306 2372 : auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
307 2372 : if (LLVM_LIKELY(!UUID))
308 : return MaybeUUID;
309 :
310 68 : if (auto *CT = OldTypeRefs.Final.lookup(UUID))
311 : return CT;
312 :
313 2 : auto &Ref = OldTypeRefs.Unknown[UUID];
314 2 : if (!Ref)
315 2 : Ref = MDNode::getTemporary(Context, None);
316 2 : return Ref.get();
317 : }
318 :
319 18 : Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
320 18 : auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
321 18 : if (!Tuple || Tuple->isDistinct())
322 0 : return MaybeTuple;
323 :
324 : // Look through the array immediately if possible.
325 18 : if (!Tuple->isTemporary())
326 18 : return resolveTypeRefArray(Tuple);
327 :
328 : // Create and return a placeholder to use for now. Eventually
329 : // resolveTypeRefArrays() will be resolve this forward reference.
330 0 : OldTypeRefs.Arrays.emplace_back(
331 0 : std::piecewise_construct, std::forward_as_tuple(Tuple),
332 0 : std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
333 0 : return OldTypeRefs.Arrays.back().second.get();
334 : }
335 :
336 18 : Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
337 : auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
338 18 : if (!Tuple || Tuple->isDistinct())
339 0 : return MaybeTuple;
340 :
341 : // Look through the DITypeRefArray, upgrading each DITypeRef.
342 : SmallVector<Metadata *, 32> Ops;
343 18 : Ops.reserve(Tuple->getNumOperands());
344 46 : for (Metadata *MD : Tuple->operands())
345 28 : Ops.push_back(upgradeTypeRef(MD));
346 :
347 18 : return MDTuple::get(Context, Ops);
348 : }
349 :
350 : namespace {
351 :
352 : class PlaceholderQueue {
353 : // Placeholders would thrash around when moved, so store in a std::deque
354 : // instead of some sort of vector.
355 : std::deque<DistinctMDOperandPlaceholder> PHs;
356 :
357 : public:
358 4068 : ~PlaceholderQueue() {
359 : assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed");
360 : }
361 : bool empty() { return PHs.empty(); }
362 : DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
363 : void flush(BitcodeReaderMetadataList &MetadataList);
364 :
365 : /// Return the list of temporaries nodes in the queue, these need to be
366 : /// loaded before we can flush the queue.
367 4074 : void getTemporaries(BitcodeReaderMetadataList &MetadataList,
368 : DenseSet<unsigned> &Temporaries) {
369 7121 : for (auto &PH : PHs) {
370 3047 : auto ID = PH.getID();
371 : auto *MD = MetadataList.lookup(ID);
372 3047 : if (!MD) {
373 : Temporaries.insert(ID);
374 12 : continue;
375 : }
376 : auto *N = dyn_cast_or_null<MDNode>(MD);
377 3035 : if (N && N->isTemporary())
378 : Temporaries.insert(ID);
379 : }
380 4074 : }
381 : };
382 :
383 : } // end anonymous namespace
384 :
385 : DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
386 : PHs.emplace_back(ID);
387 : return PHs.back();
388 : }
389 :
390 4069 : void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
391 7096 : while (!PHs.empty()) {
392 3027 : auto *MD = MetadataList.lookup(PHs.front().getID());
393 : assert(MD && "Flushing placeholder on unassigned MD");
394 : #ifndef NDEBUG
395 : if (auto *MDN = dyn_cast<MDNode>(MD))
396 : assert(MDN->isResolved() &&
397 : "Flushing Placeholder while cycles aren't resolved");
398 : #endif
399 3027 : PHs.front().replaceUseWith(MD);
400 3027 : PHs.pop_front();
401 : }
402 4069 : }
403 :
404 : } // anonynous namespace
405 :
406 0 : static Error error(const Twine &Message) {
407 : return make_error<StringError>(
408 0 : Message, make_error_code(BitcodeError::CorruptedBitcode));
409 : }
410 :
411 : class MetadataLoader::MetadataLoaderImpl {
412 : BitcodeReaderMetadataList MetadataList;
413 : BitcodeReaderValueList &ValueList;
414 : BitstreamCursor &Stream;
415 : LLVMContext &Context;
416 : Module &TheModule;
417 : std::function<Type *(unsigned)> getTypeByID;
418 :
419 : /// Cursor associated with the lazy-loading of Metadata. This is the easy way
420 : /// to keep around the right "context" (Abbrev list) to be able to jump in
421 : /// the middle of the metadata block and load any record.
422 : BitstreamCursor IndexCursor;
423 :
424 : /// Index that keeps track of MDString values.
425 : std::vector<StringRef> MDStringRef;
426 :
427 : /// On-demand loading of a single MDString. Requires the index above to be
428 : /// populated.
429 : MDString *lazyLoadOneMDString(unsigned Idx);
430 :
431 : /// Index that keeps track of where to find a metadata record in the stream.
432 : std::vector<uint64_t> GlobalMetadataBitPosIndex;
433 :
434 : /// Populate the index above to enable lazily loading of metadata, and load
435 : /// the named metadata as well as the transitively referenced global
436 : /// Metadata.
437 : Expected<bool> lazyLoadModuleMetadataBlock();
438 :
439 : /// On-demand loading of a single metadata. Requires the index above to be
440 : /// populated.
441 : void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);
442 :
443 : // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
444 : // point from SP to CU after a block is completly parsed.
445 : std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
446 :
447 : /// Functions that need to be matched with subprograms when upgrading old
448 : /// metadata.
449 : SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
450 :
451 : // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
452 : DenseMap<unsigned, unsigned> MDKindMap;
453 :
454 : bool StripTBAA = false;
455 : bool HasSeenOldLoopTags = false;
456 : bool NeedUpgradeToDIGlobalVariableExpression = false;
457 : bool NeedDeclareExpressionUpgrade = false;
458 :
459 : /// True if metadata is being parsed for a module being ThinLTO imported.
460 : bool IsImporting = false;
461 :
462 : Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
463 : PlaceholderQueue &Placeholders, StringRef Blob,
464 : unsigned &NextMetadataNo);
465 : Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
466 : function_ref<void(StringRef)> CallBack);
467 : Error parseGlobalObjectAttachment(GlobalObject &GO,
468 : ArrayRef<uint64_t> Record);
469 : Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
470 :
471 : void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
472 :
473 : /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
474 2571 : void upgradeCUSubprograms() {
475 2577 : for (auto CU_SP : CUSubprograms)
476 : if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
477 27 : for (auto &Op : SPs->operands())
478 : if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
479 : SP->replaceUnit(CU_SP.first);
480 : CUSubprograms.clear();
481 2571 : }
482 :
483 : /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
484 2571 : void upgradeCUVariables() {
485 2571 : if (!NeedUpgradeToDIGlobalVariableExpression)
486 : return;
487 :
488 : // Upgrade list of variables attached to the CUs.
489 44 : if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
490 40 : for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
491 20 : auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
492 : if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
493 66 : for (unsigned I = 0; I < GVs->getNumOperands(); I++)
494 : if (auto *GV =
495 46 : dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
496 8 : auto *DGVE = DIGlobalVariableExpression::getDistinct(
497 8 : Context, GV, DIExpression::get(Context, {}));
498 8 : GVs->replaceOperandWith(I, DGVE);
499 : }
500 : }
501 :
502 : // Upgrade variables attached to globals.
503 67 : for (auto &GV : TheModule.globals()) {
504 : SmallVector<MDNode *, 1> MDs;
505 45 : GV.getMetadata(LLVMContext::MD_dbg, MDs);
506 45 : GV.eraseMetadata(LLVMContext::MD_dbg);
507 90 : for (auto *MD : MDs)
508 : if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) {
509 3 : auto *DGVE = DIGlobalVariableExpression::getDistinct(
510 3 : Context, DGV, DIExpression::get(Context, {}));
511 3 : GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
512 : } else
513 42 : GV.addMetadata(LLVMContext::MD_dbg, *MD);
514 : }
515 : }
516 :
517 : /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
518 : /// describes a function argument.
519 57839 : void upgradeDeclareExpressions(Function &F) {
520 57839 : if (!NeedDeclareExpressionUpgrade)
521 : return;
522 :
523 63 : for (auto &BB : F)
524 161 : for (auto &I : BB)
525 : if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
526 10 : if (auto *DIExpr = DDI->getExpression())
527 : if (DIExpr->startsWithDeref() &&
528 : dyn_cast_or_null<Argument>(DDI->getAddress())) {
529 : SmallVector<uint64_t, 8> Ops;
530 1 : Ops.append(std::next(DIExpr->elements_begin()),
531 : DIExpr->elements_end());
532 1 : auto *E = DIExpression::get(Context, Ops);
533 1 : DDI->setOperand(2, MetadataAsValue::get(Context, E));
534 : }
535 : }
536 :
537 : /// Upgrade the expression from previous versions.
538 110 : Error upgradeDIExpression(uint64_t FromVersion,
539 : MutableArrayRef<uint64_t> &Expr,
540 : SmallVectorImpl<uint64_t> &Buffer) {
541 110 : auto N = Expr.size();
542 110 : switch (FromVersion) {
543 : default:
544 0 : return error("Invalid record");
545 6 : case 0:
546 6 : if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
547 3 : Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
548 : LLVM_FALLTHROUGH;
549 : case 1:
550 : // Move DW_OP_deref to the end.
551 16 : if (N && Expr[0] == dwarf::DW_OP_deref) {
552 : auto End = Expr.end();
553 4 : if (Expr.size() >= 3 &&
554 2 : *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
555 : End = std::prev(End, 3);
556 : std::move(std::next(Expr.begin()), End, Expr.begin());
557 4 : *std::prev(End) = dwarf::DW_OP_deref;
558 : }
559 16 : NeedDeclareExpressionUpgrade = true;
560 : LLVM_FALLTHROUGH;
561 17 : case 2: {
562 : // Change DW_OP_plus to DW_OP_plus_uconst.
563 : // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
564 17 : auto SubExpr = ArrayRef<uint64_t>(Expr);
565 36 : while (!SubExpr.empty()) {
566 : // Skip past other operators with their operands
567 : // for this version of the IR, obtained from
568 : // from historic DIExpression::ExprOperand::getSize().
569 : size_t HistoricSize;
570 19 : switch (SubExpr.front()) {
571 7 : default:
572 7 : HistoricSize = 1;
573 7 : break;
574 8 : case dwarf::DW_OP_constu:
575 : case dwarf::DW_OP_minus:
576 : case dwarf::DW_OP_plus:
577 8 : HistoricSize = 2;
578 8 : break;
579 4 : case dwarf::DW_OP_LLVM_fragment:
580 4 : HistoricSize = 3;
581 4 : break;
582 : }
583 :
584 : // If the expression is malformed, make sure we don't
585 : // copy more elements than we should.
586 19 : HistoricSize = std::min(SubExpr.size(), HistoricSize);
587 19 : ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1);
588 :
589 19 : switch (SubExpr.front()) {
590 5 : case dwarf::DW_OP_plus:
591 5 : Buffer.push_back(dwarf::DW_OP_plus_uconst);
592 5 : Buffer.append(Args.begin(), Args.end());
593 5 : break;
594 1 : case dwarf::DW_OP_minus:
595 1 : Buffer.push_back(dwarf::DW_OP_constu);
596 1 : Buffer.append(Args.begin(), Args.end());
597 1 : Buffer.push_back(dwarf::DW_OP_minus);
598 1 : break;
599 13 : default:
600 13 : Buffer.push_back(*SubExpr.begin());
601 13 : Buffer.append(Args.begin(), Args.end());
602 13 : break;
603 : }
604 :
605 : // Continue with remaining elements.
606 : SubExpr = SubExpr.slice(HistoricSize);
607 : }
608 17 : Expr = MutableArrayRef<uint64_t>(Buffer);
609 : LLVM_FALLTHROUGH;
610 : }
611 : case 3:
612 : // Up-to-date!
613 : break;
614 : }
615 :
616 : return Error::success();
617 : }
618 :
619 : void upgradeDebugInfo() {
620 2571 : upgradeCUSubprograms();
621 2571 : upgradeCUVariables();
622 : }
623 :
624 : public:
625 3479 : MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
626 : BitcodeReaderValueList &ValueList,
627 : std::function<Type *(unsigned)> getTypeByID,
628 : bool IsImporting)
629 3479 : : MetadataList(TheModule.getContext()), ValueList(ValueList),
630 3479 : Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule),
631 3479 : getTypeByID(std::move(getTypeByID)), IsImporting(IsImporting) {}
632 :
633 : Error parseMetadata(bool ModuleLevel);
634 :
635 : bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
636 :
637 9820 : Metadata *getMetadataFwdRefOrLoad(unsigned ID) {
638 19640 : if (ID < MDStringRef.size())
639 0 : return lazyLoadOneMDString(ID);
640 9820 : if (auto *MD = MetadataList.lookup(ID))
641 : return MD;
642 : // If lazy-loading is enabled, we try recursively to load the operand
643 : // instead of creating a temporary.
644 0 : if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
645 : PlaceholderQueue Placeholders;
646 0 : lazyLoadOneMetadata(ID, Placeholders);
647 0 : resolveForwardRefsAndPlaceholders(Placeholders);
648 : return MetadataList.lookup(ID);
649 : }
650 0 : return MetadataList.getMetadataFwdRef(ID);
651 : }
652 :
653 : MDNode *getMDNodeFwdRefOrNull(unsigned Idx) {
654 8254 : return MetadataList.getMDNodeFwdRefOrNull(Idx);
655 : }
656 :
657 : DISubprogram *lookupSubprogramForFunction(Function *F) {
658 13164 : return FunctionsWithSPs.lookup(F);
659 : }
660 :
661 : bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }
662 :
663 : Error parseMetadataAttachment(
664 : Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
665 :
666 : Error parseMetadataKinds();
667 :
668 2 : void setStripTBAA(bool Value) { StripTBAA = Value; }
669 0 : bool isStrippingTBAA() { return StripTBAA; }
670 :
671 : unsigned size() const { return MetadataList.size(); }
672 : void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
673 57839 : void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
674 : };
675 :
676 : Expected<bool>
677 15 : MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
678 15 : IndexCursor = Stream;
679 : SmallVector<uint64_t, 64> Record;
680 : // Get the abbrevs, and preload record positions to make them lazy-loadable.
681 : while (true) {
682 : BitstreamEntry Entry = IndexCursor.advanceSkippingSubblocks(
683 39 : BitstreamCursor::AF_DontPopBlockAtEnd);
684 39 : switch (Entry.Kind) {
685 : case BitstreamEntry::SubBlock: // Handled for us already.
686 : case BitstreamEntry::Error:
687 0 : return error("Malformed block");
688 3 : case BitstreamEntry::EndBlock: {
689 : return true;
690 : }
691 : case BitstreamEntry::Record: {
692 : // The interesting case.
693 : ++NumMDRecordLoaded;
694 36 : uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
695 36 : auto Code = IndexCursor.skipRecord(Entry.ID);
696 : switch (Code) {
697 15 : case bitc::METADATA_STRINGS: {
698 : // Rewind and parse the strings.
699 15 : IndexCursor.JumpToBit(CurrentPos);
700 15 : StringRef Blob;
701 : Record.clear();
702 15 : IndexCursor.readRecord(Entry.ID, Record, &Blob);
703 15 : unsigned NumStrings = Record[0];
704 15 : MDStringRef.reserve(NumStrings);
705 : auto IndexNextMDString = [&](StringRef Str) {
706 94 : MDStringRef.push_back(Str);
707 15 : };
708 15 : if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
709 : return std::move(Err);
710 15 : break;
711 : }
712 3 : case bitc::METADATA_INDEX_OFFSET: {
713 : // This is the offset to the index, when we see this we skip all the
714 : // records and load only an index to these.
715 3 : IndexCursor.JumpToBit(CurrentPos);
716 : Record.clear();
717 3 : IndexCursor.readRecord(Entry.ID, Record);
718 3 : if (Record.size() != 2)
719 0 : return error("Invalid record");
720 3 : auto Offset = Record[0] + (Record[1] << 32);
721 3 : auto BeginPos = IndexCursor.GetCurrentBitNo();
722 3 : IndexCursor.JumpToBit(BeginPos + Offset);
723 : Entry = IndexCursor.advanceSkippingSubblocks(
724 3 : BitstreamCursor::AF_DontPopBlockAtEnd);
725 : assert(Entry.Kind == BitstreamEntry::Record &&
726 : "Corrupted bitcode: Expected `Record` when trying to find the "
727 : "Metadata index");
728 : Record.clear();
729 3 : auto Code = IndexCursor.readRecord(Entry.ID, Record);
730 : (void)Code;
731 : assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
732 : "`METADATA_INDEX` when trying "
733 : "to find the Metadata index");
734 :
735 : // Delta unpack
736 3 : auto CurrentValue = BeginPos;
737 6 : GlobalMetadataBitPosIndex.reserve(Record.size());
738 99 : for (auto &Elt : Record) {
739 96 : CurrentValue += Elt;
740 96 : GlobalMetadataBitPosIndex.push_back(CurrentValue);
741 : }
742 3 : break;
743 : }
744 : case bitc::METADATA_INDEX:
745 : // We don't expect to get there, the Index is loaded when we encounter
746 : // the offset.
747 0 : return error("Corrupted Metadata block");
748 6 : case bitc::METADATA_NAME: {
749 : // Named metadata need to be materialized now and aren't deferred.
750 6 : IndexCursor.JumpToBit(CurrentPos);
751 : Record.clear();
752 6 : unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
753 : assert(Code == bitc::METADATA_NAME);
754 :
755 : // Read name of the named metadata.
756 : SmallString<8> Name(Record.begin(), Record.end());
757 : Code = IndexCursor.ReadCode();
758 :
759 : // Named Metadata comes in two parts, we expect the name to be followed
760 : // by the node
761 : Record.clear();
762 6 : unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
763 : assert(NextBitCode == bitc::METADATA_NAMED_NODE);
764 : (void)NextBitCode;
765 :
766 : // Read named metadata elements.
767 6 : unsigned Size = Record.size();
768 12 : NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
769 14 : for (unsigned i = 0; i != Size; ++i) {
770 : // FIXME: We could use a placeholder here, however NamedMDNode are
771 : // taking MDNode as operand and not using the Metadata infrastructure.
772 : // It is acknowledged by 'TODO: Inherit from Metadata' in the
773 : // NamedMDNode class definition.
774 16 : MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
775 : assert(MD && "Invalid record");
776 8 : NMD->addOperand(MD);
777 : }
778 : break;
779 : }
780 0 : case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
781 : // FIXME: we need to do this early because we don't materialize global
782 : // value explicitly.
783 0 : IndexCursor.JumpToBit(CurrentPos);
784 : Record.clear();
785 0 : IndexCursor.readRecord(Entry.ID, Record);
786 0 : if (Record.size() % 2 == 0)
787 0 : return error("Invalid record");
788 0 : unsigned ValueID = Record[0];
789 0 : if (ValueID >= ValueList.size())
790 0 : return error("Invalid record");
791 : if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
792 0 : if (Error Err = parseGlobalObjectAttachment(
793 0 : *GO, ArrayRef<uint64_t>(Record).slice(1)))
794 : return std::move(Err);
795 : break;
796 : }
797 12 : case bitc::METADATA_KIND:
798 : case bitc::METADATA_STRING_OLD:
799 : case bitc::METADATA_OLD_FN_NODE:
800 : case bitc::METADATA_OLD_NODE:
801 : case bitc::METADATA_VALUE:
802 : case bitc::METADATA_DISTINCT_NODE:
803 : case bitc::METADATA_NODE:
804 : case bitc::METADATA_LOCATION:
805 : case bitc::METADATA_GENERIC_DEBUG:
806 : case bitc::METADATA_SUBRANGE:
807 : case bitc::METADATA_ENUMERATOR:
808 : case bitc::METADATA_BASIC_TYPE:
809 : case bitc::METADATA_DERIVED_TYPE:
810 : case bitc::METADATA_COMPOSITE_TYPE:
811 : case bitc::METADATA_SUBROUTINE_TYPE:
812 : case bitc::METADATA_MODULE:
813 : case bitc::METADATA_FILE:
814 : case bitc::METADATA_COMPILE_UNIT:
815 : case bitc::METADATA_SUBPROGRAM:
816 : case bitc::METADATA_LEXICAL_BLOCK:
817 : case bitc::METADATA_LEXICAL_BLOCK_FILE:
818 : case bitc::METADATA_NAMESPACE:
819 : case bitc::METADATA_MACRO:
820 : case bitc::METADATA_MACRO_FILE:
821 : case bitc::METADATA_TEMPLATE_TYPE:
822 : case bitc::METADATA_TEMPLATE_VALUE:
823 : case bitc::METADATA_GLOBAL_VAR:
824 : case bitc::METADATA_LOCAL_VAR:
825 : case bitc::METADATA_LABEL:
826 : case bitc::METADATA_EXPRESSION:
827 : case bitc::METADATA_OBJC_PROPERTY:
828 : case bitc::METADATA_IMPORTED_ENTITY:
829 : case bitc::METADATA_GLOBAL_VAR_EXPR:
830 : // We don't expect to see any of these, if we see one, give up on
831 : // lazy-loading and fallback.
832 : MDStringRef.clear();
833 : GlobalMetadataBitPosIndex.clear();
834 : return false;
835 : }
836 : break;
837 : }
838 : }
839 24 : }
840 : }
841 :
842 : /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
843 : /// module level metadata.
844 2571 : Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
845 2571 : if (!ModuleLevel && MetadataList.hasFwdRefs())
846 0 : return error("Invalid metadata: fwd refs into function blocks");
847 :
848 : // Record the entry position so that we can jump back here and efficiently
849 : // skip the whole block in case we lazy-load.
850 2571 : auto EntryPos = Stream.GetCurrentBitNo();
851 :
852 2571 : if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
853 0 : return error("Invalid record");
854 :
855 : SmallVector<uint64_t, 64> Record;
856 : PlaceholderQueue Placeholders;
857 :
858 : // We lazy-load module-level metadata: we build an index for each record, and
859 : // then load individual record as needed, starting with the named metadata.
860 2571 : if (ModuleLevel && IsImporting && MetadataList.empty() &&
861 : !DisableLazyLoading) {
862 15 : auto SuccessOrErr = lazyLoadModuleMetadataBlock();
863 15 : if (!SuccessOrErr)
864 : return SuccessOrErr.takeError();
865 15 : if (SuccessOrErr.get()) {
866 : // An index was successfully created and we will be able to load metadata
867 : // on-demand.
868 6 : MetadataList.resize(MDStringRef.size() +
869 3 : GlobalMetadataBitPosIndex.size());
870 :
871 : // Reading the named metadata created forward references and/or
872 : // placeholders, that we flush here.
873 3 : resolveForwardRefsAndPlaceholders(Placeholders);
874 : upgradeDebugInfo();
875 : // Return at the beginning of the block, since it is easy to skip it
876 : // entirely from there.
877 3 : Stream.ReadBlockEnd(); // Pop the abbrev block context.
878 3 : Stream.JumpToBit(EntryPos);
879 3 : if (Stream.SkipBlock())
880 0 : return error("Invalid record");
881 : return Error::success();
882 : }
883 : // Couldn't load an index, fallback to loading all the block "old-style".
884 : }
885 :
886 2568 : unsigned NextMetadataNo = MetadataList.size();
887 :
888 : // Read all the records.
889 : while (true) {
890 27077 : BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
891 :
892 27077 : switch (Entry.Kind) {
893 : case BitstreamEntry::SubBlock: // Handled for us already.
894 : case BitstreamEntry::Error:
895 0 : return error("Malformed block");
896 2568 : case BitstreamEntry::EndBlock:
897 2568 : resolveForwardRefsAndPlaceholders(Placeholders);
898 : upgradeDebugInfo();
899 : return Error::success();
900 : case BitstreamEntry::Record:
901 : // The interesting case.
902 : break;
903 : }
904 :
905 : // Read a record.
906 : Record.clear();
907 24509 : StringRef Blob;
908 : ++NumMDRecordLoaded;
909 24509 : unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
910 24509 : if (Error Err =
911 24509 : parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
912 : return Err;
913 : }
914 : }
915 :
916 38 : MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
917 : ++NumMDStringLoaded;
918 38 : if (Metadata *MD = MetadataList.lookup(ID))
919 : return cast<MDString>(MD);
920 72 : auto MDS = MDString::get(Context, MDStringRef[ID]);
921 36 : MetadataList.assignValue(MDS, ID);
922 36 : return MDS;
923 : }
924 :
925 97 : void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
926 : unsigned ID, PlaceholderQueue &Placeholders) {
927 : assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
928 : assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
929 : // Lookup first if the metadata hasn't already been loaded.
930 97 : if (auto *MD = MetadataList.lookup(ID)) {
931 : auto *N = dyn_cast_or_null<MDNode>(MD);
932 9 : if (!N->isTemporary())
933 1 : return;
934 : }
935 : SmallVector<uint64_t, 64> Record;
936 96 : StringRef Blob;
937 288 : IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
938 96 : auto Entry = IndexCursor.advanceSkippingSubblocks();
939 : ++NumMDRecordLoaded;
940 96 : unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob);
941 192 : if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
942 0 : report_fatal_error("Can't lazyload MD");
943 : }
944 :
945 : /// Ensure that all forward-references and placeholders are resolved.
946 : /// Iteratively lazy-loading metadata on-demand if needed.
947 4069 : void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
948 : PlaceholderQueue &Placeholders) {
949 : DenseSet<unsigned> Temporaries;
950 : while (1) {
951 : // Populate Temporaries with the placeholders that haven't been loaded yet.
952 4074 : Placeholders.getTemporaries(MetadataList, Temporaries);
953 :
954 : // If we don't have any temporary, or FwdReference, we're done!
955 4074 : if (Temporaries.empty() && !MetadataList.hasFwdRefs())
956 : break;
957 :
958 : // First, load all the temporaries. This can add new placeholders or
959 : // forward references.
960 17 : for (auto ID : Temporaries)
961 12 : lazyLoadOneMetadata(ID, Placeholders);
962 : Temporaries.clear();
963 :
964 : // Second, load the forward-references. This can also add new placeholders
965 : // or forward references.
966 13 : while (MetadataList.hasFwdRefs())
967 8 : lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
968 : }
969 : // At this point we don't have any forward reference remaining, or temporary
970 : // that haven't been loaded. We can safely drop RAUW support and mark cycles
971 : // as resolved.
972 4069 : MetadataList.tryToResolveCycles();
973 :
974 : // Finally, everything is in place, we can replace the placeholders operands
975 : // with the final node they refer to.
976 4069 : Placeholders.flush(MetadataList);
977 4069 : }
978 :
979 24605 : Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
980 : SmallVectorImpl<uint64_t> &Record, unsigned Code,
981 : PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
982 :
983 24605 : bool IsDistinct = false;
984 : auto getMD = [&](unsigned ID) -> Metadata * {
985 : if (ID < MDStringRef.size())
986 : return lazyLoadOneMDString(ID);
987 : if (!IsDistinct) {
988 : if (auto *MD = MetadataList.lookup(ID))
989 : return MD;
990 : // If lazy-loading is enabled, we try recursively to load the operand
991 : // instead of creating a temporary.
992 : if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
993 : // Create a temporary for the node that is referencing the operand we
994 : // will lazy-load. It is needed before recursing in case there are
995 : // uniquing cycles.
996 : MetadataList.getMetadataFwdRef(NextMetadataNo);
997 : lazyLoadOneMetadata(ID, Placeholders);
998 : return MetadataList.lookup(ID);
999 : }
1000 : // Return a temporary.
1001 : return MetadataList.getMetadataFwdRef(ID);
1002 : }
1003 : if (auto *MD = MetadataList.getMetadataIfResolved(ID))
1004 : return MD;
1005 : return &Placeholders.getPlaceholderOp(ID);
1006 24605 : };
1007 : auto getMDOrNull = [&](unsigned ID) -> Metadata * {
1008 : if (ID)
1009 : return getMD(ID - 1);
1010 : return nullptr;
1011 24605 : };
1012 : auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
1013 402 : if (ID)
1014 6 : return MetadataList.getMetadataFwdRef(ID - 1);
1015 : return nullptr;
1016 : };
1017 : auto getMDString = [&](unsigned ID) -> MDString * {
1018 : // This requires that the ID is not really a forward reference. In
1019 : // particular, the MDString must already have been resolved.
1020 : auto MDS = getMDOrNull(ID);
1021 : return cast_or_null<MDString>(MDS);
1022 24605 : };
1023 :
1024 : // Support for old type refs.
1025 : auto getDITypeRefOrNull = [&](unsigned ID) {
1026 : return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1027 24605 : };
1028 :
1029 : #define GET_OR_DISTINCT(CLASS, ARGS) \
1030 : (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1031 :
1032 24605 : switch (Code) {
1033 : default: // Default behavior: ignore.
1034 : break;
1035 2081 : case bitc::METADATA_NAME: {
1036 : // Read name of the named metadata.
1037 : SmallString<8> Name(Record.begin(), Record.end());
1038 : Record.clear();
1039 2081 : Code = Stream.ReadCode();
1040 :
1041 : ++NumMDRecordLoaded;
1042 2081 : unsigned NextBitCode = Stream.readRecord(Code, Record);
1043 2081 : if (NextBitCode != bitc::METADATA_NAMED_NODE)
1044 0 : return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1045 :
1046 : // Read named metadata elements.
1047 2081 : unsigned Size = Record.size();
1048 4162 : NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1049 7544 : for (unsigned i = 0; i != Size; ++i) {
1050 10926 : MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1051 : if (!MD)
1052 0 : return error("Invalid record");
1053 5463 : NMD->addOperand(MD);
1054 : }
1055 : break;
1056 : }
1057 598 : case bitc::METADATA_OLD_FN_NODE: {
1058 : // FIXME: Remove in 4.0.
1059 : // This is a LocalAsMetadata record, the only type of function-local
1060 : // metadata.
1061 598 : if (Record.size() % 2 == 1)
1062 0 : return error("Invalid record");
1063 :
1064 : // If this isn't a LocalAsMetadata record, we're dropping it. This used
1065 : // to be legal, but there's no upgrade path.
1066 : auto dropRecord = [&] {
1067 : MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
1068 : NextMetadataNo++;
1069 598 : };
1070 598 : if (Record.size() != 2) {
1071 1 : dropRecord();
1072 598 : break;
1073 : }
1074 :
1075 1194 : Type *Ty = getTypeByID(Record[0]);
1076 597 : if (Ty->isMetadataTy() || Ty->isVoidTy()) {
1077 1 : dropRecord();
1078 1 : break;
1079 : }
1080 :
1081 596 : MetadataList.assignValue(
1082 1192 : LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1083 : NextMetadataNo);
1084 596 : NextMetadataNo++;
1085 596 : break;
1086 : }
1087 1346 : case bitc::METADATA_OLD_NODE: {
1088 : // FIXME: Remove in 4.0.
1089 1346 : if (Record.size() % 2 == 1)
1090 0 : return error("Invalid record");
1091 :
1092 : unsigned Size = Record.size();
1093 : SmallVector<Metadata *, 8> Elts;
1094 11830 : for (unsigned i = 0; i != Size; i += 2) {
1095 20968 : Type *Ty = getTypeByID(Record[i]);
1096 10484 : if (!Ty)
1097 0 : return error("Invalid record");
1098 10484 : if (Ty->isMetadataTy())
1099 11206 : Elts.push_back(getMD(Record[i + 1]));
1100 4881 : else if (!Ty->isVoidTy()) {
1101 : auto *MD =
1102 9248 : ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
1103 : assert(isa<ConstantAsMetadata>(MD) &&
1104 : "Expected non-function-local metadata");
1105 4624 : Elts.push_back(MD);
1106 : } else
1107 257 : Elts.push_back(nullptr);
1108 : }
1109 2692 : MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1110 1346 : NextMetadataNo++;
1111 : break;
1112 : }
1113 6831 : case bitc::METADATA_VALUE: {
1114 6831 : if (Record.size() != 2)
1115 0 : return error("Invalid record");
1116 :
1117 13662 : Type *Ty = getTypeByID(Record[0]);
1118 6831 : if (Ty->isMetadataTy() || Ty->isVoidTy())
1119 0 : return error("Invalid record");
1120 :
1121 6831 : MetadataList.assignValue(
1122 13662 : ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1123 : NextMetadataNo);
1124 6831 : NextMetadataNo++;
1125 6831 : break;
1126 : }
1127 1990 : case bitc::METADATA_DISTINCT_NODE:
1128 1990 : IsDistinct = true;
1129 : LLVM_FALLTHROUGH;
1130 7906 : case bitc::METADATA_NODE: {
1131 : SmallVector<Metadata *, 8> Elts;
1132 7906 : Elts.reserve(Record.size());
1133 32740 : for (unsigned ID : Record)
1134 24834 : Elts.push_back(getMDOrNull(ID));
1135 15812 : MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1136 5916 : : MDNode::get(Context, Elts),
1137 : NextMetadataNo);
1138 7906 : NextMetadataNo++;
1139 : break;
1140 : }
1141 54 : case bitc::METADATA_LOCATION: {
1142 108 : if (Record.size() != 5 && Record.size() != 6)
1143 0 : return error("Invalid record");
1144 :
1145 54 : IsDistinct = Record[0];
1146 54 : unsigned Line = Record[1];
1147 54 : unsigned Column = Record[2];
1148 54 : Metadata *Scope = getMD(Record[3]);
1149 54 : Metadata *InlinedAt = getMDOrNull(Record[4]);
1150 54 : bool ImplicitCode = Record.size() == 6 && Record[5];
1151 108 : MetadataList.assignValue(
1152 54 : GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
1153 : ImplicitCode)),
1154 : NextMetadataNo);
1155 54 : NextMetadataNo++;
1156 54 : break;
1157 : }
1158 20 : case bitc::METADATA_GENERIC_DEBUG: {
1159 20 : if (Record.size() < 4)
1160 0 : return error("Invalid record");
1161 :
1162 20 : IsDistinct = Record[0];
1163 20 : unsigned Tag = Record[1];
1164 20 : unsigned Version = Record[2];
1165 :
1166 20 : if (Tag >= 1u << 16 || Version != 0)
1167 0 : return error("Invalid record");
1168 :
1169 20 : auto *Header = getMDString(Record[3]);
1170 : SmallVector<Metadata *, 8> DwarfOps;
1171 35 : for (unsigned I = 4, E = Record.size(); I != E; ++I)
1172 30 : DwarfOps.push_back(getMDOrNull(Record[I]));
1173 40 : MetadataList.assignValue(
1174 20 : GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
1175 : NextMetadataNo);
1176 20 : NextMetadataNo++;
1177 : break;
1178 : }
1179 43 : case bitc::METADATA_SUBRANGE: {
1180 : Metadata *Val = nullptr;
1181 : // Operand 'count' is interpreted as:
1182 : // - Signed integer (version 0)
1183 : // - Metadata node (version 1)
1184 43 : switch (Record[0] >> 1) {
1185 : case 0:
1186 6 : Val = GET_OR_DISTINCT(DISubrange,
1187 : (Context, Record[1], unrotateSign(Record.back())));
1188 3 : break;
1189 : case 1:
1190 80 : Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
1191 : unrotateSign(Record.back())));
1192 40 : break;
1193 : default:
1194 0 : return error("Invalid record: Unsupported version of DISubrange");
1195 : }
1196 :
1197 43 : MetadataList.assignValue(Val, NextMetadataNo);
1198 : IsDistinct = Record[0] & 1;
1199 43 : NextMetadataNo++;
1200 43 : break;
1201 : }
1202 42 : case bitc::METADATA_ENUMERATOR: {
1203 42 : if (Record.size() != 3)
1204 0 : return error("Invalid record");
1205 :
1206 42 : IsDistinct = Record[0] & 1;
1207 42 : bool IsUnsigned = Record[0] & 2;
1208 84 : MetadataList.assignValue(
1209 84 : GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
1210 : IsUnsigned, getMDString(Record[2]))),
1211 : NextMetadataNo);
1212 42 : NextMetadataNo++;
1213 42 : break;
1214 : }
1215 212 : case bitc::METADATA_BASIC_TYPE: {
1216 424 : if (Record.size() < 6 || Record.size() > 7)
1217 0 : return error("Invalid record");
1218 :
1219 212 : IsDistinct = Record[0];
1220 212 : DINode::DIFlags Flags = (Record.size() > 6) ?
1221 190 : static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
1222 :
1223 424 : MetadataList.assignValue(
1224 212 : GET_OR_DISTINCT(DIBasicType,
1225 : (Context, Record[1], getMDString(Record[2]), Record[3],
1226 : Record[4], Record[5], Flags)),
1227 : NextMetadataNo);
1228 212 : NextMetadataNo++;
1229 212 : break;
1230 : }
1231 183 : case bitc::METADATA_DERIVED_TYPE: {
1232 366 : if (Record.size() < 12 || Record.size() > 13)
1233 0 : return error("Invalid record");
1234 :
1235 : // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1236 : // that there is no DWARF address space associated with DIDerivedType.
1237 : Optional<unsigned> DWARFAddressSpace;
1238 183 : if (Record.size() > 12 && Record[12])
1239 6 : DWARFAddressSpace = Record[12] - 1;
1240 :
1241 183 : IsDistinct = Record[0];
1242 183 : DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1243 366 : MetadataList.assignValue(
1244 366 : GET_OR_DISTINCT(DIDerivedType,
1245 : (Context, Record[1], getMDString(Record[2]),
1246 : getMDOrNull(Record[3]), Record[4],
1247 : getDITypeRefOrNull(Record[5]),
1248 : getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1249 : Record[9], DWARFAddressSpace, Flags,
1250 : getDITypeRefOrNull(Record[11]))),
1251 : NextMetadataNo);
1252 183 : NextMetadataNo++;
1253 : break;
1254 : }
1255 249 : case bitc::METADATA_COMPOSITE_TYPE: {
1256 498 : if (Record.size() < 16 || Record.size() > 17)
1257 0 : return error("Invalid record");
1258 :
1259 : // If we have a UUID and this is not a forward declaration, lookup the
1260 : // mapping.
1261 249 : IsDistinct = Record[0] & 0x1;
1262 : bool IsNotUsedInTypeRef = Record[0] >= 2;
1263 249 : unsigned Tag = Record[1];
1264 249 : MDString *Name = getMDString(Record[2]);
1265 249 : Metadata *File = getMDOrNull(Record[3]);
1266 249 : unsigned Line = Record[4];
1267 249 : Metadata *Scope = getDITypeRefOrNull(Record[5]);
1268 : Metadata *BaseType = nullptr;
1269 249 : uint64_t SizeInBits = Record[7];
1270 249 : if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1271 0 : return error("Alignment value is too large");
1272 249 : uint32_t AlignInBits = Record[8];
1273 : uint64_t OffsetInBits = 0;
1274 249 : DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1275 : Metadata *Elements = nullptr;
1276 249 : unsigned RuntimeLang = Record[12];
1277 : Metadata *VTableHolder = nullptr;
1278 : Metadata *TemplateParams = nullptr;
1279 : Metadata *Discriminator = nullptr;
1280 249 : auto *Identifier = getMDString(Record[15]);
1281 : // If this module is being parsed so that it can be ThinLTO imported
1282 : // into another module, composite types only need to be imported
1283 : // as type declarations (unless full type definitions requested).
1284 : // Create type declarations up front to save memory. Also, buildODRType
1285 : // handles the case where this is type ODRed with a definition needed
1286 : // by the importing module, in which case the existing definition is
1287 : // used.
1288 249 : if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
1289 38 : (Tag == dwarf::DW_TAG_enumeration_type ||
1290 19 : Tag == dwarf::DW_TAG_class_type ||
1291 22 : Tag == dwarf::DW_TAG_structure_type ||
1292 11 : Tag == dwarf::DW_TAG_union_type)) {
1293 : Flags = Flags | DINode::FlagFwdDecl;
1294 : } else {
1295 230 : BaseType = getDITypeRefOrNull(Record[6]);
1296 230 : OffsetInBits = Record[9];
1297 230 : Elements = getMDOrNull(Record[11]);
1298 230 : VTableHolder = getDITypeRefOrNull(Record[13]);
1299 230 : TemplateParams = getMDOrNull(Record[14]);
1300 230 : if (Record.size() > 16)
1301 213 : Discriminator = getMDOrNull(Record[16]);
1302 : }
1303 : DICompositeType *CT = nullptr;
1304 249 : if (Identifier)
1305 168 : CT = DICompositeType::buildODRType(
1306 : Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
1307 : SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1308 : VTableHolder, TemplateParams, Discriminator);
1309 :
1310 : // Create a node if we didn't get a lazy ODR type.
1311 168 : if (!CT)
1312 180 : CT = GET_OR_DISTINCT(DICompositeType,
1313 : (Context, Tag, Name, File, Line, Scope, BaseType,
1314 : SizeInBits, AlignInBits, OffsetInBits, Flags,
1315 : Elements, RuntimeLang, VTableHolder, TemplateParams,
1316 : Identifier, Discriminator));
1317 249 : if (!IsNotUsedInTypeRef && Identifier)
1318 6 : MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1319 :
1320 249 : MetadataList.assignValue(CT, NextMetadataNo);
1321 249 : NextMetadataNo++;
1322 249 : break;
1323 : }
1324 254 : case bitc::METADATA_SUBROUTINE_TYPE: {
1325 508 : if (Record.size() < 3 || Record.size() > 4)
1326 0 : return error("Invalid record");
1327 254 : bool IsOldTypeRefArray = Record[0] < 2;
1328 254 : unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1329 :
1330 254 : IsDistinct = Record[0] & 0x1;
1331 254 : DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1332 254 : Metadata *Types = getMDOrNull(Record[2]);
1333 254 : if (LLVM_UNLIKELY(IsOldTypeRefArray))
1334 18 : Types = MetadataList.upgradeTypeRefArray(Types);
1335 :
1336 508 : MetadataList.assignValue(
1337 254 : GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
1338 : NextMetadataNo);
1339 254 : NextMetadataNo++;
1340 254 : break;
1341 : }
1342 :
1343 12 : case bitc::METADATA_MODULE: {
1344 12 : if (Record.size() != 6)
1345 0 : return error("Invalid record");
1346 :
1347 12 : IsDistinct = Record[0];
1348 24 : MetadataList.assignValue(
1349 12 : GET_OR_DISTINCT(DIModule,
1350 : (Context, getMDOrNull(Record[1]),
1351 : getMDString(Record[2]), getMDString(Record[3]),
1352 : getMDString(Record[4]), getMDString(Record[5]))),
1353 : NextMetadataNo);
1354 12 : NextMetadataNo++;
1355 12 : break;
1356 : }
1357 :
1358 471 : case bitc::METADATA_FILE: {
1359 942 : if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
1360 0 : return error("Invalid record");
1361 :
1362 471 : IsDistinct = Record[0];
1363 : Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
1364 : // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
1365 : // is not present. This matches up with the old internal representation,
1366 : // and the old encoding for CSK_None in the ChecksumKind. The new
1367 : // representation reserves the value 0 in the ChecksumKind to continue to
1368 : // encode None in a backwards-compatible way.
1369 471 : if (Record.size() > 4 && Record[3] && Record[4])
1370 26 : Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
1371 26 : getMDString(Record[4]));
1372 942 : MetadataList.assignValue(
1373 942 : GET_OR_DISTINCT(
1374 : DIFile,
1375 : (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
1376 : Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
1377 : : None)),
1378 : NextMetadataNo);
1379 471 : NextMetadataNo++;
1380 : break;
1381 : }
1382 402 : case bitc::METADATA_COMPILE_UNIT: {
1383 804 : if (Record.size() < 14 || Record.size() > 19)
1384 0 : return error("Invalid record");
1385 :
1386 : // Ignore Record[0], which indicates whether this compile unit is
1387 : // distinct. It's always distinct.
1388 402 : IsDistinct = true;
1389 1571 : auto *CU = DICompileUnit::getDistinct(
1390 : Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
1391 : Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
1392 : Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1393 : getMDOrNull(Record[12]), getMDOrNull(Record[13]),
1394 395 : Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
1395 : Record.size() <= 14 ? 0 : Record[14],
1396 : Record.size() <= 16 ? true : Record[16],
1397 : Record.size() <= 17 ? false : Record[17],
1398 774 : Record.size() <= 18 ? 0 : Record[18]);
1399 :
1400 402 : MetadataList.assignValue(CU, NextMetadataNo);
1401 402 : NextMetadataNo++;
1402 :
1403 : // Move the Upgrade the list of subprograms.
1404 408 : if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1405 6 : CUSubprograms.push_back({CU, SPs});
1406 : break;
1407 : }
1408 383 : case bitc::METADATA_SUBPROGRAM: {
1409 766 : if (Record.size() < 18 || Record.size() > 21)
1410 0 : return error("Invalid record");
1411 :
1412 383 : IsDistinct =
1413 383 : (Record[0] & 1) || Record[8]; // All definitions should be distinct.
1414 : // Version 1 has a Function as Record[15].
1415 : // Version 2 has removed Record[15].
1416 : // Version 3 has the Unit as Record[15].
1417 : // Version 4 added thisAdjustment.
1418 : bool HasUnit = Record[0] >= 2;
1419 383 : if (HasUnit && Record.size() < 19)
1420 0 : return error("Invalid record");
1421 383 : Metadata *CUorFn = getMDOrNull(Record[15]);
1422 766 : unsigned Offset = Record.size() >= 19 ? 1 : 0;
1423 383 : bool HasFn = Offset && !HasUnit;
1424 : bool HasThisAdj = Record.size() >= 20;
1425 : bool HasThrownTypes = Record.size() >= 21;
1426 410 : DISubprogram *SP = GET_OR_DISTINCT(
1427 : DISubprogram,
1428 : (Context,
1429 : getDITypeRefOrNull(Record[1]), // scope
1430 : getMDString(Record[2]), // name
1431 : getMDString(Record[3]), // linkageName
1432 : getMDOrNull(Record[4]), // file
1433 : Record[5], // line
1434 : getMDOrNull(Record[6]), // type
1435 : Record[7], // isLocal
1436 : Record[8], // isDefinition
1437 : Record[9], // scopeLine
1438 : getDITypeRefOrNull(Record[10]), // containingType
1439 : Record[11], // virtuality
1440 : Record[12], // virtualIndex
1441 : HasThisAdj ? Record[19] : 0, // thisAdjustment
1442 : static_cast<DINode::DIFlags>(Record[13]), // flags
1443 : Record[14], // isOptimized
1444 : HasUnit ? CUorFn : nullptr, // unit
1445 : getMDOrNull(Record[15 + Offset]), // templateParams
1446 : getMDOrNull(Record[16 + Offset]), // declaration
1447 : getMDOrNull(Record[17 + Offset]), // retainedNodes
1448 : HasThrownTypes ? getMDOrNull(Record[20]) : nullptr // thrownTypes
1449 : ));
1450 383 : MetadataList.assignValue(SP, NextMetadataNo);
1451 383 : NextMetadataNo++;
1452 :
1453 : // Upgrade sp->function mapping to function->sp mapping.
1454 383 : if (HasFn) {
1455 : if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1456 19 : if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1457 19 : if (F->isMaterializable())
1458 : // Defer until materialized; unmaterialized functions may not have
1459 : // metadata.
1460 19 : FunctionsWithSPs[F] = SP;
1461 0 : else if (!F->empty())
1462 0 : F->setSubprogram(SP);
1463 : }
1464 : }
1465 : break;
1466 : }
1467 104 : case bitc::METADATA_LEXICAL_BLOCK: {
1468 104 : if (Record.size() != 5)
1469 0 : return error("Invalid record");
1470 :
1471 104 : IsDistinct = Record[0];
1472 208 : MetadataList.assignValue(
1473 104 : GET_OR_DISTINCT(DILexicalBlock,
1474 : (Context, getMDOrNull(Record[1]),
1475 : getMDOrNull(Record[2]), Record[3], Record[4])),
1476 : NextMetadataNo);
1477 104 : NextMetadataNo++;
1478 104 : break;
1479 : }
1480 42 : case bitc::METADATA_LEXICAL_BLOCK_FILE: {
1481 42 : if (Record.size() != 4)
1482 0 : return error("Invalid record");
1483 :
1484 42 : IsDistinct = Record[0];
1485 84 : MetadataList.assignValue(
1486 42 : GET_OR_DISTINCT(DILexicalBlockFile,
1487 : (Context, getMDOrNull(Record[1]),
1488 : getMDOrNull(Record[2]), Record[3])),
1489 : NextMetadataNo);
1490 42 : NextMetadataNo++;
1491 42 : break;
1492 : }
1493 36 : case bitc::METADATA_NAMESPACE: {
1494 : // Newer versions of DINamespace dropped file and line.
1495 : MDString *Name;
1496 72 : if (Record.size() == 3)
1497 35 : Name = getMDString(Record[2]);
1498 1 : else if (Record.size() == 5)
1499 1 : Name = getMDString(Record[3]);
1500 : else
1501 0 : return error("Invalid record");
1502 :
1503 36 : IsDistinct = Record[0] & 1;
1504 36 : bool ExportSymbols = Record[0] & 2;
1505 72 : MetadataList.assignValue(
1506 36 : GET_OR_DISTINCT(DINamespace,
1507 : (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1508 : NextMetadataNo);
1509 36 : NextMetadataNo++;
1510 36 : break;
1511 : }
1512 13 : case bitc::METADATA_MACRO: {
1513 13 : if (Record.size() != 5)
1514 0 : return error("Invalid record");
1515 :
1516 13 : IsDistinct = Record[0];
1517 26 : MetadataList.assignValue(
1518 13 : GET_OR_DISTINCT(DIMacro,
1519 : (Context, Record[1], Record[2], getMDString(Record[3]),
1520 : getMDString(Record[4]))),
1521 : NextMetadataNo);
1522 13 : NextMetadataNo++;
1523 13 : break;
1524 : }
1525 19 : case bitc::METADATA_MACRO_FILE: {
1526 19 : if (Record.size() != 5)
1527 0 : return error("Invalid record");
1528 :
1529 19 : IsDistinct = Record[0];
1530 38 : MetadataList.assignValue(
1531 19 : GET_OR_DISTINCT(DIMacroFile,
1532 : (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1533 : getMDOrNull(Record[4]))),
1534 : NextMetadataNo);
1535 19 : NextMetadataNo++;
1536 19 : break;
1537 : }
1538 30 : case bitc::METADATA_TEMPLATE_TYPE: {
1539 30 : if (Record.size() != 3)
1540 0 : return error("Invalid record");
1541 :
1542 30 : IsDistinct = Record[0];
1543 30 : MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
1544 : (Context, getMDString(Record[1]),
1545 : getDITypeRefOrNull(Record[2]))),
1546 : NextMetadataNo);
1547 30 : NextMetadataNo++;
1548 30 : break;
1549 : }
1550 34 : case bitc::METADATA_TEMPLATE_VALUE: {
1551 34 : if (Record.size() != 5)
1552 0 : return error("Invalid record");
1553 :
1554 34 : IsDistinct = Record[0];
1555 68 : MetadataList.assignValue(
1556 34 : GET_OR_DISTINCT(DITemplateValueParameter,
1557 : (Context, Record[1], getMDString(Record[2]),
1558 : getDITypeRefOrNull(Record[3]),
1559 : getMDOrNull(Record[4]))),
1560 : NextMetadataNo);
1561 34 : NextMetadataNo++;
1562 34 : break;
1563 : }
1564 70 : case bitc::METADATA_GLOBAL_VAR: {
1565 140 : if (Record.size() < 11 || Record.size() > 13)
1566 0 : return error("Invalid record");
1567 :
1568 70 : IsDistinct = Record[0] & 1;
1569 70 : unsigned Version = Record[0] >> 1;
1570 :
1571 70 : if (Version == 2) {
1572 104 : MetadataList.assignValue(
1573 52 : GET_OR_DISTINCT(
1574 : DIGlobalVariable,
1575 : (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1576 : getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1577 : getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1578 : getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])),
1579 : NextMetadataNo);
1580 :
1581 52 : NextMetadataNo++;
1582 18 : } else if (Version == 1) {
1583 : // No upgrade necessary. A null field will be introduced to indicate
1584 : // that no parameter information is available.
1585 4 : MetadataList.assignValue(
1586 2 : GET_OR_DISTINCT(DIGlobalVariable,
1587 : (Context, getMDOrNull(Record[1]),
1588 : getMDString(Record[2]), getMDString(Record[3]),
1589 : getMDOrNull(Record[4]), Record[5],
1590 : getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1591 : getMDOrNull(Record[10]), nullptr, Record[11])),
1592 : NextMetadataNo);
1593 :
1594 2 : NextMetadataNo++;
1595 16 : } else if (Version == 0) {
1596 : // Upgrade old metadata, which stored a global variable reference or a
1597 : // ConstantInt here.
1598 16 : NeedUpgradeToDIGlobalVariableExpression = true;
1599 16 : Metadata *Expr = getMDOrNull(Record[9]);
1600 : uint32_t AlignInBits = 0;
1601 16 : if (Record.size() > 11) {
1602 7 : if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1603 0 : return error("Alignment value is too large");
1604 7 : AlignInBits = Record[11];
1605 : }
1606 : GlobalVariable *Attach = nullptr;
1607 : if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1608 : if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1609 : Attach = GV;
1610 : Expr = nullptr;
1611 : } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1612 2 : Expr = DIExpression::get(Context,
1613 : {dwarf::DW_OP_constu, CI->getZExtValue(),
1614 : dwarf::DW_OP_stack_value});
1615 : } else {
1616 : Expr = nullptr;
1617 : }
1618 : }
1619 16 : DIGlobalVariable *DGV = GET_OR_DISTINCT(
1620 : DIGlobalVariable,
1621 : (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1622 : getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1623 : getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1624 : getMDOrNull(Record[10]), nullptr, AlignInBits));
1625 :
1626 : DIGlobalVariableExpression *DGVE = nullptr;
1627 16 : if (Attach || Expr)
1628 20 : DGVE = DIGlobalVariableExpression::getDistinct(
1629 7 : Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
1630 16 : if (Attach)
1631 7 : Attach->addDebugInfo(DGVE);
1632 :
1633 16 : auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1634 16 : MetadataList.assignValue(MDNode, NextMetadataNo);
1635 16 : NextMetadataNo++;
1636 : } else
1637 0 : return error("Invalid record");
1638 :
1639 : break;
1640 : }
1641 137 : case bitc::METADATA_LOCAL_VAR: {
1642 : // 10th field is for the obseleted 'inlinedAt:' field.
1643 274 : if (Record.size() < 8 || Record.size() > 10)
1644 0 : return error("Invalid record");
1645 :
1646 137 : IsDistinct = Record[0] & 1;
1647 137 : bool HasAlignment = Record[0] & 2;
1648 : // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
1649 : // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
1650 : // this is newer version of record which doesn't have artificial tag.
1651 137 : bool HasTag = !HasAlignment && Record.size() > 8;
1652 137 : DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1653 : uint32_t AlignInBits = 0;
1654 137 : if (HasAlignment) {
1655 230 : if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1656 0 : return error("Alignment value is too large");
1657 115 : AlignInBits = Record[8 + HasTag];
1658 : }
1659 274 : MetadataList.assignValue(
1660 411 : GET_OR_DISTINCT(DILocalVariable,
1661 : (Context, getMDOrNull(Record[1 + HasTag]),
1662 : getMDString(Record[2 + HasTag]),
1663 : getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1664 : getDITypeRefOrNull(Record[5 + HasTag]),
1665 : Record[6 + HasTag], Flags, AlignInBits)),
1666 : NextMetadataNo);
1667 137 : NextMetadataNo++;
1668 137 : break;
1669 : }
1670 12 : case bitc::METADATA_LABEL: {
1671 12 : if (Record.size() != 5)
1672 0 : return error("Invalid record");
1673 :
1674 12 : IsDistinct = Record[0] & 1;
1675 24 : MetadataList.assignValue(
1676 12 : GET_OR_DISTINCT(DILabel,
1677 : (Context, getMDOrNull(Record[1]),
1678 : getMDString(Record[2]),
1679 : getMDOrNull(Record[3]), Record[4])),
1680 : NextMetadataNo);
1681 12 : NextMetadataNo++;
1682 12 : break;
1683 : }
1684 110 : case bitc::METADATA_EXPRESSION: {
1685 220 : if (Record.size() < 1)
1686 0 : return error("Invalid record");
1687 :
1688 110 : IsDistinct = Record[0] & 1;
1689 110 : uint64_t Version = Record[0] >> 1;
1690 110 : auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1691 :
1692 : SmallVector<uint64_t, 6> Buffer;
1693 220 : if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
1694 : return Err;
1695 :
1696 220 : MetadataList.assignValue(
1697 110 : GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
1698 110 : NextMetadataNo++;
1699 : break;
1700 : }
1701 35 : case bitc::METADATA_GLOBAL_VAR_EXPR: {
1702 35 : if (Record.size() != 3)
1703 0 : return error("Invalid record");
1704 :
1705 35 : IsDistinct = Record[0];
1706 35 : Metadata *Expr = getMDOrNull(Record[2]);
1707 35 : if (!Expr)
1708 0 : Expr = DIExpression::get(Context, {});
1709 70 : MetadataList.assignValue(
1710 35 : GET_OR_DISTINCT(DIGlobalVariableExpression,
1711 : (Context, getMDOrNull(Record[1]), Expr)),
1712 : NextMetadataNo);
1713 35 : NextMetadataNo++;
1714 35 : break;
1715 : }
1716 18 : case bitc::METADATA_OBJC_PROPERTY: {
1717 18 : if (Record.size() != 8)
1718 0 : return error("Invalid record");
1719 :
1720 18 : IsDistinct = Record[0];
1721 36 : MetadataList.assignValue(
1722 18 : GET_OR_DISTINCT(DIObjCProperty,
1723 : (Context, getMDString(Record[1]),
1724 : getMDOrNull(Record[2]), Record[3],
1725 : getMDString(Record[4]), getMDString(Record[5]),
1726 : Record[6], getDITypeRefOrNull(Record[7]))),
1727 : NextMetadataNo);
1728 18 : NextMetadataNo++;
1729 18 : break;
1730 : }
1731 31 : case bitc::METADATA_IMPORTED_ENTITY: {
1732 62 : if (Record.size() != 6 && Record.size() != 7)
1733 0 : return error("Invalid record");
1734 :
1735 31 : IsDistinct = Record[0];
1736 : bool HasFile = (Record.size() == 7);
1737 62 : MetadataList.assignValue(
1738 31 : GET_OR_DISTINCT(DIImportedEntity,
1739 : (Context, Record[1], getMDOrNull(Record[2]),
1740 : getDITypeRefOrNull(Record[3]),
1741 : HasFile ? getMDOrNull(Record[6]) : nullptr,
1742 : HasFile ? Record[4] : 0, getMDString(Record[5]))),
1743 : NextMetadataNo);
1744 31 : NextMetadataNo++;
1745 31 : break;
1746 : }
1747 : case bitc::METADATA_STRING_OLD: {
1748 : std::string String(Record.begin(), Record.end());
1749 :
1750 : // Test for upgrading !llvm.loop.
1751 328 : HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
1752 : ++NumMDStringLoaded;
1753 328 : Metadata *MD = MDString::get(Context, String);
1754 328 : MetadataList.assignValue(MD, NextMetadataNo);
1755 328 : NextMetadataNo++;
1756 : break;
1757 : }
1758 1350 : case bitc::METADATA_STRINGS: {
1759 : auto CreateNextMDString = [&](StringRef Str) {
1760 : ++NumMDStringLoaded;
1761 : MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
1762 : NextMetadataNo++;
1763 1350 : };
1764 1350 : if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
1765 : return Err;
1766 1350 : break;
1767 : }
1768 90 : case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
1769 180 : if (Record.size() % 2 == 0)
1770 0 : return error("Invalid record");
1771 90 : unsigned ValueID = Record[0];
1772 180 : if (ValueID >= ValueList.size())
1773 0 : return error("Invalid record");
1774 : if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1775 90 : if (Error Err = parseGlobalObjectAttachment(
1776 90 : *GO, ArrayRef<uint64_t>(Record).slice(1)))
1777 : return Err;
1778 : break;
1779 : }
1780 817 : case bitc::METADATA_KIND: {
1781 : // Support older bitcode files that had METADATA_KIND records in a
1782 : // block with METADATA_BLOCK_ID.
1783 1634 : if (Error Err = parseMetadataKindRecord(Record))
1784 : return Err;
1785 : break;
1786 : }
1787 : }
1788 : return Error::success();
1789 : #undef GET_OR_DISTINCT
1790 : }
1791 :
1792 1365 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
1793 : ArrayRef<uint64_t> Record, StringRef Blob,
1794 : function_ref<void(StringRef)> CallBack) {
1795 : // All the MDStrings in the block are emitted together in a single
1796 : // record. The strings are concatenated and stored in a blob along with
1797 : // their sizes.
1798 1365 : if (Record.size() != 2)
1799 0 : return error("Invalid record: metadata strings layout");
1800 :
1801 1365 : unsigned NumStrings = Record[0];
1802 1365 : unsigned StringsOffset = Record[1];
1803 1365 : if (!NumStrings)
1804 0 : return error("Invalid record: metadata strings with no strings");
1805 1365 : if (StringsOffset > Blob.size())
1806 0 : return error("Invalid record: metadata strings corrupt offset");
1807 :
1808 1365 : StringRef Lengths = Blob.slice(0, StringsOffset);
1809 : SimpleBitstreamCursor R(Lengths);
1810 :
1811 1365 : StringRef Strings = Blob.drop_front(StringsOffset);
1812 : do {
1813 : if (R.AtEndOfStream())
1814 0 : return error("Invalid record: metadata strings bad length");
1815 :
1816 6712 : unsigned Size = R.ReadVBR(6);
1817 6712 : if (Strings.size() < Size)
1818 0 : return error("Invalid record: metadata strings truncated chars");
1819 :
1820 6712 : CallBack(Strings.slice(0, Size));
1821 6712 : Strings = Strings.drop_front(Size);
1822 6712 : } while (--NumStrings);
1823 :
1824 : return Error::success();
1825 : }
1826 :
1827 342 : Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1828 : GlobalObject &GO, ArrayRef<uint64_t> Record) {
1829 : assert(Record.size() % 2 == 0);
1830 747 : for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
1831 810 : auto K = MDKindMap.find(Record[I]);
1832 405 : if (K == MDKindMap.end())
1833 0 : return error("Invalid ID");
1834 810 : MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1835 : if (!MD)
1836 0 : return error("Invalid metadata attachment");
1837 405 : GO.addMetadata(K->second, *MD);
1838 : }
1839 : return Error::success();
1840 : }
1841 :
1842 : /// Parse metadata attachments.
1843 1497 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
1844 : Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1845 1497 : if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
1846 0 : return error("Invalid record");
1847 :
1848 : SmallVector<uint64_t, 64> Record;
1849 : PlaceholderQueue Placeholders;
1850 :
1851 : while (true) {
1852 8243 : BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1853 :
1854 8243 : switch (Entry.Kind) {
1855 : case BitstreamEntry::SubBlock: // Handled for us already.
1856 : case BitstreamEntry::Error:
1857 0 : return error("Malformed block");
1858 1497 : case BitstreamEntry::EndBlock:
1859 1497 : resolveForwardRefsAndPlaceholders(Placeholders);
1860 : return Error::success();
1861 : case BitstreamEntry::Record:
1862 : // The interesting case.
1863 : break;
1864 : }
1865 :
1866 : // Read a metadata attachment record.
1867 : Record.clear();
1868 : ++NumMDRecordLoaded;
1869 6746 : switch (Stream.readRecord(Entry.ID, Record)) {
1870 : default: // Default behavior: ignore.
1871 : break;
1872 6746 : case bitc::METADATA_ATTACHMENT: {
1873 6746 : unsigned RecordLength = Record.size();
1874 6746 : if (Record.empty())
1875 0 : return error("Invalid record");
1876 6746 : if (RecordLength % 2 == 0) {
1877 : // A function attachment.
1878 252 : if (Error Err = parseGlobalObjectAttachment(F, Record))
1879 : return Err;
1880 252 : continue;
1881 : }
1882 :
1883 : // An instruction attachment.
1884 12988 : Instruction *Inst = InstructionList[Record[0]];
1885 13100 : for (unsigned i = 1; i != RecordLength; i = i + 2) {
1886 6607 : unsigned Kind = Record[i];
1887 6607 : DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
1888 6607 : if (I == MDKindMap.end())
1889 0 : return error("Invalid ID");
1890 6607 : if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1891 11 : continue;
1892 :
1893 6596 : auto Idx = Record[i + 1];
1894 19790 : if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
1895 2 : !MetadataList.lookup(Idx)) {
1896 : // Load the attachment if it is in the lazy-loadable range and hasn't
1897 : // been loaded yet.
1898 1 : lazyLoadOneMetadata(Idx, Placeholders);
1899 1 : resolveForwardRefsAndPlaceholders(Placeholders);
1900 : }
1901 :
1902 6596 : Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
1903 6596 : if (isa<LocalAsMetadata>(Node))
1904 : // Drop the attachment. This used to be legal, but there's no
1905 : // upgrade path.
1906 : break;
1907 : MDNode *MD = dyn_cast_or_null<MDNode>(Node);
1908 : if (!MD)
1909 0 : return error("Invalid metadata attachment");
1910 :
1911 6595 : if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1912 2 : MD = upgradeInstructionLoopAttachment(*MD);
1913 :
1914 6595 : if (I->second == LLVMContext::MD_tbaa) {
1915 : assert(!MD->isTemporary() && "should load MDs before attachments");
1916 404 : MD = UpgradeTBAANode(*MD);
1917 : }
1918 6595 : Inst->setMetadata(I->second, MD);
1919 : }
1920 : break;
1921 : }
1922 : }
1923 : }
1924 : }
1925 :
1926 : /// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1927 84057 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1928 : SmallVectorImpl<uint64_t> &Record) {
1929 168114 : if (Record.size() < 2)
1930 0 : return error("Invalid record");
1931 :
1932 84057 : unsigned Kind = Record[0];
1933 84057 : SmallString<8> Name(Record.begin() + 1, Record.end());
1934 :
1935 168114 : unsigned NewKind = TheModule.getMDKindID(Name.str());
1936 84057 : if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1937 0 : return error("Conflicting METADATA_KIND records");
1938 : return Error::success();
1939 : }
1940 :
1941 : /// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1942 3328 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
1943 3328 : if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
1944 0 : return error("Invalid record");
1945 :
1946 : SmallVector<uint64_t, 64> Record;
1947 :
1948 : // Read all the records.
1949 : while (true) {
1950 86568 : BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1951 :
1952 86568 : switch (Entry.Kind) {
1953 : case BitstreamEntry::SubBlock: // Handled for us already.
1954 : case BitstreamEntry::Error:
1955 0 : return error("Malformed block");
1956 : case BitstreamEntry::EndBlock:
1957 : return Error::success();
1958 : case BitstreamEntry::Record:
1959 : // The interesting case.
1960 : break;
1961 : }
1962 :
1963 : // Read a record.
1964 : Record.clear();
1965 : ++NumMDRecordLoaded;
1966 83240 : unsigned Code = Stream.readRecord(Entry.ID, Record);
1967 83240 : switch (Code) {
1968 : default: // Default behavior: ignore.
1969 : break;
1970 83240 : case bitc::METADATA_KIND: {
1971 166480 : if (Error Err = parseMetadataKindRecord(Record))
1972 : return Err;
1973 : break;
1974 : }
1975 : }
1976 83240 : }
1977 : }
1978 :
1979 0 : MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
1980 0 : Pimpl = std::move(RHS.Pimpl);
1981 0 : return *this;
1982 : }
1983 3479 : MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
1984 3479 : : Pimpl(std::move(RHS.Pimpl)) {}
1985 :
1986 : MetadataLoader::~MetadataLoader() = default;
1987 3479 : MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
1988 : BitcodeReaderValueList &ValueList,
1989 : bool IsImporting,
1990 3479 : std::function<Type *(unsigned)> getTypeByID)
1991 : : Pimpl(llvm::make_unique<MetadataLoaderImpl>(
1992 3479 : Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
1993 :
1994 2571 : Error MetadataLoader::parseMetadata(bool ModuleLevel) {
1995 2571 : return Pimpl->parseMetadata(ModuleLevel);
1996 : }
1997 :
1998 52716 : bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
1999 :
2000 : /// Return the given metadata, creating a replaceable forward reference if
2001 : /// necessary.
2002 9820 : Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
2003 9820 : return Pimpl->getMetadataFwdRefOrLoad(Idx);
2004 : }
2005 :
2006 8254 : MDNode *MetadataLoader::getMDNodeFwdRefOrNull(unsigned Idx) {
2007 8254 : return Pimpl->getMDNodeFwdRefOrNull(Idx);
2008 : }
2009 :
2010 13164 : DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
2011 13164 : return Pimpl->lookupSubprogramForFunction(F);
2012 : }
2013 :
2014 1497 : Error MetadataLoader::parseMetadataAttachment(
2015 : Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2016 1497 : return Pimpl->parseMetadataAttachment(F, InstructionList);
2017 : }
2018 :
2019 3328 : Error MetadataLoader::parseMetadataKinds() {
2020 3328 : return Pimpl->parseMetadataKinds();
2021 : }
2022 :
2023 2 : void MetadataLoader::setStripTBAA(bool StripTBAA) {
2024 2 : return Pimpl->setStripTBAA(StripTBAA);
2025 : }
2026 :
2027 26328 : bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2028 :
2029 26388 : unsigned MetadataLoader::size() const { return Pimpl->size(); }
2030 13164 : void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2031 :
2032 57839 : void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
2033 57839 : return Pimpl->upgradeDebugIntrinsics(F);
2034 : }
|
