Bug Summary

File:include/llvm/Bitcode/BitstreamReader.h
Warning:line 210, column 39
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

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

/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp

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
86using namespace llvm;
87
88#define DEBUG_TYPE"bitcode-reader" "bitcode-reader"
89
90STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded")static llvm::Statistic NumMDStringLoaded = {"bitcode-reader",
"NumMDStringLoaded", "Number of MDStrings loaded", {0}, {false
}}
;
91STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created")static llvm::Statistic NumMDNodeTemporary = {"bitcode-reader"
, "NumMDNodeTemporary", "Number of MDNode::Temporary created"
, {0}, {false}}
;
92STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded")static llvm::Statistic NumMDRecordLoaded = {"bitcode-reader",
"NumMDRecordLoaded", "Number of Metadata records loaded", {0
}, {false}}
;
93
94/// Flag whether we need to import full type definitions for ThinLTO.
95/// Currently needed for Darwin and LLDB.
96static cl::opt<bool> ImportFullTypeDefinitions(
97 "import-full-type-definitions", cl::init(false), cl::Hidden,
98 cl::desc("Import full type definitions for ThinLTO."));
99
100static 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
105namespace {
106
107static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
108
109class 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
134public:
135 BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {}
136
137 // vector compatibility methods
138 unsigned size() const { return MetadataPtrs.size(); }
139 void resize(unsigned N) { MetadataPtrs.resize(N); }
140 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 bool empty() const { return MetadataPtrs.empty(); }
145
146 Metadata *operator[](unsigned i) const {
147 assert(i < MetadataPtrs.size())((i < MetadataPtrs.size()) ? static_cast<void> (0) :
__assert_fail ("i < MetadataPtrs.size()", "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 147, __PRETTY_FUNCTION__))
;
148 return MetadataPtrs[i];
149 }
150
151 Metadata *lookup(unsigned I) const {
152 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!")((N <= size() && "Invalid shrinkTo request!") ? static_cast
<void> (0) : __assert_fail ("N <= size() && \"Invalid shrinkTo request!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 158, __PRETTY_FUNCTION__))
;
159 assert(ForwardReference.empty() && "Unexpected forward refs")((ForwardReference.empty() && "Unexpected forward refs"
) ? static_cast<void> (0) : __assert_fail ("ForwardReference.empty() && \"Unexpected forward refs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 159, __PRETTY_FUNCTION__))
;
160 assert(UnresolvedNodes.empty() && "Unexpected unresolved node")((UnresolvedNodes.empty() && "Unexpected unresolved node"
) ? static_cast<void> (0) : __assert_fail ("UnresolvedNodes.empty() && \"Unexpected unresolved node\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 160, __PRETTY_FUNCTION__))
;
161 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 bool hasFwdRefs() const { return !ForwardReference.empty(); }
178 int getNextFwdRef() {
179 assert(hasFwdRefs())((hasFwdRefs()) ? static_cast<void> (0) : __assert_fail
("hasFwdRefs()", "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 179, __PRETTY_FUNCTION__))
;
180 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
192private:
193 Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
194};
195
196void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
197 if (auto *MDN = dyn_cast<MDNode>(MD))
198 if (!MDN->isResolved())
199 UnresolvedNodes.insert(Idx);
200
201 if (Idx == size()) {
202 push_back(MD);
203 return;
204 }
205
206 if (Idx >= size())
207 resize(Idx + 1);
208
209 TrackingMDRef &OldMD = MetadataPtrs[Idx];
210 if (!OldMD) {
211 OldMD.reset(MD);
212 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
221Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
222 if (Idx >= size())
223 resize(Idx + 1);
224
225 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 Metadata *MD = MDNode::getTemporary(Context, None).release();
234 MetadataPtrs[Idx].reset(MD);
235 return MD;
236}
237
238Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
239 Metadata *MD = lookup(Idx);
240 if (auto *N = dyn_cast_or_null<MDNode>(MD))
241 if (!N->isResolved())
242 return nullptr;
243 return MD;
244}
245
246MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
247 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
248}
249
250void BitcodeReaderMetadataList::tryToResolveCycles() {
251 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 for (const auto &Ref : OldTypeRefs.FwdDecls)
257 OldTypeRefs.Final.insert(Ref);
258 OldTypeRefs.FwdDecls.clear();
259
260 // Upgrade from old type ref arrays. In strange cases, this could add to
261 // OldTypeRefs.Unknown.
262 for (const auto &Array : OldTypeRefs.Arrays)
263 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 for (const auto &Ref : OldTypeRefs.Unknown) {
270 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
271 Ref.second->replaceAllUsesWith(CT);
272 else
273 Ref.second->replaceAllUsesWith(Ref.first);
274 }
275 OldTypeRefs.Unknown.clear();
276
277 if (UnresolvedNodes.empty())
278 // Nothing to do.
279 return;
280
281 // Resolve any cycles.
282 for (unsigned I : UnresolvedNodes) {
283 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")((!N->isTemporary() && "Unexpected forward reference"
) ? static_cast<void> (0) : __assert_fail ("!N->isTemporary() && \"Unexpected forward reference\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 288, __PRETTY_FUNCTION__))
;
289 N->resolveCycles();
290 }
291
292 // Make sure we return early again until there's another unresolved ref.
293 UnresolvedNodes.clear();
294}
295
296void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
297 DICompositeType &CT) {
298 assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID")((CT.getRawIdentifier() == &UUID && "Mismatched UUID"
) ? static_cast<void> (0) : __assert_fail ("CT.getRawIdentifier() == &UUID && \"Mismatched UUID\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 298, __PRETTY_FUNCTION__))
;
299 if (CT.isForwardDecl())
300 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
301 else
302 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
303}
304
305Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
306 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
307 if (LLVM_LIKELY(!UUID)__builtin_expect((bool)(!UUID), true))
308 return MaybeUUID;
309
310 if (auto *CT = OldTypeRefs.Final.lookup(UUID))
311 return CT;
312
313 auto &Ref = OldTypeRefs.Unknown[UUID];
314 if (!Ref)
315 Ref = MDNode::getTemporary(Context, None);
316 return Ref.get();
317}
318
319Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
320 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
321 if (!Tuple || Tuple->isDistinct())
322 return MaybeTuple;
323
324 // Look through the array immediately if possible.
325 if (!Tuple->isTemporary())
326 return resolveTypeRefArray(Tuple);
327
328 // Create and return a placeholder to use for now. Eventually
329 // resolveTypeRefArrays() will be resolve this forward reference.
330 OldTypeRefs.Arrays.emplace_back(
331 std::piecewise_construct, std::forward_as_tuple(Tuple),
332 std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
333 return OldTypeRefs.Arrays.back().second.get();
334}
335
336Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
337 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
338 if (!Tuple || Tuple->isDistinct())
339 return MaybeTuple;
340
341 // Look through the DITypeRefArray, upgrading each DITypeRef.
342 SmallVector<Metadata *, 32> Ops;
343 Ops.reserve(Tuple->getNumOperands());
344 for (Metadata *MD : Tuple->operands())
345 Ops.push_back(upgradeTypeRef(MD));
346
347 return MDTuple::get(Context, Ops);
348}
349
350namespace {
351
352class 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
357public:
358 ~PlaceholderQueue() {
359 assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed")((empty() && "PlaceholderQueue hasn't been flushed before being destroyed"
) ? static_cast<void> (0) : __assert_fail ("empty() && \"PlaceholderQueue hasn't been flushed before being destroyed\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 359, __PRETTY_FUNCTION__))
;
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 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
368 DenseSet<unsigned> &Temporaries) {
369 for (auto &PH : PHs) {
370 auto ID = PH.getID();
371 auto *MD = MetadataList.lookup(ID);
372 if (!MD) {
373 Temporaries.insert(ID);
374 continue;
375 }
376 auto *N = dyn_cast_or_null<MDNode>(MD);
377 if (N && N->isTemporary())
378 Temporaries.insert(ID);
379 }
380 }
381};
382
383} // end anonymous namespace
384
385DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
386 PHs.emplace_back(ID);
387 return PHs.back();
388}
389
390void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
391 while (!PHs.empty()) {
392 auto *MD = MetadataList.lookup(PHs.front().getID());
393 assert(MD && "Flushing placeholder on unassigned MD")((MD && "Flushing placeholder on unassigned MD") ? static_cast
<void> (0) : __assert_fail ("MD && \"Flushing placeholder on unassigned MD\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 393, __PRETTY_FUNCTION__))
;
394#ifndef NDEBUG
395 if (auto *MDN = dyn_cast<MDNode>(MD))
396 assert(MDN->isResolved() &&((MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? static_cast<void> (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 397, __PRETTY_FUNCTION__))
397 "Flushing Placeholder while cycles aren't resolved")((MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? static_cast<void> (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 397, __PRETTY_FUNCTION__))
;
398#endif
399 PHs.front().replaceUseWith(MD);
400 PHs.pop_front();
401 }
402}
403
404} // anonynous namespace
405
406static Error error(const Twine &Message) {
407 return make_error<StringError>(
408 Message, make_error_code(BitcodeError::CorruptedBitcode));
409}
410
411class 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 void upgradeCUSubprograms() {
475 for (auto CU_SP : CUSubprograms)
476 if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
477 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 }
482
483 /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
484 void upgradeCUVariables() {
485 if (!NeedUpgradeToDIGlobalVariableExpression)
486 return;
487
488 // Upgrade list of variables attached to the CUs.
489 if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
490 for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
491 auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
492 if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
493 for (unsigned I = 0; I < GVs->getNumOperands(); I++)
494 if (auto *GV =
495 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
496 auto *DGVE = DIGlobalVariableExpression::getDistinct(
497 Context, GV, DIExpression::get(Context, {}));
498 GVs->replaceOperandWith(I, DGVE);
499 }
500 }
501
502 // Upgrade variables attached to globals.
503 for (auto &GV : TheModule.globals()) {
504 SmallVector<MDNode *, 1> MDs;
505 GV.getMetadata(LLVMContext::MD_dbg, MDs);
506 GV.eraseMetadata(LLVMContext::MD_dbg);
507 for (auto *MD : MDs)
508 if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) {
509 auto *DGVE = DIGlobalVariableExpression::getDistinct(
510 Context, DGV, DIExpression::get(Context, {}));
511 GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
512 } else
513 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 void upgradeDeclareExpressions(Function &F) {
520 if (!NeedDeclareExpressionUpgrade)
521 return;
522
523 for (auto &BB : F)
524 for (auto &I : BB)
525 if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
526 if (auto *DIExpr = DDI->getExpression())
527 if (DIExpr->startsWithDeref() &&
528 dyn_cast_or_null<Argument>(DDI->getAddress())) {
529 SmallVector<uint64_t, 8> Ops;
530 Ops.append(std::next(DIExpr->elements_begin()),
531 DIExpr->elements_end());
532 auto *E = DIExpression::get(Context, Ops);
533 DDI->setOperand(2, MetadataAsValue::get(Context, E));
534 }
535 }
536
537 /// Upgrade the expression from previous versions.
538 Error upgradeDIExpression(uint64_t FromVersion,
539 MutableArrayRef<uint64_t> &Expr,
540 SmallVectorImpl<uint64_t> &Buffer) {
541 auto N = Expr.size();
542 switch (FromVersion) {
543 default:
544 return error("Invalid record");
545 case 0:
546 if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
547 Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
548 LLVM_FALLTHROUGH[[clang::fallthrough]];
549 case 1:
550 // Move DW_OP_deref to the end.
551 if (N && Expr[0] == dwarf::DW_OP_deref) {
552 auto End = Expr.end();
553 if (Expr.size() >= 3 &&
554 *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 *std::prev(End) = dwarf::DW_OP_deref;
558 }
559 NeedDeclareExpressionUpgrade = true;
560 LLVM_FALLTHROUGH[[clang::fallthrough]];
561 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 auto SubExpr = ArrayRef<uint64_t>(Expr);
565 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 switch (SubExpr.front()) {
571 default:
572 HistoricSize = 1;
573 break;
574 case dwarf::DW_OP_constu:
575 case dwarf::DW_OP_minus:
576 case dwarf::DW_OP_plus:
577 HistoricSize = 2;
578 break;
579 case dwarf::DW_OP_LLVM_fragment:
580 HistoricSize = 3;
581 break;
582 }
583
584 // If the expression is malformed, make sure we don't
585 // copy more elements than we should.
586 HistoricSize = std::min(SubExpr.size(), HistoricSize);
587 ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1);
588
589 switch (SubExpr.front()) {
590 case dwarf::DW_OP_plus:
591 Buffer.push_back(dwarf::DW_OP_plus_uconst);
592 Buffer.append(Args.begin(), Args.end());
593 break;
594 case dwarf::DW_OP_minus:
595 Buffer.push_back(dwarf::DW_OP_constu);
596 Buffer.append(Args.begin(), Args.end());
597 Buffer.push_back(dwarf::DW_OP_minus);
598 break;
599 default:
600 Buffer.push_back(*SubExpr.begin());
601 Buffer.append(Args.begin(), Args.end());
602 break;
603 }
604
605 // Continue with remaining elements.
606 SubExpr = SubExpr.slice(HistoricSize);
607 }
608 Expr = MutableArrayRef<uint64_t>(Buffer);
609 LLVM_FALLTHROUGH[[clang::fallthrough]];
610 }
611 case 3:
612 // Up-to-date!
613 break;
614 }
615
616 return Error::success();
617 }
618
619 void upgradeDebugInfo() {
620 upgradeCUSubprograms();
621 upgradeCUVariables();
622 }
623
624public:
625 MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
626 BitcodeReaderValueList &ValueList,
627 std::function<Type *(unsigned)> getTypeByID,
628 bool IsImporting)
629 : MetadataList(TheModule.getContext()), ValueList(ValueList),
630 Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule),
631 getTypeByID(std::move(getTypeByID)), IsImporting(IsImporting) {}
632
633 Error parseMetadata(bool ModuleLevel);
634
635 bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
636
637 Metadata *getMetadataFwdRefOrLoad(unsigned ID) {
638 if (ID < MDStringRef.size())
639 return lazyLoadOneMDString(ID);
640 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 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
645 PlaceholderQueue Placeholders;
646 lazyLoadOneMetadata(ID, Placeholders);
647 resolveForwardRefsAndPlaceholders(Placeholders);
648 return MetadataList.lookup(ID);
649 }
650 return MetadataList.getMetadataFwdRef(ID);
651 }
652
653 MDNode *getMDNodeFwdRefOrNull(unsigned Idx) {
654 return MetadataList.getMDNodeFwdRefOrNull(Idx);
655 }
656
657 DISubprogram *lookupSubprogramForFunction(Function *F) {
658 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 void setStripTBAA(bool Value) { StripTBAA = Value; }
669 bool isStrippingTBAA() { return StripTBAA; }
670
671 unsigned size() const { return MetadataList.size(); }
672 void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
673 void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
674};
675
676Expected<bool>
677MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
678 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 BitstreamCursor::AF_DontPopBlockAtEnd);
684 switch (Entry.Kind) {
685 case BitstreamEntry::SubBlock: // Handled for us already.
686 case BitstreamEntry::Error:
687 return error("Malformed block");
688 case BitstreamEntry::EndBlock: {
689 return true;
690 }
691 case BitstreamEntry::Record: {
692 // The interesting case.
693 ++NumMDRecordLoaded;
694 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
695 auto Code = IndexCursor.skipRecord(Entry.ID);
696 switch (Code) {
697 case bitc::METADATA_STRINGS: {
698 // Rewind and parse the strings.
699 IndexCursor.JumpToBit(CurrentPos);
700 StringRef Blob;
701 Record.clear();
702 IndexCursor.readRecord(Entry.ID, Record, &Blob);
703 unsigned NumStrings = Record[0];
704 MDStringRef.reserve(NumStrings);
705 auto IndexNextMDString = [&](StringRef Str) {
706 MDStringRef.push_back(Str);
707 };
708 if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
709 return std::move(Err);
710 break;
711 }
712 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 IndexCursor.JumpToBit(CurrentPos);
716 Record.clear();
717 IndexCursor.readRecord(Entry.ID, Record);
718 if (Record.size() != 2)
719 return error("Invalid record");
720 auto Offset = Record[0] + (Record[1] << 32);
721 auto BeginPos = IndexCursor.GetCurrentBitNo();
722 IndexCursor.JumpToBit(BeginPos + Offset);
723 Entry = IndexCursor.advanceSkippingSubblocks(
724 BitstreamCursor::AF_DontPopBlockAtEnd);
725 assert(Entry.Kind == BitstreamEntry::Record &&((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
"Metadata index") ? static_cast<void> (0) : __assert_fail
("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 727, __PRETTY_FUNCTION__))
726 "Corrupted bitcode: Expected `Record` when trying to find the "((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
"Metadata index") ? static_cast<void> (0) : __assert_fail
("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 727, __PRETTY_FUNCTION__))
727 "Metadata index")((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
"Metadata index") ? static_cast<void> (0) : __assert_fail
("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 727, __PRETTY_FUNCTION__))
;
728 Record.clear();
729 auto Code = IndexCursor.readRecord(Entry.ID, Record);
730 (void)Code;
731 assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
"`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 733, __PRETTY_FUNCTION__))
732 "`METADATA_INDEX` when trying "((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
"`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 733, __PRETTY_FUNCTION__))
733 "to find the Metadata index")((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
"`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 733, __PRETTY_FUNCTION__))
;
734
735 // Delta unpack
736 auto CurrentValue = BeginPos;
737 GlobalMetadataBitPosIndex.reserve(Record.size());
738 for (auto &Elt : Record) {
739 CurrentValue += Elt;
740 GlobalMetadataBitPosIndex.push_back(CurrentValue);
741 }
742 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 return error("Corrupted Metadata block");
748 case bitc::METADATA_NAME: {
749 // Named metadata need to be materialized now and aren't deferred.
750 IndexCursor.JumpToBit(CurrentPos);
751 Record.clear();
752 unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
753 assert(Code == bitc::METADATA_NAME)((Code == bitc::METADATA_NAME) ? static_cast<void> (0) :
__assert_fail ("Code == bitc::METADATA_NAME", "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 753, __PRETTY_FUNCTION__))
;
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 unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
763 assert(NextBitCode == bitc::METADATA_NAMED_NODE)((NextBitCode == bitc::METADATA_NAMED_NODE) ? static_cast<
void> (0) : __assert_fail ("NextBitCode == bitc::METADATA_NAMED_NODE"
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 763, __PRETTY_FUNCTION__))
;
764 (void)NextBitCode;
765
766 // Read named metadata elements.
767 unsigned Size = Record.size();
768 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
769 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 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
775 assert(MD && "Invalid record")((MD && "Invalid record") ? static_cast<void> (
0) : __assert_fail ("MD && \"Invalid record\"", "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 775, __PRETTY_FUNCTION__))
;
776 NMD->addOperand(MD);
777 }
778 break;
779 }
780 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
781 // FIXME: we need to do this early because we don't materialize global
782 // value explicitly.
783 IndexCursor.JumpToBit(CurrentPos);
784 Record.clear();
785 IndexCursor.readRecord(Entry.ID, Record);
786 if (Record.size() % 2 == 0)
787 return error("Invalid record");
788 unsigned ValueID = Record[0];
789 if (ValueID >= ValueList.size())
790 return error("Invalid record");
791 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
792 if (Error Err = parseGlobalObjectAttachment(
793 *GO, ArrayRef<uint64_t>(Record).slice(1)))
794 return std::move(Err);
795 break;
796 }
797 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 }
840}
841
842/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
843/// module level metadata.
844Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
845 if (!ModuleLevel && MetadataList.hasFwdRefs())
846 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 auto EntryPos = Stream.GetCurrentBitNo();
851
852 if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
853 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 if (ModuleLevel && IsImporting && MetadataList.empty() &&
861 !DisableLazyLoading) {
862 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
863 if (!SuccessOrErr)
864 return SuccessOrErr.takeError();
865 if (SuccessOrErr.get()) {
866 // An index was successfully created and we will be able to load metadata
867 // on-demand.
868 MetadataList.resize(MDStringRef.size() +
869 GlobalMetadataBitPosIndex.size());
870
871 // Reading the named metadata created forward references and/or
872 // placeholders, that we flush here.
873 resolveForwardRefsAndPlaceholders(Placeholders);
874 upgradeDebugInfo();
875 // Return at the beginning of the block, since it is easy to skip it
876 // entirely from there.
877 Stream.ReadBlockEnd(); // Pop the abbrev block context.
878 Stream.JumpToBit(EntryPos);
879 if (Stream.SkipBlock())
880 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 unsigned NextMetadataNo = MetadataList.size();
887
888 // Read all the records.
889 while (true) {
890 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
891
892 switch (Entry.Kind) {
893 case BitstreamEntry::SubBlock: // Handled for us already.
894 case BitstreamEntry::Error:
895 return error("Malformed block");
896 case BitstreamEntry::EndBlock:
897 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 StringRef Blob;
908 ++NumMDRecordLoaded;
909 unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
910 if (Error Err =
911 parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
912 return Err;
913 }
914}
915
916MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
917 ++NumMDStringLoaded;
918 if (Metadata *MD = MetadataList.lookup(ID))
919 return cast<MDString>(MD);
920 auto MDS = MDString::get(Context, MDStringRef[ID]);
921 MetadataList.assignValue(MDS, ID);
922 return MDS;
923}
924
925void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
926 unsigned ID, PlaceholderQueue &Placeholders) {
927 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size())((ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size
()) ? static_cast<void> (0) : __assert_fail ("ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 927, __PRETTY_FUNCTION__))
;
928 assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString")((ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString"
) ? static_cast<void> (0) : __assert_fail ("ID >= MDStringRef.size() && \"Unexpected lazy-loading of MDString\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 928, __PRETTY_FUNCTION__))
;
929 // Lookup first if the metadata hasn't already been loaded.
930 if (auto *MD = MetadataList.lookup(ID)) {
931 auto *N = dyn_cast_or_null<MDNode>(MD);
932 if (!N->isTemporary())
933 return;
934 }
935 SmallVector<uint64_t, 64> Record;
936 StringRef Blob;
937 IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
938 auto Entry = IndexCursor.advanceSkippingSubblocks();
939 ++NumMDRecordLoaded;
940 unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob);
941 if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
942 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.
947void 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 Placeholders.getTemporaries(MetadataList, Temporaries);
953
954 // If we don't have any temporary, or FwdReference, we're done!
955 if (Temporaries.empty() && !MetadataList.hasFwdRefs())
956 break;
957
958 // First, load all the temporaries. This can add new placeholders or
959 // forward references.
960 for (auto ID : Temporaries)
961 lazyLoadOneMetadata(ID, Placeholders);
962 Temporaries.clear();
963
964 // Second, load the forward-references. This can also add new placeholders
965 // or forward references.
966 while (MetadataList.hasFwdRefs())
967 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 MetadataList.tryToResolveCycles();
973
974 // Finally, everything is in place, we can replace the placeholders operands
975 // with the final node they refer to.
976 Placeholders.flush(MetadataList);
977}
978
979Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
980 SmallVectorImpl<uint64_t> &Record, unsigned Code,
981 PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
982
983 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 };
1007 auto getMDOrNull = [&](unsigned ID) -> Metadata * {
1008 if (ID)
1009 return getMD(ID - 1);
1010 return nullptr;
1011 };
1012 auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
1013 if (ID)
1014 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 };
1023
1024 // Support for old type refs.
1025 auto getDITypeRefOrNull = [&](unsigned ID) {
1026 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1027 };
1028
1029#define GET_OR_DISTINCT(CLASS, ARGS) \
1030 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1031
1032 switch (Code) {
1033 default: // Default behavior: ignore.
1034 break;
1035 case bitc::METADATA_NAME: {
1036 // Read name of the named metadata.
1037 SmallString<8> Name(Record.begin(), Record.end());
1038 Record.clear();
1039 Code = Stream.ReadCode();
1040
1041 ++NumMDRecordLoaded;
1042 unsigned NextBitCode = Stream.readRecord(Code, Record);
1043 if (NextBitCode != bitc::METADATA_NAMED_NODE)
1044 return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1045
1046 // Read named metadata elements.
1047 unsigned Size = Record.size();
1048 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1049 for (unsigned i = 0; i != Size; ++i) {
1050 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1051 if (!MD)
1052 return error("Invalid record");
1053 NMD->addOperand(MD);
1054 }
1055 break;
1056 }
1057 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 if (Record.size() % 2 == 1)
1062 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 };
1070 if (Record.size() != 2) {
1071 dropRecord();
1072 break;
1073 }
1074
1075 Type *Ty = getTypeByID(Record[0]);
1076 if (Ty->isMetadataTy() || Ty->isVoidTy()) {
1077 dropRecord();
1078 break;
1079 }
1080
1081 MetadataList.assignValue(
1082 LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1083 NextMetadataNo);
1084 NextMetadataNo++;
1085 break;
1086 }
1087 case bitc::METADATA_OLD_NODE: {
1088 // FIXME: Remove in 4.0.
1089 if (Record.size() % 2 == 1)
1090 return error("Invalid record");
1091
1092 unsigned Size = Record.size();
1093 SmallVector<Metadata *, 8> Elts;
1094 for (unsigned i = 0; i != Size; i += 2) {
1095 Type *Ty = getTypeByID(Record[i]);
1096 if (!Ty)
1097 return error("Invalid record");
1098 if (Ty->isMetadataTy())
1099 Elts.push_back(getMD(Record[i + 1]));
1100 else if (!Ty->isVoidTy()) {
1101 auto *MD =
1102 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
1103 assert(isa<ConstantAsMetadata>(MD) &&((isa<ConstantAsMetadata>(MD) && "Expected non-function-local metadata"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1104, __PRETTY_FUNCTION__))
1104 "Expected non-function-local metadata")((isa<ConstantAsMetadata>(MD) && "Expected non-function-local metadata"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1104, __PRETTY_FUNCTION__))
;
1105 Elts.push_back(MD);
1106 } else
1107 Elts.push_back(nullptr);
1108 }
1109 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1110 NextMetadataNo++;
1111 break;
1112 }
1113 case bitc::METADATA_VALUE: {
1114 if (Record.size() != 2)
1115 return error("Invalid record");
1116
1117 Type *Ty = getTypeByID(Record[0]);
1118 if (Ty->isMetadataTy() || Ty->isVoidTy())
1119 return error("Invalid record");
1120
1121 MetadataList.assignValue(
1122 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1123 NextMetadataNo);
1124 NextMetadataNo++;
1125 break;
1126 }
1127 case bitc::METADATA_DISTINCT_NODE:
1128 IsDistinct = true;
1129 LLVM_FALLTHROUGH[[clang::fallthrough]];
1130 case bitc::METADATA_NODE: {
1131 SmallVector<Metadata *, 8> Elts;
1132 Elts.reserve(Record.size());
1133 for (unsigned ID : Record)
1134 Elts.push_back(getMDOrNull(ID));
1135 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1136 : MDNode::get(Context, Elts),
1137 NextMetadataNo);
1138 NextMetadataNo++;
1139 break;
1140 }
1141 case bitc::METADATA_LOCATION: {
1142 if (Record.size() != 5 && Record.size() != 6)
1143 return error("Invalid record");
1144
1145 IsDistinct = Record[0];
1146 unsigned Line = Record[1];
1147 unsigned Column = Record[2];
1148 Metadata *Scope = getMD(Record[3]);
1149 Metadata *InlinedAt = getMDOrNull(Record[4]);
1150 bool ImplicitCode = Record.size() == 6 && Record[5];
1151 MetadataList.assignValue(
1152 GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
1153 ImplicitCode)),
1154 NextMetadataNo);
1155 NextMetadataNo++;
1156 break;
1157 }
1158 case bitc::METADATA_GENERIC_DEBUG: {
1159 if (Record.size() < 4)
1160 return error("Invalid record");
1161
1162 IsDistinct = Record[0];
1163 unsigned Tag = Record[1];
1164 unsigned Version = Record[2];
1165
1166 if (Tag >= 1u << 16 || Version != 0)
1167 return error("Invalid record");
1168
1169 auto *Header = getMDString(Record[3]);
1170 SmallVector<Metadata *, 8> DwarfOps;
1171 for (unsigned I = 4, E = Record.size(); I != E; ++I)
1172 DwarfOps.push_back(getMDOrNull(Record[I]));
1173 MetadataList.assignValue(
1174 GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
1175 NextMetadataNo);
1176 NextMetadataNo++;
1177 break;
1178 }
1179 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 switch (Record[0] >> 1) {
1185 case 0:
1186 Val = GET_OR_DISTINCT(DISubrange,
1187 (Context, Record[1], unrotateSign(Record.back())));
1188 break;
1189 case 1:
1190 Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
1191 unrotateSign(Record.back())));
1192 break;
1193 default:
1194 return error("Invalid record: Unsupported version of DISubrange");
1195 }
1196
1197 MetadataList.assignValue(Val, NextMetadataNo);
1198 IsDistinct = Record[0] & 1;
1199 NextMetadataNo++;
1200 break;
1201 }
1202 case bitc::METADATA_ENUMERATOR: {
1203 if (Record.size() != 3)
1204 return error("Invalid record");
1205
1206 IsDistinct = Record[0] & 1;
1207 bool IsUnsigned = Record[0] & 2;
1208 MetadataList.assignValue(
1209 GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
1210 IsUnsigned, getMDString(Record[2]))),
1211 NextMetadataNo);
1212 NextMetadataNo++;
1213 break;
1214 }
1215 case bitc::METADATA_BASIC_TYPE: {
1216 if (Record.size() < 6 || Record.size() > 7)
1217 return error("Invalid record");
1218
1219 IsDistinct = Record[0];
1220 DINode::DIFlags Flags = (Record.size() > 6) ?
1221 static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
1222
1223 MetadataList.assignValue(
1224 GET_OR_DISTINCT(DIBasicType,
1225 (Context, Record[1], getMDString(Record[2]), Record[3],
1226 Record[4], Record[5], Flags)),
1227 NextMetadataNo);
1228 NextMetadataNo++;
1229 break;
1230 }
1231 case bitc::METADATA_DERIVED_TYPE: {
1232 if (Record.size() < 12 || Record.size() > 13)
1233 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 if (Record.size() > 12 && Record[12])
1239 DWARFAddressSpace = Record[12] - 1;
1240
1241 IsDistinct = Record[0];
1242 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1243 MetadataList.assignValue(
1244 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 NextMetadataNo++;
1253 break;
1254 }
1255 case bitc::METADATA_COMPOSITE_TYPE: {
1256 if (Record.size() < 16 || Record.size() > 17)
1257 return error("Invalid record");
1258
1259 // If we have a UUID and this is not a forward declaration, lookup the
1260 // mapping.
1261 IsDistinct = Record[0] & 0x1;
1262 bool IsNotUsedInTypeRef = Record[0] >= 2;
1263 unsigned Tag = Record[1];
1264 MDString *Name = getMDString(Record[2]);
1265 Metadata *File = getMDOrNull(Record[3]);
1266 unsigned Line = Record[4];
1267 Metadata *Scope = getDITypeRefOrNull(Record[5]);
1268 Metadata *BaseType = nullptr;
1269 uint64_t SizeInBits = Record[7];
1270 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1271 return error("Alignment value is too large");
1272 uint32_t AlignInBits = Record[8];
1273 uint64_t OffsetInBits = 0;
1274 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1275 Metadata *Elements = nullptr;
1276 unsigned RuntimeLang = Record[12];
1277 Metadata *VTableHolder = nullptr;
1278 Metadata *TemplateParams = nullptr;
1279 Metadata *Discriminator = nullptr;
1280 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 if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
1289 (Tag == dwarf::DW_TAG_enumeration_type ||
1290 Tag == dwarf::DW_TAG_class_type ||
1291 Tag == dwarf::DW_TAG_structure_type ||
1292 Tag == dwarf::DW_TAG_union_type)) {
1293 Flags = Flags | DINode::FlagFwdDecl;
1294 } else {
1295 BaseType = getDITypeRefOrNull(Record[6]);
1296 OffsetInBits = Record[9];
1297 Elements = getMDOrNull(Record[11]);
1298 VTableHolder = getDITypeRefOrNull(Record[13]);
1299 TemplateParams = getMDOrNull(Record[14]);
1300 if (Record.size() > 16)
1301 Discriminator = getMDOrNull(Record[16]);
1302 }
1303 DICompositeType *CT = nullptr;
1304 if (Identifier)
1305 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 if (!CT)
1312 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 if (!IsNotUsedInTypeRef && Identifier)
1318 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1319
1320 MetadataList.assignValue(CT, NextMetadataNo);
1321 NextMetadataNo++;
1322 break;
1323 }
1324 case bitc::METADATA_SUBROUTINE_TYPE: {
1325 if (Record.size() < 3 || Record.size() > 4)
1326 return error("Invalid record");
1327 bool IsOldTypeRefArray = Record[0] < 2;
1328 unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1329
1330 IsDistinct = Record[0] & 0x1;
1331 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1332 Metadata *Types = getMDOrNull(Record[2]);
1333 if (LLVM_UNLIKELY(IsOldTypeRefArray)__builtin_expect((bool)(IsOldTypeRefArray), false))
1334 Types = MetadataList.upgradeTypeRefArray(Types);
1335
1336 MetadataList.assignValue(
1337 GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
1338 NextMetadataNo);
1339 NextMetadataNo++;
1340 break;
1341 }
1342
1343 case bitc::METADATA_MODULE: {
1344 if (Record.size() != 6)
1345 return error("Invalid record");
1346
1347 IsDistinct = Record[0];
1348 MetadataList.assignValue(
1349 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 NextMetadataNo++;
1355 break;
1356 }
1357
1358 case bitc::METADATA_FILE: {
1359 if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
1360 return error("Invalid record");
1361
1362 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 if (Record.size() > 4 && Record[3] && Record[4])
1370 Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
1371 getMDString(Record[4]));
1372 MetadataList.assignValue(
1373 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 NextMetadataNo++;
1380 break;
1381 }
1382 case bitc::METADATA_COMPILE_UNIT: {
1383 if (Record.size() < 14 || Record.size() > 19)
1384 return error("Invalid record");
1385
1386 // Ignore Record[0], which indicates whether this compile unit is
1387 // distinct. It's always distinct.
1388 IsDistinct = true;
1389 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 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 Record.size() <= 18 ? 0 : Record[18]);
1399
1400 MetadataList.assignValue(CU, NextMetadataNo);
1401 NextMetadataNo++;
1402
1403 // Move the Upgrade the list of subprograms.
1404 if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1405 CUSubprograms.push_back({CU, SPs});
1406 break;
1407 }
1408 case bitc::METADATA_SUBPROGRAM: {
1409 if (Record.size() < 18 || Record.size() > 21)
1410 return error("Invalid record");
1411
1412 IsDistinct =
1413 (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 if (HasUnit && Record.size() < 19)
1420 return error("Invalid record");
1421 Metadata *CUorFn = getMDOrNull(Record[15]);
1422 unsigned Offset = Record.size() >= 19 ? 1 : 0;
1423 bool HasFn = Offset && !HasUnit;
1424 bool HasThisAdj = Record.size() >= 20;
1425 bool HasThrownTypes = Record.size() >= 21;
1426 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 MetadataList.assignValue(SP, NextMetadataNo);
1451 NextMetadataNo++;
1452
1453 // Upgrade sp->function mapping to function->sp mapping.
1454 if (HasFn) {
1455 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1456 if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1457 if (F->isMaterializable())
1458 // Defer until materialized; unmaterialized functions may not have
1459 // metadata.
1460 FunctionsWithSPs[F] = SP;
1461 else if (!F->empty())
1462 F->setSubprogram(SP);
1463 }
1464 }
1465 break;
1466 }
1467 case bitc::METADATA_LEXICAL_BLOCK: {
1468 if (Record.size() != 5)
1469 return error("Invalid record");
1470
1471 IsDistinct = Record[0];
1472 MetadataList.assignValue(
1473 GET_OR_DISTINCT(DILexicalBlock,
1474 (Context, getMDOrNull(Record[1]),
1475 getMDOrNull(Record[2]), Record[3], Record[4])),
1476 NextMetadataNo);
1477 NextMetadataNo++;
1478 break;
1479 }
1480 case bitc::METADATA_LEXICAL_BLOCK_FILE: {
1481 if (Record.size() != 4)
1482 return error("Invalid record");
1483
1484 IsDistinct = Record[0];
1485 MetadataList.assignValue(
1486 GET_OR_DISTINCT(DILexicalBlockFile,
1487 (Context, getMDOrNull(Record[1]),
1488 getMDOrNull(Record[2]), Record[3])),
1489 NextMetadataNo);
1490 NextMetadataNo++;
1491 break;
1492 }
1493 case bitc::METADATA_NAMESPACE: {
1494 // Newer versions of DINamespace dropped file and line.
1495 MDString *Name;
1496 if (Record.size() == 3)
1497 Name = getMDString(Record[2]);
1498 else if (Record.size() == 5)
1499 Name = getMDString(Record[3]);
1500 else
1501 return error("Invalid record");
1502
1503 IsDistinct = Record[0] & 1;
1504 bool ExportSymbols = Record[0] & 2;
1505 MetadataList.assignValue(
1506 GET_OR_DISTINCT(DINamespace,
1507 (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1508 NextMetadataNo);
1509 NextMetadataNo++;
1510 break;
1511 }
1512 case bitc::METADATA_MACRO: {
1513 if (Record.size() != 5)
1514 return error("Invalid record");
1515
1516 IsDistinct = Record[0];
1517 MetadataList.assignValue(
1518 GET_OR_DISTINCT(DIMacro,
1519 (Context, Record[1], Record[2], getMDString(Record[3]),
1520 getMDString(Record[4]))),
1521 NextMetadataNo);
1522 NextMetadataNo++;
1523 break;
1524 }
1525 case bitc::METADATA_MACRO_FILE: {
1526 if (Record.size() != 5)
1527 return error("Invalid record");
1528
1529 IsDistinct = Record[0];
1530 MetadataList.assignValue(
1531 GET_OR_DISTINCT(DIMacroFile,
1532 (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1533 getMDOrNull(Record[4]))),
1534 NextMetadataNo);
1535 NextMetadataNo++;
1536 break;
1537 }
1538 case bitc::METADATA_TEMPLATE_TYPE: {
1539 if (Record.size() != 3)
1540 return error("Invalid record");
1541
1542 IsDistinct = Record[0];
1543 MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
1544 (Context, getMDString(Record[1]),
1545 getDITypeRefOrNull(Record[2]))),
1546 NextMetadataNo);
1547 NextMetadataNo++;
1548 break;
1549 }
1550 case bitc::METADATA_TEMPLATE_VALUE: {
1551 if (Record.size() != 5)
1552 return error("Invalid record");
1553
1554 IsDistinct = Record[0];
1555 MetadataList.assignValue(
1556 GET_OR_DISTINCT(DITemplateValueParameter,
1557 (Context, Record[1], getMDString(Record[2]),
1558 getDITypeRefOrNull(Record[3]),
1559 getMDOrNull(Record[4]))),
1560 NextMetadataNo);
1561 NextMetadataNo++;
1562 break;
1563 }
1564 case bitc::METADATA_GLOBAL_VAR: {
1565 if (Record.size() < 11 || Record.size() > 13)
1566 return error("Invalid record");
1567
1568 IsDistinct = Record[0] & 1;
1569 unsigned Version = Record[0] >> 1;
1570
1571 if (Version == 2) {
1572 MetadataList.assignValue(
1573 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 NextMetadataNo++;
1582 } else if (Version == 1) {
1583 // No upgrade necessary. A null field will be introduced to indicate
1584 // that no parameter information is available.
1585 MetadataList.assignValue(
1586 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 NextMetadataNo++;
1595 } else if (Version == 0) {
1596 // Upgrade old metadata, which stored a global variable reference or a
1597 // ConstantInt here.
1598 NeedUpgradeToDIGlobalVariableExpression = true;
1599 Metadata *Expr = getMDOrNull(Record[9]);
1600 uint32_t AlignInBits = 0;
1601 if (Record.size() > 11) {
1602 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1603 return error("Alignment value is too large");
1604 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 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 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 if (Attach || Expr)
1628 DGVE = DIGlobalVariableExpression::getDistinct(
1629 Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
1630 if (Attach)
1631 Attach->addDebugInfo(DGVE);
1632
1633 auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1634 MetadataList.assignValue(MDNode, NextMetadataNo);
1635 NextMetadataNo++;
1636 } else
1637 return error("Invalid record");
1638
1639 break;
1640 }
1641 case bitc::METADATA_LOCAL_VAR: {
1642 // 10th field is for the obseleted 'inlinedAt:' field.
1643 if (Record.size() < 8 || Record.size() > 10)
1644 return error("Invalid record");
1645
1646 IsDistinct = Record[0] & 1;
1647 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 bool HasTag = !HasAlignment && Record.size() > 8;
1652 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1653 uint32_t AlignInBits = 0;
1654 if (HasAlignment) {
1655 if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1656 return error("Alignment value is too large");
1657 AlignInBits = Record[8 + HasTag];
1658 }
1659 MetadataList.assignValue(
1660 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 NextMetadataNo++;
1668 break;
1669 }
1670 case bitc::METADATA_LABEL: {
1671 if (Record.size() != 5)
1672 return error("Invalid record");
1673
1674 IsDistinct = Record[0] & 1;
1675 MetadataList.assignValue(
1676 GET_OR_DISTINCT(DILabel,
1677 (Context, getMDOrNull(Record[1]),
1678 getMDString(Record[2]),
1679 getMDOrNull(Record[3]), Record[4])),
1680 NextMetadataNo);
1681 NextMetadataNo++;
1682 break;
1683 }
1684 case bitc::METADATA_EXPRESSION: {
1685 if (Record.size() < 1)
1686 return error("Invalid record");
1687
1688 IsDistinct = Record[0] & 1;
1689 uint64_t Version = Record[0] >> 1;
1690 auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1691
1692 SmallVector<uint64_t, 6> Buffer;
1693 if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
1694 return Err;
1695
1696 MetadataList.assignValue(
1697 GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
1698 NextMetadataNo++;
1699 break;
1700 }
1701 case bitc::METADATA_GLOBAL_VAR_EXPR: {
1702 if (Record.size() != 3)
1703 return error("Invalid record");
1704
1705 IsDistinct = Record[0];
1706 Metadata *Expr = getMDOrNull(Record[2]);
1707 if (!Expr)
1708 Expr = DIExpression::get(Context, {});
1709 MetadataList.assignValue(
1710 GET_OR_DISTINCT(DIGlobalVariableExpression,
1711 (Context, getMDOrNull(Record[1]), Expr)),
1712 NextMetadataNo);
1713 NextMetadataNo++;
1714 break;
1715 }
1716 case bitc::METADATA_OBJC_PROPERTY: {
1717 if (Record.size() != 8)
1718 return error("Invalid record");
1719
1720 IsDistinct = Record[0];
1721 MetadataList.assignValue(
1722 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 NextMetadataNo++;
1729 break;
1730 }
1731 case bitc::METADATA_IMPORTED_ENTITY: {
1732 if (Record.size() != 6 && Record.size() != 7)
1733 return error("Invalid record");
1734
1735 IsDistinct = Record[0];
1736 bool HasFile = (Record.size() == 7);
1737 MetadataList.assignValue(
1738 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 NextMetadataNo++;
1745 break;
1746 }
1747 case bitc::METADATA_STRING_OLD: {
1748 std::string String(Record.begin(), Record.end());
1749
1750 // Test for upgrading !llvm.loop.
1751 HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
1752 ++NumMDStringLoaded;
1753 Metadata *MD = MDString::get(Context, String);
1754 MetadataList.assignValue(MD, NextMetadataNo);
1755 NextMetadataNo++;
1756 break;
1757 }
1758 case bitc::METADATA_STRINGS: {
1759 auto CreateNextMDString = [&](StringRef Str) {
1760 ++NumMDStringLoaded;
1761 MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
1762 NextMetadataNo++;
1763 };
1764 if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
1765 return Err;
1766 break;
1767 }
1768 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
1769 if (Record.size() % 2 == 0)
1770 return error("Invalid record");
1771 unsigned ValueID = Record[0];
1772 if (ValueID >= ValueList.size())
1773 return error("Invalid record");
1774 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1775 if (Error Err = parseGlobalObjectAttachment(
1776 *GO, ArrayRef<uint64_t>(Record).slice(1)))
1777 return Err;
1778 break;
1779 }
1780 case bitc::METADATA_KIND: {
1781 // Support older bitcode files that had METADATA_KIND records in a
1782 // block with METADATA_BLOCK_ID.
1783 if (Error Err = parseMetadataKindRecord(Record))
1784 return Err;
1785 break;
1786 }
1787 }
1788 return Error::success();
1789#undef GET_OR_DISTINCT
1790}
1791
1792Error 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 if (Record.size() != 2)
1799 return error("Invalid record: metadata strings layout");
1800
1801 unsigned NumStrings = Record[0];
1802 unsigned StringsOffset = Record[1];
1803 if (!NumStrings)
1804 return error("Invalid record: metadata strings with no strings");
1805 if (StringsOffset > Blob.size())
1806 return error("Invalid record: metadata strings corrupt offset");
1807
1808 StringRef Lengths = Blob.slice(0, StringsOffset);
1809 SimpleBitstreamCursor R(Lengths);
1810
1811 StringRef Strings = Blob.drop_front(StringsOffset);
1812 do {
1813 if (R.AtEndOfStream())
1814 return error("Invalid record: metadata strings bad length");
1815
1816 unsigned Size = R.ReadVBR(6);
1817 if (Strings.size() < Size)
1818 return error("Invalid record: metadata strings truncated chars");
1819
1820 CallBack(Strings.slice(0, Size));
1821 Strings = Strings.drop_front(Size);
1822 } while (--NumStrings);
1823
1824 return Error::success();
1825}
1826
1827Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1828 GlobalObject &GO, ArrayRef<uint64_t> Record) {
1829 assert(Record.size() % 2 == 0)((Record.size() % 2 == 0) ? static_cast<void> (0) : __assert_fail
("Record.size() % 2 == 0", "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1829, __PRETTY_FUNCTION__))
;
1830 for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
1831 auto K = MDKindMap.find(Record[I]);
1832 if (K == MDKindMap.end())
1833 return error("Invalid ID");
1834 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1835 if (!MD)
1836 return error("Invalid metadata attachment");
1837 GO.addMetadata(K->second, *MD);
1838 }
1839 return Error::success();
1840}
1841
1842/// Parse metadata attachments.
1843Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
1844 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1845 if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
1846 return error("Invalid record");
1847
1848 SmallVector<uint64_t, 64> Record;
1849 PlaceholderQueue Placeholders;
1850
1851 while (true) {
1852 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1853
1854 switch (Entry.Kind) {
1855 case BitstreamEntry::SubBlock: // Handled for us already.
1856 case BitstreamEntry::Error:
1857 return error("Malformed block");
1858 case BitstreamEntry::EndBlock:
1859 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 switch (Stream.readRecord(Entry.ID, Record)) {
1870 default: // Default behavior: ignore.
1871 break;
1872 case bitc::METADATA_ATTACHMENT: {
1873 unsigned RecordLength = Record.size();
1874 if (Record.empty())
1875 return error("Invalid record");
1876 if (RecordLength % 2 == 0) {
1877 // A function attachment.
1878 if (Error Err = parseGlobalObjectAttachment(F, Record))
1879 return Err;
1880 continue;
1881 }
1882
1883 // An instruction attachment.
1884 Instruction *Inst = InstructionList[Record[0]];
1885 for (unsigned i = 1; i != RecordLength; i = i + 2) {
1886 unsigned Kind = Record[i];
1887 DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
1888 if (I == MDKindMap.end())
1889 return error("Invalid ID");
1890 if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1891 continue;
1892
1893 auto Idx = Record[i + 1];
1894 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
1895 !MetadataList.lookup(Idx)) {
1896 // Load the attachment if it is in the lazy-loadable range and hasn't
1897 // been loaded yet.
1898 lazyLoadOneMetadata(Idx, Placeholders);
1899 resolveForwardRefsAndPlaceholders(Placeholders);
1900 }
1901
1902 Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
1903 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 return error("Invalid metadata attachment");
1910
1911 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1912 MD = upgradeInstructionLoopAttachment(*MD);
1913
1914 if (I->second == LLVMContext::MD_tbaa) {
1915 assert(!MD->isTemporary() && "should load MDs before attachments")((!MD->isTemporary() && "should load MDs before attachments"
) ? static_cast<void> (0) : __assert_fail ("!MD->isTemporary() && \"should load MDs before attachments\""
, "/build/llvm-toolchain-snapshot-8~svn345461/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1915, __PRETTY_FUNCTION__))
;
1916 MD = UpgradeTBAANode(*MD);
1917 }
1918 Inst->setMetadata(I->second, MD);
1919 }
1920 break;
1921 }
1922 }
1923 }
1924}
1925
1926/// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1927Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1928 SmallVectorImpl<uint64_t> &Record) {
1929 if (Record.size() < 2)
1930 return error("Invalid record");
1931
1932 unsigned Kind = Record[0];
1933 SmallString<8> Name(Record.begin() + 1, Record.end());
1934
1935 unsigned NewKind = TheModule.getMDKindID(Name.str());
1936 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1937 return error("Conflicting METADATA_KIND records");
1938 return Error::success();
1939}
1940
1941/// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1942Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
1943 if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
2
Assuming the condition is false
3
Taking false branch
1944 return error("Invalid record");
1945
1946 SmallVector<uint64_t, 64> Record;
1947
1948 // Read all the records.
1949 while (true) {
4
Loop condition is true. Entering loop body
1950 BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
5
Calling 'BitstreamCursor::advanceSkippingSubblocks'
1951
1952 switch (Entry.Kind) {
1953 case BitstreamEntry::SubBlock: // Handled for us already.
1954 case BitstreamEntry::Error:
1955 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 unsigned Code = Stream.readRecord(Entry.ID, Record);
1967 switch (Code) {
1968 default: // Default behavior: ignore.
1969 break;
1970 case bitc::METADATA_KIND: {
1971 if (Error Err = parseMetadataKindRecord(Record))
1972 return Err;
1973 break;
1974 }
1975 }
1976 }
1977}
1978
1979MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
1980 Pimpl = std::move(RHS.Pimpl);
1981 return *this;
1982}
1983MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
1984 : Pimpl(std::move(RHS.Pimpl)) {}
1985
1986MetadataLoader::~MetadataLoader() = default;
1987MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
1988 BitcodeReaderValueList &ValueList,
1989 bool IsImporting,
1990 std::function<Type *(unsigned)> getTypeByID)
1991 : Pimpl(llvm::make_unique<MetadataLoaderImpl>(
1992 Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
1993
1994Error MetadataLoader::parseMetadata(bool ModuleLevel) {
1995 return Pimpl->parseMetadata(ModuleLevel);
1996}
1997
1998bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
1999
2000/// Return the given metadata, creating a replaceable forward reference if
2001/// necessary.
2002Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
2003 return Pimpl->getMetadataFwdRefOrLoad(Idx);
2004}
2005
2006MDNode *MetadataLoader::getMDNodeFwdRefOrNull(unsigned Idx) {
2007 return Pimpl->getMDNodeFwdRefOrNull(Idx);
2008}
2009
2010DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
2011 return Pimpl->lookupSubprogramForFunction(F);
2012}
2013
2014Error MetadataLoader::parseMetadataAttachment(
2015 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2016 return Pimpl->parseMetadataAttachment(F, InstructionList);
2017}
2018
2019Error MetadataLoader::parseMetadataKinds() {
2020 return Pimpl->parseMetadataKinds();
1
Calling 'MetadataLoaderImpl::parseMetadataKinds'
2021}
2022
2023void MetadataLoader::setStripTBAA(bool StripTBAA) {
2024 return Pimpl->setStripTBAA(StripTBAA);
2025}
2026
2027bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2028
2029unsigned MetadataLoader::size() const { return Pimpl->size(); }
2030void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2031
2032void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
2033 return Pimpl->upgradeDebugIntrinsics(F);
2034}

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Bitcode/BitstreamReader.h

1//===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This header defines the BitstreamReader class. This class can be used to
11// read an arbitrary bitstream, regardless of its contents.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_BITCODE_BITSTREAMREADER_H
16#define LLVM_BITCODE_BITSTREAMREADER_H
17
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/Bitcode/BitCodes.h"
21#include "llvm/Support/Endian.h"
22#include "llvm/Support/ErrorHandling.h"
23#include "llvm/Support/MathExtras.h"
24#include "llvm/Support/MemoryBuffer.h"
25#include <algorithm>
26#include <cassert>
27#include <climits>
28#include <cstddef>
29#include <cstdint>
30#include <memory>
31#include <string>
32#include <utility>
33#include <vector>
34
35namespace llvm {
36
37/// This class maintains the abbreviations read from a block info block.
38class BitstreamBlockInfo {
39public:
40 /// This contains information emitted to BLOCKINFO_BLOCK blocks. These
41 /// describe abbreviations that all blocks of the specified ID inherit.
42 struct BlockInfo {
43 unsigned BlockID;
44 std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
45 std::string Name;
46 std::vector<std::pair<unsigned, std::string>> RecordNames;
47 };
48
49private:
50 std::vector<BlockInfo> BlockInfoRecords;
51
52public:
53 /// If there is block info for the specified ID, return it, otherwise return
54 /// null.
55 const BlockInfo *getBlockInfo(unsigned BlockID) const {
56 // Common case, the most recent entry matches BlockID.
57 if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
58 return &BlockInfoRecords.back();
59
60 for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
61 i != e; ++i)
62 if (BlockInfoRecords[i].BlockID == BlockID)
63 return &BlockInfoRecords[i];
64 return nullptr;
65 }
66
67 BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
68 if (const BlockInfo *BI = getBlockInfo(BlockID))
69 return *const_cast<BlockInfo*>(BI);
70
71 // Otherwise, add a new record.
72 BlockInfoRecords.emplace_back();
73 BlockInfoRecords.back().BlockID = BlockID;
74 return BlockInfoRecords.back();
75 }
76};
77
78/// This represents a position within a bitstream. There may be multiple
79/// independent cursors reading within one bitstream, each maintaining their
80/// own local state.
81class SimpleBitstreamCursor {
82 ArrayRef<uint8_t> BitcodeBytes;
83 size_t NextChar = 0;
84
85public:
86 /// This is the current data we have pulled from the stream but have not
87 /// returned to the client. This is specifically and intentionally defined to
88 /// follow the word size of the host machine for efficiency. We use word_t in
89 /// places that are aware of this to make it perfectly explicit what is going
90 /// on.
91 using word_t = size_t;
92
93private:
94 word_t CurWord = 0;
95
96 /// This is the number of bits in CurWord that are valid. This is always from
97 /// [0...bits_of(size_t)-1] inclusive.
98 unsigned BitsInCurWord = 0;
99
100public:
101 static const size_t MaxChunkSize = sizeof(word_t) * 8;
102
103 SimpleBitstreamCursor() = default;
104 explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
105 : BitcodeBytes(BitcodeBytes) {}
106 explicit SimpleBitstreamCursor(StringRef BitcodeBytes)
107 : BitcodeBytes(reinterpret_cast<const uint8_t *>(BitcodeBytes.data()),
108 BitcodeBytes.size()) {}
109 explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes)
110 : SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {}
111
112 bool canSkipToPos(size_t pos) const {
113 // pos can be skipped to if it is a valid address or one byte past the end.
114 return pos <= BitcodeBytes.size();
115 }
116
117 bool AtEndOfStream() {
118 return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
119 }
120
121 /// Return the bit # of the bit we are reading.
122 uint64_t GetCurrentBitNo() const {
123 return NextChar*CHAR_BIT8 - BitsInCurWord;
124 }
125
126 // Return the byte # of the current bit.
127 uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }
128
129 ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
130
131 /// Reset the stream to the specified bit number.
132 void JumpToBit(uint64_t BitNo) {
133 size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1);
134 unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
135 assert(canSkipToPos(ByteNo) && "Invalid location")((canSkipToPos(ByteNo) && "Invalid location") ? static_cast
<void> (0) : __assert_fail ("canSkipToPos(ByteNo) && \"Invalid location\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Bitcode/BitstreamReader.h"
, 135, __PRETTY_FUNCTION__))
;
136
137 // Move the cursor to the right word.
138 NextChar = ByteNo;
139 BitsInCurWord = 0;
140
141 // Skip over any bits that are already consumed.
142 if (WordBitNo)
143 Read(WordBitNo);
144 }
145
146 /// Get a pointer into the bitstream at the specified byte offset.
147 const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
148 return BitcodeBytes.data() + ByteNo;
149 }
150
151 /// Get a pointer into the bitstream at the specified bit offset.
152 ///
153 /// The bit offset must be on a byte boundary.
154 const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
155 assert(!(BitNo % 8) && "Expected bit on byte boundary")((!(BitNo % 8) && "Expected bit on byte boundary") ? static_cast
<void> (0) : __assert_fail ("!(BitNo % 8) && \"Expected bit on byte boundary\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Bitcode/BitstreamReader.h"
, 155, __PRETTY_FUNCTION__))
;
156 return getPointerToByte(BitNo / 8, NumBytes);
157 }
158
159 void fillCurWord() {
160 if (NextChar >= BitcodeBytes.size())
161 report_fatal_error("Unexpected end of file");
162
163 // Read the next word from the stream.
164 const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
165 unsigned BytesRead;
166 if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
167 BytesRead = sizeof(word_t);
168 CurWord =
169 support::endian::read<word_t, support::little, support::unaligned>(
170 NextCharPtr);
171 } else {
172 // Short read.
173 BytesRead = BitcodeBytes.size() - NextChar;
174 CurWord = 0;
175 for (unsigned B = 0; B != BytesRead; ++B)
176 CurWord |= uint64_t(NextCharPtr[B]) << (B * 8);
177 }
178 NextChar += BytesRead;
179 BitsInCurWord = BytesRead * 8;
180 }
181
182 word_t Read(unsigned NumBits) {
183 static const unsigned BitsInWord = MaxChunkSize;
184
185 assert(NumBits && NumBits <= BitsInWord &&((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Bitcode/BitstreamReader.h"
, 186, __PRETTY_FUNCTION__))
186 "Cannot return zero or more than BitsInWord bits!")((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Bitcode/BitstreamReader.h"
, 186, __PRETTY_FUNCTION__))
;
187
188 static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f;
12
'?' condition is true
189
190 // If the field is fully contained by CurWord, return it quickly.
191 if (BitsInCurWord >= NumBits) {
13
Assuming the condition is false
14
Taking false branch
192 word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits));
193
194 // Use a mask to avoid undefined behavior.
195 CurWord >>= (NumBits & Mask);
196
197 BitsInCurWord -= NumBits;
198 return R;
199 }
200
201 word_t R = BitsInCurWord ? CurWord : 0;
15
'?' condition is true
202 unsigned BitsLeft = NumBits - BitsInCurWord;
203
204 fillCurWord();
205
206 // If we run out of data, abort.
207 if (BitsLeft > BitsInCurWord)
16
Assuming the condition is false
17
Taking false branch
208 report_fatal_error("Unexpected end of file");
209
210 word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
18
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'
211
212 // Use a mask to avoid undefined behavior.
213 CurWord >>= (BitsLeft & Mask);
214
215 BitsInCurWord -= BitsLeft;
216
217 R |= R2 << (NumBits - BitsLeft);
218
219 return R;
220 }
221
222 uint32_t ReadVBR(unsigned NumBits) {
223 uint32_t Piece = Read(NumBits);
224 if ((Piece & (1U << (NumBits-1))) == 0)
225 return Piece;
226
227 uint32_t Result = 0;
228 unsigned NextBit = 0;
229 while (true) {
230 Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
231
232 if ((Piece & (1U << (NumBits-1))) == 0)
233 return Result;
234
235 NextBit += NumBits-1;
236 Piece = Read(NumBits);
237 }
238 }
239
240 // Read a VBR that may have a value up to 64-bits in size. The chunk size of
241 // the VBR must still be <= 32 bits though.
242 uint64_t ReadVBR64(unsigned NumBits) {
243 uint32_t Piece = Read(NumBits);
244 if ((Piece & (1U << (NumBits-1))) == 0)
245 return uint64_t(Piece);
246
247 uint64_t Result = 0;
248 unsigned NextBit = 0;
249 while (true) {
250 Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
251
252 if ((Piece & (1U << (NumBits-1))) == 0)
253 return Result;
254
255 NextBit += NumBits-1;
256 Piece = Read(NumBits);
257 }
258 }
259
260 void SkipToFourByteBoundary() {
261 // If word_t is 64-bits and if we've read less than 32 bits, just dump
262 // the bits we have up to the next 32-bit boundary.
263 if (sizeof(word_t) > 4 &&
264 BitsInCurWord >= 32) {
265 CurWord >>= BitsInCurWord-32;
266 BitsInCurWord = 32;
267 return;
268 }
269
270 BitsInCurWord = 0;
271 }
272
273 /// Skip to the end of the file.
274 void skipToEnd() { NextChar = BitcodeBytes.size(); }
275};
276
277/// When advancing through a bitstream cursor, each advance can discover a few
278/// different kinds of entries:
279struct BitstreamEntry {
280 enum {
281 Error, // Malformed bitcode was found.
282 EndBlock, // We've reached the end of the current block, (or the end of the
283 // file, which is treated like a series of EndBlock records.
284 SubBlock, // This is the start of a new subblock of a specific ID.
285 Record // This is a record with a specific AbbrevID.
286 } Kind;
287
288 unsigned ID;
289
290 static BitstreamEntry getError() {
291 BitstreamEntry E; E.Kind = Error; return E;
292 }
293
294 static BitstreamEntry getEndBlock() {
295 BitstreamEntry E; E.Kind = EndBlock; return E;
296 }
297
298 static BitstreamEntry getSubBlock(unsigned ID) {
299 BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
300 }
301
302 static BitstreamEntry getRecord(unsigned AbbrevID) {
303 BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
304 }
305};
306
307/// This represents a position within a bitcode file, implemented on top of a
308/// SimpleBitstreamCursor.
309///
310/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
311/// be passed by value.
312class BitstreamCursor : SimpleBitstreamCursor {
313 // This is the declared size of code values used for the current block, in
314 // bits.
315 unsigned CurCodeSize = 2;
316
317 /// Abbrevs installed at in this block.
318 std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
319
320 struct Block {
321 unsigned PrevCodeSize;
322 std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
323
324 explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
325 };
326
327 /// This tracks the codesize of parent blocks.
328 SmallVector<Block, 8> BlockScope;
329
330 BitstreamBlockInfo *BlockInfo = nullptr;
331
332public:
333 static const size_t MaxChunkSize = sizeof(word_t) * 8;
334
335 BitstreamCursor() = default;
336 explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
337 : SimpleBitstreamCursor(BitcodeBytes) {}
338 explicit BitstreamCursor(StringRef BitcodeBytes)
339 : SimpleBitstreamCursor(BitcodeBytes) {}
340 explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
341 : SimpleBitstreamCursor(BitcodeBytes) {}
342
343 using SimpleBitstreamCursor::canSkipToPos;
344 using SimpleBitstreamCursor::AtEndOfStream;
345 using SimpleBitstreamCursor::getBitcodeBytes;
346 using SimpleBitstreamCursor::GetCurrentBitNo;
347 using SimpleBitstreamCursor::getCurrentByteNo;
348 using SimpleBitstreamCursor::getPointerToByte;
349 using SimpleBitstreamCursor::JumpToBit;
350 using SimpleBitstreamCursor::fillCurWord;
351 using SimpleBitstreamCursor::Read;
352 using SimpleBitstreamCursor::ReadVBR;
353 using SimpleBitstreamCursor::ReadVBR64;
354
355 /// Return the number of bits used to encode an abbrev #.
356 unsigned getAbbrevIDWidth() const { return CurCodeSize; }
357
358 /// Flags that modify the behavior of advance().
359 enum {
360 /// If this flag is used, the advance() method does not automatically pop
361 /// the block scope when the end of a block is reached.
362 AF_DontPopBlockAtEnd = 1,
363
364 /// If this flag is used, abbrev entries are returned just like normal
365 /// records.
366 AF_DontAutoprocessAbbrevs = 2
367 };
368
369 /// Advance the current bitstream, returning the next entry in the stream.
370 BitstreamEntry advance(unsigned Flags = 0) {
371 while (true) {
8
Loop condition is true. Entering loop body
372 if (AtEndOfStream())
9
Taking false branch
373 return BitstreamEntry::getError();
374
375 unsigned Code = ReadCode();
10
Calling 'BitstreamCursor::ReadCode'
376 if (Code == bitc::END_BLOCK) {
377 // Pop the end of the block unless Flags tells us not to.
378 if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
379 return BitstreamEntry::getError();
380 return BitstreamEntry::getEndBlock();
381 }
382
383 if (Code == bitc::ENTER_SUBBLOCK)
384 return BitstreamEntry::getSubBlock(ReadSubBlockID());
385
386 if (Code == bitc::DEFINE_ABBREV &&
387 !(Flags & AF_DontAutoprocessAbbrevs)) {
388 // We read and accumulate abbrev's, the client can't do anything with
389 // them anyway.
390 ReadAbbrevRecord();
391 continue;
392 }
393
394 return BitstreamEntry::getRecord(Code);
395 }
396 }
397
398 /// This is a convenience function for clients that don't expect any
399 /// subblocks. This just skips over them automatically.
400 BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
401 while (true) {
6
Loop condition is true. Entering loop body
402 // If we found a normal entry, return it.
403 BitstreamEntry Entry = advance(Flags);
7
Calling 'BitstreamCursor::advance'
404 if (Entry.Kind != BitstreamEntry::SubBlock)
405 return Entry;
406
407 // If we found a sub-block, just skip over it and check the next entry.
408 if (SkipBlock())
409 return BitstreamEntry::getError();
410 }
411 }
412
413 unsigned ReadCode() {
414 return Read(CurCodeSize);
11
Calling 'SimpleBitstreamCursor::Read'
415 }
416
417 // Block header:
418 // [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
419
420 /// Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
421 unsigned ReadSubBlockID() {
422 return ReadVBR(bitc::BlockIDWidth);
423 }
424
425 /// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
426 /// of this block. If the block record is malformed, return true.
427 bool SkipBlock() {
428 // Read and ignore the codelen value. Since we are skipping this block, we
429 // don't care what code widths are used inside of it.
430 ReadVBR(bitc::CodeLenWidth);
431 SkipToFourByteBoundary();
432 size_t NumFourBytes = Read(bitc::BlockSizeWidth);
433
434 // Check that the block wasn't partially defined, and that the offset isn't
435 // bogus.
436 size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
437 if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
438 return true;
439
440 JumpToBit(SkipTo);
441 return false;
442 }
443
444 /// Having read the ENTER_SUBBLOCK abbrevid, enter the block, and return true
445 /// if the block has an error.
446 bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr);
447
448 bool ReadBlockEnd() {
449 if (BlockScope.empty()) return true;
450
451 // Block tail:
452 // [END_BLOCK, <align4bytes>]
453 SkipToFourByteBoundary();
454
455 popBlockScope();
456 return false;
457 }
458
459private:
460 void popBlockScope() {
461 CurCodeSize = BlockScope.back().PrevCodeSize;
462
463 CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
464 BlockScope.pop_back();
465 }
466
467 //===--------------------------------------------------------------------===//
468 // Record Processing
469 //===--------------------------------------------------------------------===//
470
471public:
472 /// Return the abbreviation for the specified AbbrevId.
473 const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
474 unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV;
475 if (AbbrevNo >= CurAbbrevs.size())
476 report_fatal_error("Invalid abbrev number");
477 return CurAbbrevs[AbbrevNo].get();
478 }
479
480 /// Read the current record and discard it, returning the code for the record.
481 unsigned skipRecord(unsigned AbbrevID);
482
483 unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
484 StringRef *Blob = nullptr);
485
486 //===--------------------------------------------------------------------===//
487 // Abbrev Processing
488 //===--------------------------------------------------------------------===//
489 void ReadAbbrevRecord();
490
491 /// Read and return a block info block from the bitstream. If an error was
492 /// encountered, return None.
493 ///
494 /// \param ReadBlockInfoNames Whether to read block/record name information in
495 /// the BlockInfo block. Only llvm-bcanalyzer uses this.
496 Optional<BitstreamBlockInfo>
497 ReadBlockInfoBlock(bool ReadBlockInfoNames = false);
498
499 /// Set the block info to be used by this BitstreamCursor to interpret
500 /// abbreviated records.
501 void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; }
502};
503
504} // end llvm namespace
505
506#endif // LLVM_BITCODE_BITSTREAMREADER_H