1311116Sdim//===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===// 2311116Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6311116Sdim// 7311116Sdim//===----------------------------------------------------------------------===// 8311116Sdim 9311116Sdim#include "MetadataLoader.h" 10311116Sdim#include "ValueList.h" 11311116Sdim 12311116Sdim#include "llvm/ADT/APFloat.h" 13311116Sdim#include "llvm/ADT/APInt.h" 14311116Sdim#include "llvm/ADT/ArrayRef.h" 15311116Sdim#include "llvm/ADT/DenseMap.h" 16311544Sdim#include "llvm/ADT/DenseSet.h" 17311116Sdim#include "llvm/ADT/None.h" 18311116Sdim#include "llvm/ADT/STLExtras.h" 19311116Sdim#include "llvm/ADT/SmallString.h" 20311116Sdim#include "llvm/ADT/SmallVector.h" 21311544Sdim#include "llvm/ADT/Statistic.h" 22311116Sdim#include "llvm/ADT/StringRef.h" 23311116Sdim#include "llvm/ADT/Twine.h" 24311116Sdim#include "llvm/Bitcode/BitcodeReader.h" 25353358Sdim#include "llvm/Bitstream/BitstreamReader.h" 26311116Sdim#include "llvm/Bitcode/LLVMBitCodes.h" 27311116Sdim#include "llvm/IR/Argument.h" 28311116Sdim#include "llvm/IR/Attributes.h" 29311116Sdim#include "llvm/IR/AutoUpgrade.h" 30311116Sdim#include "llvm/IR/BasicBlock.h" 31311116Sdim#include "llvm/IR/CallingConv.h" 32311116Sdim#include "llvm/IR/Comdat.h" 33311116Sdim#include "llvm/IR/Constant.h" 34311116Sdim#include "llvm/IR/Constants.h" 35311116Sdim#include "llvm/IR/DebugInfo.h" 36311116Sdim#include "llvm/IR/DebugInfoMetadata.h" 37311116Sdim#include "llvm/IR/DebugLoc.h" 38311116Sdim#include "llvm/IR/DerivedTypes.h" 39311116Sdim#include "llvm/IR/DiagnosticPrinter.h" 40311116Sdim#include "llvm/IR/Function.h" 41311116Sdim#include "llvm/IR/GVMaterializer.h" 42311116Sdim#include "llvm/IR/GlobalAlias.h" 43311116Sdim#include "llvm/IR/GlobalIFunc.h" 44311116Sdim#include "llvm/IR/GlobalIndirectSymbol.h" 45311116Sdim#include "llvm/IR/GlobalObject.h" 46311116Sdim#include "llvm/IR/GlobalValue.h" 47311116Sdim#include "llvm/IR/GlobalVariable.h" 48311116Sdim#include "llvm/IR/InlineAsm.h" 49311116Sdim#include "llvm/IR/InstrTypes.h" 50311116Sdim#include "llvm/IR/Instruction.h" 51311116Sdim#include "llvm/IR/Instructions.h" 52321369Sdim#include "llvm/IR/IntrinsicInst.h" 53311116Sdim#include "llvm/IR/Intrinsics.h" 54311116Sdim#include "llvm/IR/LLVMContext.h" 55311116Sdim#include "llvm/IR/Module.h" 56311116Sdim#include "llvm/IR/ModuleSummaryIndex.h" 57311116Sdim#include "llvm/IR/OperandTraits.h" 58311116Sdim#include "llvm/IR/TrackingMDRef.h" 59311116Sdim#include "llvm/IR/Type.h" 60311116Sdim#include "llvm/IR/ValueHandle.h" 61311116Sdim#include "llvm/Support/AtomicOrdering.h" 62311116Sdim#include "llvm/Support/Casting.h" 63311116Sdim#include "llvm/Support/CommandLine.h" 64311116Sdim#include "llvm/Support/Compiler.h" 65311116Sdim#include "llvm/Support/Debug.h" 66311116Sdim#include "llvm/Support/Error.h" 67311116Sdim#include "llvm/Support/ErrorHandling.h" 68311116Sdim#include "llvm/Support/ManagedStatic.h" 69311116Sdim#include "llvm/Support/MemoryBuffer.h" 70311116Sdim#include "llvm/Support/raw_ostream.h" 71311116Sdim#include <algorithm> 72311116Sdim#include <cassert> 73311116Sdim#include <cstddef> 74311116Sdim#include <cstdint> 75311116Sdim#include <deque> 76311116Sdim#include <limits> 77311116Sdim#include <map> 78311116Sdim#include <memory> 79311116Sdim#include <string> 80311116Sdim#include <system_error> 81311116Sdim#include <tuple> 82311116Sdim#include <utility> 83311116Sdim#include <vector> 84311116Sdim 85311116Sdimusing namespace llvm; 86311116Sdim 87311544Sdim#define DEBUG_TYPE "bitcode-reader" 88311544Sdim 89311544SdimSTATISTIC(NumMDStringLoaded, "Number of MDStrings loaded"); 90311544SdimSTATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created"); 91311544SdimSTATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded"); 92311544Sdim 93311116Sdim/// Flag whether we need to import full type definitions for ThinLTO. 94311116Sdim/// Currently needed for Darwin and LLDB. 95311116Sdimstatic cl::opt<bool> ImportFullTypeDefinitions( 96311116Sdim "import-full-type-definitions", cl::init(false), cl::Hidden, 97311116Sdim cl::desc("Import full type definitions for ThinLTO.")); 98311116Sdim 99311544Sdimstatic cl::opt<bool> DisableLazyLoading( 100311544Sdim "disable-ondemand-mds-loading", cl::init(false), cl::Hidden, 101311544Sdim cl::desc("Force disable the lazy-loading on-demand of metadata when " 102311544Sdim "loading bitcode for importing.")); 103311544Sdim 104311116Sdimnamespace { 105311116Sdim 106353358Sdimstatic int64_t unrotateSign(uint64_t U) { return (U & 1) ? ~(U >> 1) : U >> 1; } 107311116Sdim 108311116Sdimclass BitcodeReaderMetadataList { 109311116Sdim /// Array of metadata references. 110311116Sdim /// 111311116Sdim /// Don't use std::vector here. Some versions of libc++ copy (instead of 112311116Sdim /// move) on resize, and TrackingMDRef is very expensive to copy. 113311116Sdim SmallVector<TrackingMDRef, 1> MetadataPtrs; 114311116Sdim 115311116Sdim /// The set of indices in MetadataPtrs above of forward references that were 116311116Sdim /// generated. 117311116Sdim SmallDenseSet<unsigned, 1> ForwardReference; 118311116Sdim 119311116Sdim /// The set of indices in MetadataPtrs above of Metadata that need to be 120311116Sdim /// resolved. 121311116Sdim SmallDenseSet<unsigned, 1> UnresolvedNodes; 122311116Sdim 123311116Sdim /// Structures for resolving old type refs. 124311116Sdim struct { 125311116Sdim SmallDenseMap<MDString *, TempMDTuple, 1> Unknown; 126311116Sdim SmallDenseMap<MDString *, DICompositeType *, 1> Final; 127311116Sdim SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls; 128311116Sdim SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays; 129311116Sdim } OldTypeRefs; 130311116Sdim 131311116Sdim LLVMContext &Context; 132311116Sdim 133353358Sdim /// Maximum number of valid references. Forward references exceeding the 134353358Sdim /// maximum must be invalid. 135353358Sdim unsigned RefsUpperBound; 136353358Sdim 137311116Sdimpublic: 138353358Sdim BitcodeReaderMetadataList(LLVMContext &C, size_t RefsUpperBound) 139353358Sdim : Context(C), 140353358Sdim RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(), 141353358Sdim RefsUpperBound)) {} 142311116Sdim 143311116Sdim // vector compatibility methods 144311116Sdim unsigned size() const { return MetadataPtrs.size(); } 145311116Sdim void resize(unsigned N) { MetadataPtrs.resize(N); } 146311116Sdim void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); } 147311116Sdim void clear() { MetadataPtrs.clear(); } 148311116Sdim Metadata *back() const { return MetadataPtrs.back(); } 149311116Sdim void pop_back() { MetadataPtrs.pop_back(); } 150311116Sdim bool empty() const { return MetadataPtrs.empty(); } 151311116Sdim 152311116Sdim Metadata *operator[](unsigned i) const { 153311116Sdim assert(i < MetadataPtrs.size()); 154311116Sdim return MetadataPtrs[i]; 155311116Sdim } 156311116Sdim 157311116Sdim Metadata *lookup(unsigned I) const { 158311116Sdim if (I < MetadataPtrs.size()) 159311116Sdim return MetadataPtrs[I]; 160311116Sdim return nullptr; 161311116Sdim } 162311116Sdim 163311116Sdim void shrinkTo(unsigned N) { 164311116Sdim assert(N <= size() && "Invalid shrinkTo request!"); 165311116Sdim assert(ForwardReference.empty() && "Unexpected forward refs"); 166311116Sdim assert(UnresolvedNodes.empty() && "Unexpected unresolved node"); 167311116Sdim MetadataPtrs.resize(N); 168311116Sdim } 169311116Sdim 170311116Sdim /// Return the given metadata, creating a replaceable forward reference if 171311116Sdim /// necessary. 172311116Sdim Metadata *getMetadataFwdRef(unsigned Idx); 173311116Sdim 174341825Sdim /// Return the given metadata only if it is fully resolved. 175311116Sdim /// 176311116Sdim /// Gives the same result as \a lookup(), unless \a MDNode::isResolved() 177311116Sdim /// would give \c false. 178311116Sdim Metadata *getMetadataIfResolved(unsigned Idx); 179311116Sdim 180311116Sdim MDNode *getMDNodeFwdRefOrNull(unsigned Idx); 181311116Sdim void assignValue(Metadata *MD, unsigned Idx); 182311116Sdim void tryToResolveCycles(); 183311116Sdim bool hasFwdRefs() const { return !ForwardReference.empty(); } 184311544Sdim int getNextFwdRef() { 185311544Sdim assert(hasFwdRefs()); 186311544Sdim return *ForwardReference.begin(); 187311544Sdim } 188311116Sdim 189311116Sdim /// Upgrade a type that had an MDString reference. 190311116Sdim void addTypeRef(MDString &UUID, DICompositeType &CT); 191311116Sdim 192311116Sdim /// Upgrade a type that had an MDString reference. 193311116Sdim Metadata *upgradeTypeRef(Metadata *MaybeUUID); 194311116Sdim 195311116Sdim /// Upgrade a type ref array that may have MDString references. 196311116Sdim Metadata *upgradeTypeRefArray(Metadata *MaybeTuple); 197311116Sdim 198311116Sdimprivate: 199311116Sdim Metadata *resolveTypeRefArray(Metadata *MaybeTuple); 200311116Sdim}; 201311116Sdim 202311116Sdimvoid BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) { 203311116Sdim if (auto *MDN = dyn_cast<MDNode>(MD)) 204311116Sdim if (!MDN->isResolved()) 205311116Sdim UnresolvedNodes.insert(Idx); 206311116Sdim 207311116Sdim if (Idx == size()) { 208311116Sdim push_back(MD); 209311116Sdim return; 210311116Sdim } 211311116Sdim 212311116Sdim if (Idx >= size()) 213311116Sdim resize(Idx + 1); 214311116Sdim 215311116Sdim TrackingMDRef &OldMD = MetadataPtrs[Idx]; 216311116Sdim if (!OldMD) { 217311116Sdim OldMD.reset(MD); 218311116Sdim return; 219311116Sdim } 220311116Sdim 221311116Sdim // If there was a forward reference to this value, replace it. 222311116Sdim TempMDTuple PrevMD(cast<MDTuple>(OldMD.get())); 223311116Sdim PrevMD->replaceAllUsesWith(MD); 224311116Sdim ForwardReference.erase(Idx); 225311116Sdim} 226311116Sdim 227311116SdimMetadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) { 228353358Sdim // Bail out for a clearly invalid value. 229353358Sdim if (Idx >= RefsUpperBound) 230353358Sdim return nullptr; 231353358Sdim 232311116Sdim if (Idx >= size()) 233311116Sdim resize(Idx + 1); 234311116Sdim 235311116Sdim if (Metadata *MD = MetadataPtrs[Idx]) 236311116Sdim return MD; 237311116Sdim 238311116Sdim // Track forward refs to be resolved later. 239311116Sdim ForwardReference.insert(Idx); 240311116Sdim 241311116Sdim // Create and return a placeholder, which will later be RAUW'd. 242311544Sdim ++NumMDNodeTemporary; 243311116Sdim Metadata *MD = MDNode::getTemporary(Context, None).release(); 244311116Sdim MetadataPtrs[Idx].reset(MD); 245311116Sdim return MD; 246311116Sdim} 247311116Sdim 248311116SdimMetadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) { 249311116Sdim Metadata *MD = lookup(Idx); 250311116Sdim if (auto *N = dyn_cast_or_null<MDNode>(MD)) 251311116Sdim if (!N->isResolved()) 252311116Sdim return nullptr; 253311116Sdim return MD; 254311116Sdim} 255311116Sdim 256311116SdimMDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) { 257311116Sdim return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx)); 258311116Sdim} 259311116Sdim 260311116Sdimvoid BitcodeReaderMetadataList::tryToResolveCycles() { 261311116Sdim if (!ForwardReference.empty()) 262311116Sdim // Still forward references... can't resolve cycles. 263311116Sdim return; 264311116Sdim 265311116Sdim // Give up on finding a full definition for any forward decls that remain. 266311116Sdim for (const auto &Ref : OldTypeRefs.FwdDecls) 267311116Sdim OldTypeRefs.Final.insert(Ref); 268311116Sdim OldTypeRefs.FwdDecls.clear(); 269311116Sdim 270311116Sdim // Upgrade from old type ref arrays. In strange cases, this could add to 271311116Sdim // OldTypeRefs.Unknown. 272311116Sdim for (const auto &Array : OldTypeRefs.Arrays) 273311116Sdim Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get())); 274311116Sdim OldTypeRefs.Arrays.clear(); 275311116Sdim 276311116Sdim // Replace old string-based type refs with the resolved node, if possible. 277311116Sdim // If we haven't seen the node, leave it to the verifier to complain about 278311116Sdim // the invalid string reference. 279311116Sdim for (const auto &Ref : OldTypeRefs.Unknown) { 280311116Sdim if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first)) 281311116Sdim Ref.second->replaceAllUsesWith(CT); 282311116Sdim else 283311116Sdim Ref.second->replaceAllUsesWith(Ref.first); 284311116Sdim } 285311116Sdim OldTypeRefs.Unknown.clear(); 286311116Sdim 287311116Sdim if (UnresolvedNodes.empty()) 288311116Sdim // Nothing to do. 289311116Sdim return; 290311116Sdim 291311116Sdim // Resolve any cycles. 292311116Sdim for (unsigned I : UnresolvedNodes) { 293311116Sdim auto &MD = MetadataPtrs[I]; 294311116Sdim auto *N = dyn_cast_or_null<MDNode>(MD); 295311116Sdim if (!N) 296311116Sdim continue; 297311116Sdim 298311116Sdim assert(!N->isTemporary() && "Unexpected forward reference"); 299311116Sdim N->resolveCycles(); 300311116Sdim } 301311116Sdim 302311116Sdim // Make sure we return early again until there's another unresolved ref. 303311116Sdim UnresolvedNodes.clear(); 304311116Sdim} 305311116Sdim 306311116Sdimvoid BitcodeReaderMetadataList::addTypeRef(MDString &UUID, 307311116Sdim DICompositeType &CT) { 308311116Sdim assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID"); 309311116Sdim if (CT.isForwardDecl()) 310311116Sdim OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT)); 311311116Sdim else 312311116Sdim OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT)); 313311116Sdim} 314311116Sdim 315311116SdimMetadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) { 316311116Sdim auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID); 317311116Sdim if (LLVM_LIKELY(!UUID)) 318311116Sdim return MaybeUUID; 319311116Sdim 320311116Sdim if (auto *CT = OldTypeRefs.Final.lookup(UUID)) 321311116Sdim return CT; 322311116Sdim 323311116Sdim auto &Ref = OldTypeRefs.Unknown[UUID]; 324311116Sdim if (!Ref) 325311116Sdim Ref = MDNode::getTemporary(Context, None); 326311116Sdim return Ref.get(); 327311116Sdim} 328311116Sdim 329311116SdimMetadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) { 330311116Sdim auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); 331311116Sdim if (!Tuple || Tuple->isDistinct()) 332311116Sdim return MaybeTuple; 333311116Sdim 334311116Sdim // Look through the array immediately if possible. 335311116Sdim if (!Tuple->isTemporary()) 336311116Sdim return resolveTypeRefArray(Tuple); 337311116Sdim 338311116Sdim // Create and return a placeholder to use for now. Eventually 339311116Sdim // resolveTypeRefArrays() will be resolve this forward reference. 340311116Sdim OldTypeRefs.Arrays.emplace_back( 341311116Sdim std::piecewise_construct, std::forward_as_tuple(Tuple), 342311116Sdim std::forward_as_tuple(MDTuple::getTemporary(Context, None))); 343311116Sdim return OldTypeRefs.Arrays.back().second.get(); 344311116Sdim} 345311116Sdim 346311116SdimMetadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) { 347311116Sdim auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); 348311116Sdim if (!Tuple || Tuple->isDistinct()) 349311116Sdim return MaybeTuple; 350311116Sdim 351353358Sdim // Look through the DITypeRefArray, upgrading each DIType *. 352311116Sdim SmallVector<Metadata *, 32> Ops; 353311116Sdim Ops.reserve(Tuple->getNumOperands()); 354311116Sdim for (Metadata *MD : Tuple->operands()) 355311116Sdim Ops.push_back(upgradeTypeRef(MD)); 356311116Sdim 357311116Sdim return MDTuple::get(Context, Ops); 358311116Sdim} 359311116Sdim 360311116Sdimnamespace { 361311116Sdim 362311116Sdimclass PlaceholderQueue { 363311116Sdim // Placeholders would thrash around when moved, so store in a std::deque 364311116Sdim // instead of some sort of vector. 365311116Sdim std::deque<DistinctMDOperandPlaceholder> PHs; 366311116Sdim 367311116Sdimpublic: 368321369Sdim ~PlaceholderQueue() { 369321369Sdim assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed"); 370321369Sdim } 371311544Sdim bool empty() { return PHs.empty(); } 372311116Sdim DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID); 373311116Sdim void flush(BitcodeReaderMetadataList &MetadataList); 374311544Sdim 375311544Sdim /// Return the list of temporaries nodes in the queue, these need to be 376311544Sdim /// loaded before we can flush the queue. 377311544Sdim void getTemporaries(BitcodeReaderMetadataList &MetadataList, 378311544Sdim DenseSet<unsigned> &Temporaries) { 379311544Sdim for (auto &PH : PHs) { 380311544Sdim auto ID = PH.getID(); 381311544Sdim auto *MD = MetadataList.lookup(ID); 382311544Sdim if (!MD) { 383311544Sdim Temporaries.insert(ID); 384311544Sdim continue; 385311544Sdim } 386311544Sdim auto *N = dyn_cast_or_null<MDNode>(MD); 387311544Sdim if (N && N->isTemporary()) 388311544Sdim Temporaries.insert(ID); 389311544Sdim } 390311544Sdim } 391311116Sdim}; 392311116Sdim 393311116Sdim} // end anonymous namespace 394311116Sdim 395311116SdimDistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) { 396311116Sdim PHs.emplace_back(ID); 397311116Sdim return PHs.back(); 398311116Sdim} 399311116Sdim 400311116Sdimvoid PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) { 401311116Sdim while (!PHs.empty()) { 402311116Sdim auto *MD = MetadataList.lookup(PHs.front().getID()); 403311116Sdim assert(MD && "Flushing placeholder on unassigned MD"); 404311116Sdim#ifndef NDEBUG 405311116Sdim if (auto *MDN = dyn_cast<MDNode>(MD)) 406311116Sdim assert(MDN->isResolved() && 407311116Sdim "Flushing Placeholder while cycles aren't resolved"); 408311116Sdim#endif 409311116Sdim PHs.front().replaceUseWith(MD); 410311116Sdim PHs.pop_front(); 411311116Sdim } 412311116Sdim} 413311116Sdim 414360784Sdim} // anonymous namespace 415311116Sdim 416321369Sdimstatic Error error(const Twine &Message) { 417321369Sdim return make_error<StringError>( 418321369Sdim Message, make_error_code(BitcodeError::CorruptedBitcode)); 419321369Sdim} 420321369Sdim 421311116Sdimclass MetadataLoader::MetadataLoaderImpl { 422311116Sdim BitcodeReaderMetadataList MetadataList; 423311116Sdim BitcodeReaderValueList &ValueList; 424311116Sdim BitstreamCursor &Stream; 425311116Sdim LLVMContext &Context; 426311116Sdim Module &TheModule; 427311116Sdim std::function<Type *(unsigned)> getTypeByID; 428311116Sdim 429311544Sdim /// Cursor associated with the lazy-loading of Metadata. This is the easy way 430311544Sdim /// to keep around the right "context" (Abbrev list) to be able to jump in 431311544Sdim /// the middle of the metadata block and load any record. 432311544Sdim BitstreamCursor IndexCursor; 433311544Sdim 434311544Sdim /// Index that keeps track of MDString values. 435311544Sdim std::vector<StringRef> MDStringRef; 436311544Sdim 437311544Sdim /// On-demand loading of a single MDString. Requires the index above to be 438311544Sdim /// populated. 439311544Sdim MDString *lazyLoadOneMDString(unsigned Idx); 440311544Sdim 441311544Sdim /// Index that keeps track of where to find a metadata record in the stream. 442311544Sdim std::vector<uint64_t> GlobalMetadataBitPosIndex; 443311544Sdim 444311544Sdim /// Populate the index above to enable lazily loading of metadata, and load 445311544Sdim /// the named metadata as well as the transitively referenced global 446311544Sdim /// Metadata. 447311833Sdim Expected<bool> lazyLoadModuleMetadataBlock(); 448311544Sdim 449311544Sdim /// On-demand loading of a single metadata. Requires the index above to be 450311544Sdim /// populated. 451311544Sdim void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders); 452311544Sdim 453311116Sdim // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to 454311116Sdim // point from SP to CU after a block is completly parsed. 455311116Sdim std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms; 456311116Sdim 457311116Sdim /// Functions that need to be matched with subprograms when upgrading old 458311116Sdim /// metadata. 459311116Sdim SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs; 460311116Sdim 461311116Sdim // Map the bitcode's custom MDKind ID to the Module's MDKind ID. 462311116Sdim DenseMap<unsigned, unsigned> MDKindMap; 463311116Sdim 464311116Sdim bool StripTBAA = false; 465311116Sdim bool HasSeenOldLoopTags = false; 466313643Sdim bool NeedUpgradeToDIGlobalVariableExpression = false; 467321369Sdim bool NeedDeclareExpressionUpgrade = false; 468311116Sdim 469311116Sdim /// True if metadata is being parsed for a module being ThinLTO imported. 470311116Sdim bool IsImporting = false; 471311116Sdim 472311116Sdim Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code, 473311116Sdim PlaceholderQueue &Placeholders, StringRef Blob, 474311544Sdim unsigned &NextMetadataNo); 475311116Sdim Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob, 476321369Sdim function_ref<void(StringRef)> CallBack); 477311116Sdim Error parseGlobalObjectAttachment(GlobalObject &GO, 478311116Sdim ArrayRef<uint64_t> Record); 479311116Sdim Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record); 480311116Sdim 481311544Sdim void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders); 482311544Sdim 483311544Sdim /// Upgrade old-style CU <-> SP pointers to point from SP to CU. 484311544Sdim void upgradeCUSubprograms() { 485311544Sdim for (auto CU_SP : CUSubprograms) 486311544Sdim if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second)) 487311544Sdim for (auto &Op : SPs->operands()) 488321369Sdim if (auto *SP = dyn_cast_or_null<DISubprogram>(Op)) 489321369Sdim SP->replaceUnit(CU_SP.first); 490311544Sdim CUSubprograms.clear(); 491311544Sdim } 492311544Sdim 493313643Sdim /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions. 494313643Sdim void upgradeCUVariables() { 495313643Sdim if (!NeedUpgradeToDIGlobalVariableExpression) 496313643Sdim return; 497313643Sdim 498313643Sdim // Upgrade list of variables attached to the CUs. 499313643Sdim if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) 500313643Sdim for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) { 501313643Sdim auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I)); 502313643Sdim if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables())) 503313643Sdim for (unsigned I = 0; I < GVs->getNumOperands(); I++) 504313643Sdim if (auto *GV = 505313643Sdim dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) { 506327952Sdim auto *DGVE = DIGlobalVariableExpression::getDistinct( 507327952Sdim Context, GV, DIExpression::get(Context, {})); 508313643Sdim GVs->replaceOperandWith(I, DGVE); 509313643Sdim } 510313643Sdim } 511313643Sdim 512313643Sdim // Upgrade variables attached to globals. 513313643Sdim for (auto &GV : TheModule.globals()) { 514321369Sdim SmallVector<MDNode *, 1> MDs; 515313643Sdim GV.getMetadata(LLVMContext::MD_dbg, MDs); 516313643Sdim GV.eraseMetadata(LLVMContext::MD_dbg); 517313643Sdim for (auto *MD : MDs) 518360784Sdim if (auto *DGV = dyn_cast<DIGlobalVariable>(MD)) { 519327952Sdim auto *DGVE = DIGlobalVariableExpression::getDistinct( 520327952Sdim Context, DGV, DIExpression::get(Context, {})); 521313643Sdim GV.addMetadata(LLVMContext::MD_dbg, *DGVE); 522313643Sdim } else 523313643Sdim GV.addMetadata(LLVMContext::MD_dbg, *MD); 524313643Sdim } 525313643Sdim } 526313643Sdim 527321369Sdim /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that 528321369Sdim /// describes a function argument. 529321369Sdim void upgradeDeclareExpressions(Function &F) { 530321369Sdim if (!NeedDeclareExpressionUpgrade) 531321369Sdim return; 532321369Sdim 533321369Sdim for (auto &BB : F) 534321369Sdim for (auto &I : BB) 535321369Sdim if (auto *DDI = dyn_cast<DbgDeclareInst>(&I)) 536321369Sdim if (auto *DIExpr = DDI->getExpression()) 537321369Sdim if (DIExpr->startsWithDeref() && 538321369Sdim dyn_cast_or_null<Argument>(DDI->getAddress())) { 539321369Sdim SmallVector<uint64_t, 8> Ops; 540321369Sdim Ops.append(std::next(DIExpr->elements_begin()), 541321369Sdim DIExpr->elements_end()); 542321369Sdim auto *E = DIExpression::get(Context, Ops); 543321369Sdim DDI->setOperand(2, MetadataAsValue::get(Context, E)); 544321369Sdim } 545321369Sdim } 546321369Sdim 547321369Sdim /// Upgrade the expression from previous versions. 548321369Sdim Error upgradeDIExpression(uint64_t FromVersion, 549321369Sdim MutableArrayRef<uint64_t> &Expr, 550321369Sdim SmallVectorImpl<uint64_t> &Buffer) { 551321369Sdim auto N = Expr.size(); 552321369Sdim switch (FromVersion) { 553321369Sdim default: 554321369Sdim return error("Invalid record"); 555321369Sdim case 0: 556321369Sdim if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece) 557321369Sdim Expr[N - 3] = dwarf::DW_OP_LLVM_fragment; 558321369Sdim LLVM_FALLTHROUGH; 559321369Sdim case 1: 560321369Sdim // Move DW_OP_deref to the end. 561321369Sdim if (N && Expr[0] == dwarf::DW_OP_deref) { 562321369Sdim auto End = Expr.end(); 563321369Sdim if (Expr.size() >= 3 && 564321369Sdim *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment) 565321369Sdim End = std::prev(End, 3); 566321369Sdim std::move(std::next(Expr.begin()), End, Expr.begin()); 567321369Sdim *std::prev(End) = dwarf::DW_OP_deref; 568321369Sdim } 569321369Sdim NeedDeclareExpressionUpgrade = true; 570321369Sdim LLVM_FALLTHROUGH; 571321369Sdim case 2: { 572321369Sdim // Change DW_OP_plus to DW_OP_plus_uconst. 573321369Sdim // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus 574321369Sdim auto SubExpr = ArrayRef<uint64_t>(Expr); 575321369Sdim while (!SubExpr.empty()) { 576321369Sdim // Skip past other operators with their operands 577321369Sdim // for this version of the IR, obtained from 578321369Sdim // from historic DIExpression::ExprOperand::getSize(). 579321369Sdim size_t HistoricSize; 580321369Sdim switch (SubExpr.front()) { 581321369Sdim default: 582321369Sdim HistoricSize = 1; 583321369Sdim break; 584321369Sdim case dwarf::DW_OP_constu: 585321369Sdim case dwarf::DW_OP_minus: 586321369Sdim case dwarf::DW_OP_plus: 587321369Sdim HistoricSize = 2; 588321369Sdim break; 589321369Sdim case dwarf::DW_OP_LLVM_fragment: 590321369Sdim HistoricSize = 3; 591321369Sdim break; 592321369Sdim } 593321369Sdim 594321369Sdim // If the expression is malformed, make sure we don't 595321369Sdim // copy more elements than we should. 596321369Sdim HistoricSize = std::min(SubExpr.size(), HistoricSize); 597321369Sdim ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1); 598321369Sdim 599321369Sdim switch (SubExpr.front()) { 600321369Sdim case dwarf::DW_OP_plus: 601321369Sdim Buffer.push_back(dwarf::DW_OP_plus_uconst); 602321369Sdim Buffer.append(Args.begin(), Args.end()); 603321369Sdim break; 604321369Sdim case dwarf::DW_OP_minus: 605321369Sdim Buffer.push_back(dwarf::DW_OP_constu); 606321369Sdim Buffer.append(Args.begin(), Args.end()); 607321369Sdim Buffer.push_back(dwarf::DW_OP_minus); 608321369Sdim break; 609321369Sdim default: 610321369Sdim Buffer.push_back(*SubExpr.begin()); 611321369Sdim Buffer.append(Args.begin(), Args.end()); 612321369Sdim break; 613321369Sdim } 614321369Sdim 615321369Sdim // Continue with remaining elements. 616321369Sdim SubExpr = SubExpr.slice(HistoricSize); 617321369Sdim } 618321369Sdim Expr = MutableArrayRef<uint64_t>(Buffer); 619321369Sdim LLVM_FALLTHROUGH; 620321369Sdim } 621321369Sdim case 3: 622321369Sdim // Up-to-date! 623321369Sdim break; 624321369Sdim } 625321369Sdim 626321369Sdim return Error::success(); 627321369Sdim } 628321369Sdim 629313643Sdim void upgradeDebugInfo() { 630313643Sdim upgradeCUSubprograms(); 631313643Sdim upgradeCUVariables(); 632313643Sdim } 633313643Sdim 634311116Sdimpublic: 635311116Sdim MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule, 636311116Sdim BitcodeReaderValueList &ValueList, 637311116Sdim std::function<Type *(unsigned)> getTypeByID, 638311116Sdim bool IsImporting) 639353358Sdim : MetadataList(TheModule.getContext(), Stream.SizeInBytes()), 640353358Sdim ValueList(ValueList), Stream(Stream), Context(TheModule.getContext()), 641353358Sdim TheModule(TheModule), getTypeByID(std::move(getTypeByID)), 642353358Sdim IsImporting(IsImporting) {} 643311116Sdim 644311116Sdim Error parseMetadata(bool ModuleLevel); 645311116Sdim 646311116Sdim bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); } 647312719Sdim 648312719Sdim Metadata *getMetadataFwdRefOrLoad(unsigned ID) { 649312719Sdim if (ID < MDStringRef.size()) 650312719Sdim return lazyLoadOneMDString(ID); 651312719Sdim if (auto *MD = MetadataList.lookup(ID)) 652312719Sdim return MD; 653312719Sdim // If lazy-loading is enabled, we try recursively to load the operand 654312719Sdim // instead of creating a temporary. 655312719Sdim if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { 656312719Sdim PlaceholderQueue Placeholders; 657312719Sdim lazyLoadOneMetadata(ID, Placeholders); 658312719Sdim resolveForwardRefsAndPlaceholders(Placeholders); 659312719Sdim return MetadataList.lookup(ID); 660312719Sdim } 661312719Sdim return MetadataList.getMetadataFwdRef(ID); 662311116Sdim } 663311116Sdim 664311116Sdim DISubprogram *lookupSubprogramForFunction(Function *F) { 665311116Sdim return FunctionsWithSPs.lookup(F); 666311116Sdim } 667311116Sdim 668311116Sdim bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; } 669311116Sdim 670311116Sdim Error parseMetadataAttachment( 671311116Sdim Function &F, const SmallVectorImpl<Instruction *> &InstructionList); 672311116Sdim 673311116Sdim Error parseMetadataKinds(); 674311116Sdim 675311116Sdim void setStripTBAA(bool Value) { StripTBAA = Value; } 676311116Sdim bool isStrippingTBAA() { return StripTBAA; } 677311116Sdim 678311116Sdim unsigned size() const { return MetadataList.size(); } 679311116Sdim void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); } 680321369Sdim void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); } 681311116Sdim}; 682311116Sdim 683311833SdimExpected<bool> 684311833SdimMetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() { 685311544Sdim IndexCursor = Stream; 686311544Sdim SmallVector<uint64_t, 64> Record; 687311544Sdim // Get the abbrevs, and preload record positions to make them lazy-loadable. 688311544Sdim while (true) { 689353358Sdim Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks( 690311544Sdim BitstreamCursor::AF_DontPopBlockAtEnd); 691353358Sdim if (!MaybeEntry) 692353358Sdim return MaybeEntry.takeError(); 693353358Sdim BitstreamEntry Entry = MaybeEntry.get(); 694353358Sdim 695311544Sdim switch (Entry.Kind) { 696311544Sdim case BitstreamEntry::SubBlock: // Handled for us already. 697311544Sdim case BitstreamEntry::Error: 698311544Sdim return error("Malformed block"); 699311544Sdim case BitstreamEntry::EndBlock: { 700311544Sdim return true; 701311544Sdim } 702311544Sdim case BitstreamEntry::Record: { 703311544Sdim // The interesting case. 704311544Sdim ++NumMDRecordLoaded; 705311544Sdim uint64_t CurrentPos = IndexCursor.GetCurrentBitNo(); 706353358Sdim Expected<unsigned> MaybeCode = IndexCursor.skipRecord(Entry.ID); 707353358Sdim if (!MaybeCode) 708353358Sdim return MaybeCode.takeError(); 709353358Sdim unsigned Code = MaybeCode.get(); 710311544Sdim switch (Code) { 711311544Sdim case bitc::METADATA_STRINGS: { 712311544Sdim // Rewind and parse the strings. 713353358Sdim if (Error Err = IndexCursor.JumpToBit(CurrentPos)) 714353358Sdim return std::move(Err); 715311544Sdim StringRef Blob; 716311544Sdim Record.clear(); 717353358Sdim if (Expected<unsigned> MaybeRecord = 718353358Sdim IndexCursor.readRecord(Entry.ID, Record, &Blob)) 719353358Sdim ; 720353358Sdim else 721353358Sdim return MaybeRecord.takeError(); 722311544Sdim unsigned NumStrings = Record[0]; 723311544Sdim MDStringRef.reserve(NumStrings); 724311544Sdim auto IndexNextMDString = [&](StringRef Str) { 725311544Sdim MDStringRef.push_back(Str); 726311544Sdim }; 727311544Sdim if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString)) 728311544Sdim return std::move(Err); 729311544Sdim break; 730311544Sdim } 731311544Sdim case bitc::METADATA_INDEX_OFFSET: { 732311544Sdim // This is the offset to the index, when we see this we skip all the 733311544Sdim // records and load only an index to these. 734353358Sdim if (Error Err = IndexCursor.JumpToBit(CurrentPos)) 735353358Sdim return std::move(Err); 736311544Sdim Record.clear(); 737353358Sdim if (Expected<unsigned> MaybeRecord = 738353358Sdim IndexCursor.readRecord(Entry.ID, Record)) 739353358Sdim ; 740353358Sdim else 741353358Sdim return MaybeRecord.takeError(); 742311544Sdim if (Record.size() != 2) 743311544Sdim return error("Invalid record"); 744311544Sdim auto Offset = Record[0] + (Record[1] << 32); 745311544Sdim auto BeginPos = IndexCursor.GetCurrentBitNo(); 746353358Sdim if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset)) 747353358Sdim return std::move(Err); 748353358Sdim Expected<BitstreamEntry> MaybeEntry = 749353358Sdim IndexCursor.advanceSkippingSubblocks( 750353358Sdim BitstreamCursor::AF_DontPopBlockAtEnd); 751353358Sdim if (!MaybeEntry) 752353358Sdim return MaybeEntry.takeError(); 753353358Sdim Entry = MaybeEntry.get(); 754311544Sdim assert(Entry.Kind == BitstreamEntry::Record && 755311544Sdim "Corrupted bitcode: Expected `Record` when trying to find the " 756311544Sdim "Metadata index"); 757311544Sdim Record.clear(); 758353358Sdim if (Expected<unsigned> MaybeCode = 759353358Sdim IndexCursor.readRecord(Entry.ID, Record)) 760353358Sdim assert(MaybeCode.get() == bitc::METADATA_INDEX && 761353358Sdim "Corrupted bitcode: Expected `METADATA_INDEX` when trying to " 762353358Sdim "find the Metadata index"); 763353358Sdim else 764353358Sdim return MaybeCode.takeError(); 765311544Sdim // Delta unpack 766311544Sdim auto CurrentValue = BeginPos; 767311544Sdim GlobalMetadataBitPosIndex.reserve(Record.size()); 768311544Sdim for (auto &Elt : Record) { 769311544Sdim CurrentValue += Elt; 770311544Sdim GlobalMetadataBitPosIndex.push_back(CurrentValue); 771311544Sdim } 772311544Sdim break; 773311544Sdim } 774311544Sdim case bitc::METADATA_INDEX: 775311544Sdim // We don't expect to get there, the Index is loaded when we encounter 776311544Sdim // the offset. 777311544Sdim return error("Corrupted Metadata block"); 778311544Sdim case bitc::METADATA_NAME: { 779311544Sdim // Named metadata need to be materialized now and aren't deferred. 780353358Sdim if (Error Err = IndexCursor.JumpToBit(CurrentPos)) 781353358Sdim return std::move(Err); 782311544Sdim Record.clear(); 783311544Sdim 784353358Sdim unsigned Code; 785353358Sdim if (Expected<unsigned> MaybeCode = 786353358Sdim IndexCursor.readRecord(Entry.ID, Record)) { 787353358Sdim Code = MaybeCode.get(); 788353358Sdim assert(Code == bitc::METADATA_NAME); 789353358Sdim } else 790353358Sdim return MaybeCode.takeError(); 791353358Sdim 792311544Sdim // Read name of the named metadata. 793311544Sdim SmallString<8> Name(Record.begin(), Record.end()); 794353358Sdim if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode()) 795353358Sdim Code = MaybeCode.get(); 796353358Sdim else 797353358Sdim return MaybeCode.takeError(); 798311544Sdim 799311544Sdim // Named Metadata comes in two parts, we expect the name to be followed 800311544Sdim // by the node 801311544Sdim Record.clear(); 802353358Sdim if (Expected<unsigned> MaybeNextBitCode = 803353358Sdim IndexCursor.readRecord(Code, Record)) 804353358Sdim assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE); 805353358Sdim else 806353358Sdim return MaybeNextBitCode.takeError(); 807311544Sdim 808311544Sdim // Read named metadata elements. 809311544Sdim unsigned Size = Record.size(); 810311544Sdim NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); 811311544Sdim for (unsigned i = 0; i != Size; ++i) { 812311544Sdim // FIXME: We could use a placeholder here, however NamedMDNode are 813311544Sdim // taking MDNode as operand and not using the Metadata infrastructure. 814311544Sdim // It is acknowledged by 'TODO: Inherit from Metadata' in the 815311544Sdim // NamedMDNode class definition. 816311544Sdim MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); 817344779Sdim assert(MD && "Invalid metadata: expect fwd ref to MDNode"); 818311544Sdim NMD->addOperand(MD); 819311544Sdim } 820311544Sdim break; 821311544Sdim } 822311544Sdim case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { 823311544Sdim // FIXME: we need to do this early because we don't materialize global 824311544Sdim // value explicitly. 825353358Sdim if (Error Err = IndexCursor.JumpToBit(CurrentPos)) 826353358Sdim return std::move(Err); 827311544Sdim Record.clear(); 828353358Sdim if (Expected<unsigned> MaybeRecord = 829353358Sdim IndexCursor.readRecord(Entry.ID, Record)) 830353358Sdim ; 831353358Sdim else 832353358Sdim return MaybeRecord.takeError(); 833311544Sdim if (Record.size() % 2 == 0) 834311544Sdim return error("Invalid record"); 835311544Sdim unsigned ValueID = Record[0]; 836311544Sdim if (ValueID >= ValueList.size()) 837311544Sdim return error("Invalid record"); 838311544Sdim if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) 839311544Sdim if (Error Err = parseGlobalObjectAttachment( 840311544Sdim *GO, ArrayRef<uint64_t>(Record).slice(1))) 841311544Sdim return std::move(Err); 842311544Sdim break; 843311544Sdim } 844311544Sdim case bitc::METADATA_KIND: 845311544Sdim case bitc::METADATA_STRING_OLD: 846311544Sdim case bitc::METADATA_OLD_FN_NODE: 847311544Sdim case bitc::METADATA_OLD_NODE: 848311544Sdim case bitc::METADATA_VALUE: 849311544Sdim case bitc::METADATA_DISTINCT_NODE: 850311544Sdim case bitc::METADATA_NODE: 851311544Sdim case bitc::METADATA_LOCATION: 852311544Sdim case bitc::METADATA_GENERIC_DEBUG: 853311544Sdim case bitc::METADATA_SUBRANGE: 854311544Sdim case bitc::METADATA_ENUMERATOR: 855311544Sdim case bitc::METADATA_BASIC_TYPE: 856311544Sdim case bitc::METADATA_DERIVED_TYPE: 857311544Sdim case bitc::METADATA_COMPOSITE_TYPE: 858311544Sdim case bitc::METADATA_SUBROUTINE_TYPE: 859311544Sdim case bitc::METADATA_MODULE: 860311544Sdim case bitc::METADATA_FILE: 861311544Sdim case bitc::METADATA_COMPILE_UNIT: 862311544Sdim case bitc::METADATA_SUBPROGRAM: 863311544Sdim case bitc::METADATA_LEXICAL_BLOCK: 864311544Sdim case bitc::METADATA_LEXICAL_BLOCK_FILE: 865311544Sdim case bitc::METADATA_NAMESPACE: 866353358Sdim case bitc::METADATA_COMMON_BLOCK: 867311544Sdim case bitc::METADATA_MACRO: 868311544Sdim case bitc::METADATA_MACRO_FILE: 869311544Sdim case bitc::METADATA_TEMPLATE_TYPE: 870311544Sdim case bitc::METADATA_TEMPLATE_VALUE: 871311544Sdim case bitc::METADATA_GLOBAL_VAR: 872311544Sdim case bitc::METADATA_LOCAL_VAR: 873341825Sdim case bitc::METADATA_LABEL: 874311544Sdim case bitc::METADATA_EXPRESSION: 875311544Sdim case bitc::METADATA_OBJC_PROPERTY: 876311544Sdim case bitc::METADATA_IMPORTED_ENTITY: 877311544Sdim case bitc::METADATA_GLOBAL_VAR_EXPR: 878311544Sdim // We don't expect to see any of these, if we see one, give up on 879311544Sdim // lazy-loading and fallback. 880311544Sdim MDStringRef.clear(); 881311544Sdim GlobalMetadataBitPosIndex.clear(); 882311544Sdim return false; 883311544Sdim } 884311544Sdim break; 885311544Sdim } 886311544Sdim } 887311544Sdim } 888311544Sdim} 889311544Sdim 890311116Sdim/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing 891311116Sdim/// module level metadata. 892311116SdimError MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) { 893311116Sdim if (!ModuleLevel && MetadataList.hasFwdRefs()) 894311116Sdim return error("Invalid metadata: fwd refs into function blocks"); 895311116Sdim 896311544Sdim // Record the entry position so that we can jump back here and efficiently 897311544Sdim // skip the whole block in case we lazy-load. 898311544Sdim auto EntryPos = Stream.GetCurrentBitNo(); 899311544Sdim 900353358Sdim if (Error Err = Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 901353358Sdim return Err; 902311116Sdim 903311116Sdim SmallVector<uint64_t, 64> Record; 904311116Sdim PlaceholderQueue Placeholders; 905311116Sdim 906311544Sdim // We lazy-load module-level metadata: we build an index for each record, and 907311544Sdim // then load individual record as needed, starting with the named metadata. 908311544Sdim if (ModuleLevel && IsImporting && MetadataList.empty() && 909311544Sdim !DisableLazyLoading) { 910311833Sdim auto SuccessOrErr = lazyLoadModuleMetadataBlock(); 911311544Sdim if (!SuccessOrErr) 912311544Sdim return SuccessOrErr.takeError(); 913311544Sdim if (SuccessOrErr.get()) { 914311544Sdim // An index was successfully created and we will be able to load metadata 915311544Sdim // on-demand. 916311544Sdim MetadataList.resize(MDStringRef.size() + 917311544Sdim GlobalMetadataBitPosIndex.size()); 918311544Sdim 919311544Sdim // Reading the named metadata created forward references and/or 920311544Sdim // placeholders, that we flush here. 921311544Sdim resolveForwardRefsAndPlaceholders(Placeholders); 922313643Sdim upgradeDebugInfo(); 923311544Sdim // Return at the beginning of the block, since it is easy to skip it 924311544Sdim // entirely from there. 925311544Sdim Stream.ReadBlockEnd(); // Pop the abbrev block context. 926353358Sdim if (Error Err = IndexCursor.JumpToBit(EntryPos)) 927353358Sdim return Err; 928353358Sdim if (Error Err = Stream.SkipBlock()) { 929353358Sdim // FIXME this drops the error on the floor, which 930353358Sdim // ThinLTO/X86/debuginfo-cu-import.ll relies on. 931353358Sdim consumeError(std::move(Err)); 932353358Sdim return Error::success(); 933353358Sdim } 934311544Sdim return Error::success(); 935311544Sdim } 936311544Sdim // Couldn't load an index, fallback to loading all the block "old-style". 937311544Sdim } 938311544Sdim 939311544Sdim unsigned NextMetadataNo = MetadataList.size(); 940311544Sdim 941311116Sdim // Read all the records. 942311116Sdim while (true) { 943353358Sdim Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); 944353358Sdim if (!MaybeEntry) 945353358Sdim return MaybeEntry.takeError(); 946353358Sdim BitstreamEntry Entry = MaybeEntry.get(); 947311116Sdim 948311116Sdim switch (Entry.Kind) { 949311116Sdim case BitstreamEntry::SubBlock: // Handled for us already. 950311116Sdim case BitstreamEntry::Error: 951311116Sdim return error("Malformed block"); 952311116Sdim case BitstreamEntry::EndBlock: 953311544Sdim resolveForwardRefsAndPlaceholders(Placeholders); 954313643Sdim upgradeDebugInfo(); 955311116Sdim return Error::success(); 956311116Sdim case BitstreamEntry::Record: 957311116Sdim // The interesting case. 958311116Sdim break; 959311116Sdim } 960311116Sdim 961311116Sdim // Read a record. 962311116Sdim Record.clear(); 963311116Sdim StringRef Blob; 964311544Sdim ++NumMDRecordLoaded; 965353358Sdim if (Expected<unsigned> MaybeCode = 966353358Sdim Stream.readRecord(Entry.ID, Record, &Blob)) { 967353358Sdim if (Error Err = parseOneMetadata(Record, MaybeCode.get(), Placeholders, 968353358Sdim Blob, NextMetadataNo)) 969353358Sdim return Err; 970353358Sdim } else 971353358Sdim return MaybeCode.takeError(); 972311116Sdim } 973311116Sdim} 974311116Sdim 975311544SdimMDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) { 976311544Sdim ++NumMDStringLoaded; 977311544Sdim if (Metadata *MD = MetadataList.lookup(ID)) 978311544Sdim return cast<MDString>(MD); 979311544Sdim auto MDS = MDString::get(Context, MDStringRef[ID]); 980311544Sdim MetadataList.assignValue(MDS, ID); 981311544Sdim return MDS; 982311544Sdim} 983311544Sdim 984311544Sdimvoid MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata( 985311544Sdim unsigned ID, PlaceholderQueue &Placeholders) { 986311544Sdim assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()); 987311544Sdim assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString"); 988311544Sdim // Lookup first if the metadata hasn't already been loaded. 989311544Sdim if (auto *MD = MetadataList.lookup(ID)) { 990360784Sdim auto *N = cast<MDNode>(MD); 991312639Sdim if (!N->isTemporary()) 992312639Sdim return; 993311544Sdim } 994311544Sdim SmallVector<uint64_t, 64> Record; 995311544Sdim StringRef Blob; 996353358Sdim if (Error Err = IndexCursor.JumpToBit( 997353358Sdim GlobalMetadataBitPosIndex[ID - MDStringRef.size()])) 998353358Sdim report_fatal_error("lazyLoadOneMetadata failed jumping: " + 999353358Sdim toString(std::move(Err))); 1000353358Sdim Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks(); 1001353358Sdim if (!MaybeEntry) 1002353358Sdim // FIXME this drops the error on the floor. 1003353358Sdim report_fatal_error("lazyLoadOneMetadata failed advanceSkippingSubblocks: " + 1004353358Sdim toString(MaybeEntry.takeError())); 1005353358Sdim BitstreamEntry Entry = MaybeEntry.get(); 1006311544Sdim ++NumMDRecordLoaded; 1007353358Sdim if (Expected<unsigned> MaybeCode = 1008353358Sdim IndexCursor.readRecord(Entry.ID, Record, &Blob)) { 1009353358Sdim if (Error Err = 1010353358Sdim parseOneMetadata(Record, MaybeCode.get(), Placeholders, Blob, ID)) 1011353358Sdim report_fatal_error("Can't lazyload MD, parseOneMetadata: " + 1012353358Sdim toString(std::move(Err))); 1013353358Sdim } else 1014353358Sdim report_fatal_error("Can't lazyload MD: " + toString(MaybeCode.takeError())); 1015311544Sdim} 1016311544Sdim 1017311544Sdim/// Ensure that all forward-references and placeholders are resolved. 1018311544Sdim/// Iteratively lazy-loading metadata on-demand if needed. 1019311544Sdimvoid MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders( 1020311544Sdim PlaceholderQueue &Placeholders) { 1021311544Sdim DenseSet<unsigned> Temporaries; 1022311544Sdim while (1) { 1023311544Sdim // Populate Temporaries with the placeholders that haven't been loaded yet. 1024311544Sdim Placeholders.getTemporaries(MetadataList, Temporaries); 1025311544Sdim 1026311544Sdim // If we don't have any temporary, or FwdReference, we're done! 1027311544Sdim if (Temporaries.empty() && !MetadataList.hasFwdRefs()) 1028311544Sdim break; 1029311544Sdim 1030311544Sdim // First, load all the temporaries. This can add new placeholders or 1031311544Sdim // forward references. 1032311544Sdim for (auto ID : Temporaries) 1033311544Sdim lazyLoadOneMetadata(ID, Placeholders); 1034311544Sdim Temporaries.clear(); 1035311544Sdim 1036311544Sdim // Second, load the forward-references. This can also add new placeholders 1037311544Sdim // or forward references. 1038311544Sdim while (MetadataList.hasFwdRefs()) 1039311544Sdim lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders); 1040311544Sdim } 1041311544Sdim // At this point we don't have any forward reference remaining, or temporary 1042311544Sdim // that haven't been loaded. We can safely drop RAUW support and mark cycles 1043311544Sdim // as resolved. 1044311544Sdim MetadataList.tryToResolveCycles(); 1045311544Sdim 1046311544Sdim // Finally, everything is in place, we can replace the placeholders operands 1047311544Sdim // with the final node they refer to. 1048311544Sdim Placeholders.flush(MetadataList); 1049311544Sdim} 1050311544Sdim 1051311116SdimError MetadataLoader::MetadataLoaderImpl::parseOneMetadata( 1052311116Sdim SmallVectorImpl<uint64_t> &Record, unsigned Code, 1053311544Sdim PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) { 1054311116Sdim 1055311116Sdim bool IsDistinct = false; 1056311116Sdim auto getMD = [&](unsigned ID) -> Metadata * { 1057311544Sdim if (ID < MDStringRef.size()) 1058311544Sdim return lazyLoadOneMDString(ID); 1059312639Sdim if (!IsDistinct) { 1060312639Sdim if (auto *MD = MetadataList.lookup(ID)) 1061312639Sdim return MD; 1062312639Sdim // If lazy-loading is enabled, we try recursively to load the operand 1063312639Sdim // instead of creating a temporary. 1064312639Sdim if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { 1065312639Sdim // Create a temporary for the node that is referencing the operand we 1066312639Sdim // will lazy-load. It is needed before recursing in case there are 1067312639Sdim // uniquing cycles. 1068312639Sdim MetadataList.getMetadataFwdRef(NextMetadataNo); 1069312639Sdim lazyLoadOneMetadata(ID, Placeholders); 1070312639Sdim return MetadataList.lookup(ID); 1071312639Sdim } 1072312639Sdim // Return a temporary. 1073311116Sdim return MetadataList.getMetadataFwdRef(ID); 1074312639Sdim } 1075311116Sdim if (auto *MD = MetadataList.getMetadataIfResolved(ID)) 1076311116Sdim return MD; 1077311116Sdim return &Placeholders.getPlaceholderOp(ID); 1078311116Sdim }; 1079311116Sdim auto getMDOrNull = [&](unsigned ID) -> Metadata * { 1080311116Sdim if (ID) 1081311116Sdim return getMD(ID - 1); 1082311116Sdim return nullptr; 1083311116Sdim }; 1084311116Sdim auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * { 1085311116Sdim if (ID) 1086311116Sdim return MetadataList.getMetadataFwdRef(ID - 1); 1087311116Sdim return nullptr; 1088311116Sdim }; 1089311116Sdim auto getMDString = [&](unsigned ID) -> MDString * { 1090311116Sdim // This requires that the ID is not really a forward reference. In 1091311116Sdim // particular, the MDString must already have been resolved. 1092311544Sdim auto MDS = getMDOrNull(ID); 1093311544Sdim return cast_or_null<MDString>(MDS); 1094311116Sdim }; 1095311116Sdim 1096311116Sdim // Support for old type refs. 1097311116Sdim auto getDITypeRefOrNull = [&](unsigned ID) { 1098311116Sdim return MetadataList.upgradeTypeRef(getMDOrNull(ID)); 1099311116Sdim }; 1100311116Sdim 1101311116Sdim#define GET_OR_DISTINCT(CLASS, ARGS) \ 1102311116Sdim (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS) 1103311116Sdim 1104311116Sdim switch (Code) { 1105311116Sdim default: // Default behavior: ignore. 1106311116Sdim break; 1107311116Sdim case bitc::METADATA_NAME: { 1108311116Sdim // Read name of the named metadata. 1109311116Sdim SmallString<8> Name(Record.begin(), Record.end()); 1110311116Sdim Record.clear(); 1111353358Sdim Expected<unsigned> MaybeCode = Stream.ReadCode(); 1112353358Sdim if (!MaybeCode) 1113353358Sdim return MaybeCode.takeError(); 1114353358Sdim Code = MaybeCode.get(); 1115311116Sdim 1116311544Sdim ++NumMDRecordLoaded; 1117353358Sdim if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) { 1118353358Sdim if (MaybeNextBitCode.get() != bitc::METADATA_NAMED_NODE) 1119353358Sdim return error("METADATA_NAME not followed by METADATA_NAMED_NODE"); 1120353358Sdim } else 1121353358Sdim return MaybeNextBitCode.takeError(); 1122311116Sdim 1123311116Sdim // Read named metadata elements. 1124311116Sdim unsigned Size = Record.size(); 1125311116Sdim NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); 1126311116Sdim for (unsigned i = 0; i != Size; ++i) { 1127311116Sdim MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); 1128311116Sdim if (!MD) 1129344779Sdim return error("Invalid named metadata: expect fwd ref to MDNode"); 1130311116Sdim NMD->addOperand(MD); 1131311116Sdim } 1132311116Sdim break; 1133311116Sdim } 1134311116Sdim case bitc::METADATA_OLD_FN_NODE: { 1135311116Sdim // FIXME: Remove in 4.0. 1136311116Sdim // This is a LocalAsMetadata record, the only type of function-local 1137311116Sdim // metadata. 1138311116Sdim if (Record.size() % 2 == 1) 1139311116Sdim return error("Invalid record"); 1140311116Sdim 1141311116Sdim // If this isn't a LocalAsMetadata record, we're dropping it. This used 1142311116Sdim // to be legal, but there's no upgrade path. 1143311116Sdim auto dropRecord = [&] { 1144312967Sdim MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo); 1145312967Sdim NextMetadataNo++; 1146311116Sdim }; 1147311116Sdim if (Record.size() != 2) { 1148311116Sdim dropRecord(); 1149311116Sdim break; 1150311116Sdim } 1151311116Sdim 1152311116Sdim Type *Ty = getTypeByID(Record[0]); 1153311116Sdim if (Ty->isMetadataTy() || Ty->isVoidTy()) { 1154311116Sdim dropRecord(); 1155311116Sdim break; 1156311116Sdim } 1157311116Sdim 1158311116Sdim MetadataList.assignValue( 1159311116Sdim LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), 1160312967Sdim NextMetadataNo); 1161312967Sdim NextMetadataNo++; 1162311116Sdim break; 1163311116Sdim } 1164311116Sdim case bitc::METADATA_OLD_NODE: { 1165311116Sdim // FIXME: Remove in 4.0. 1166311116Sdim if (Record.size() % 2 == 1) 1167311116Sdim return error("Invalid record"); 1168311116Sdim 1169311116Sdim unsigned Size = Record.size(); 1170311116Sdim SmallVector<Metadata *, 8> Elts; 1171311116Sdim for (unsigned i = 0; i != Size; i += 2) { 1172311116Sdim Type *Ty = getTypeByID(Record[i]); 1173311116Sdim if (!Ty) 1174311116Sdim return error("Invalid record"); 1175311116Sdim if (Ty->isMetadataTy()) 1176311116Sdim Elts.push_back(getMD(Record[i + 1])); 1177311116Sdim else if (!Ty->isVoidTy()) { 1178311116Sdim auto *MD = 1179311116Sdim ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty)); 1180311116Sdim assert(isa<ConstantAsMetadata>(MD) && 1181311116Sdim "Expected non-function-local metadata"); 1182311116Sdim Elts.push_back(MD); 1183311116Sdim } else 1184311116Sdim Elts.push_back(nullptr); 1185311116Sdim } 1186312967Sdim MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo); 1187312967Sdim NextMetadataNo++; 1188311116Sdim break; 1189311116Sdim } 1190311116Sdim case bitc::METADATA_VALUE: { 1191311116Sdim if (Record.size() != 2) 1192311116Sdim return error("Invalid record"); 1193311116Sdim 1194311116Sdim Type *Ty = getTypeByID(Record[0]); 1195311116Sdim if (Ty->isMetadataTy() || Ty->isVoidTy()) 1196311116Sdim return error("Invalid record"); 1197311116Sdim 1198311116Sdim MetadataList.assignValue( 1199311116Sdim ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), 1200312967Sdim NextMetadataNo); 1201312967Sdim NextMetadataNo++; 1202311116Sdim break; 1203311116Sdim } 1204311116Sdim case bitc::METADATA_DISTINCT_NODE: 1205311116Sdim IsDistinct = true; 1206311116Sdim LLVM_FALLTHROUGH; 1207311116Sdim case bitc::METADATA_NODE: { 1208311116Sdim SmallVector<Metadata *, 8> Elts; 1209311116Sdim Elts.reserve(Record.size()); 1210311116Sdim for (unsigned ID : Record) 1211311116Sdim Elts.push_back(getMDOrNull(ID)); 1212311116Sdim MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts) 1213311116Sdim : MDNode::get(Context, Elts), 1214312967Sdim NextMetadataNo); 1215312967Sdim NextMetadataNo++; 1216311116Sdim break; 1217311116Sdim } 1218311116Sdim case bitc::METADATA_LOCATION: { 1219344779Sdim if (Record.size() != 5 && Record.size() != 6) 1220311116Sdim return error("Invalid record"); 1221311116Sdim 1222311116Sdim IsDistinct = Record[0]; 1223311116Sdim unsigned Line = Record[1]; 1224311116Sdim unsigned Column = Record[2]; 1225311116Sdim Metadata *Scope = getMD(Record[3]); 1226311116Sdim Metadata *InlinedAt = getMDOrNull(Record[4]); 1227344779Sdim bool ImplicitCode = Record.size() == 6 && Record[5]; 1228311116Sdim MetadataList.assignValue( 1229344779Sdim GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt, 1230344779Sdim ImplicitCode)), 1231312967Sdim NextMetadataNo); 1232312967Sdim NextMetadataNo++; 1233311116Sdim break; 1234311116Sdim } 1235311116Sdim case bitc::METADATA_GENERIC_DEBUG: { 1236311116Sdim if (Record.size() < 4) 1237311116Sdim return error("Invalid record"); 1238311116Sdim 1239311116Sdim IsDistinct = Record[0]; 1240311116Sdim unsigned Tag = Record[1]; 1241311116Sdim unsigned Version = Record[2]; 1242311116Sdim 1243311116Sdim if (Tag >= 1u << 16 || Version != 0) 1244311116Sdim return error("Invalid record"); 1245311116Sdim 1246311116Sdim auto *Header = getMDString(Record[3]); 1247311116Sdim SmallVector<Metadata *, 8> DwarfOps; 1248311116Sdim for (unsigned I = 4, E = Record.size(); I != E; ++I) 1249311116Sdim DwarfOps.push_back(getMDOrNull(Record[I])); 1250311116Sdim MetadataList.assignValue( 1251311116Sdim GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)), 1252312967Sdim NextMetadataNo); 1253312967Sdim NextMetadataNo++; 1254311116Sdim break; 1255311116Sdim } 1256311116Sdim case bitc::METADATA_SUBRANGE: { 1257341825Sdim Metadata *Val = nullptr; 1258341825Sdim // Operand 'count' is interpreted as: 1259341825Sdim // - Signed integer (version 0) 1260341825Sdim // - Metadata node (version 1) 1261341825Sdim switch (Record[0] >> 1) { 1262341825Sdim case 0: 1263341825Sdim Val = GET_OR_DISTINCT(DISubrange, 1264341825Sdim (Context, Record[1], unrotateSign(Record.back()))); 1265341825Sdim break; 1266341825Sdim case 1: 1267341825Sdim Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]), 1268341825Sdim unrotateSign(Record.back()))); 1269341825Sdim break; 1270341825Sdim default: 1271341825Sdim return error("Invalid record: Unsupported version of DISubrange"); 1272341825Sdim } 1273311116Sdim 1274341825Sdim MetadataList.assignValue(Val, NextMetadataNo); 1275341825Sdim IsDistinct = Record[0] & 1; 1276312967Sdim NextMetadataNo++; 1277311116Sdim break; 1278311116Sdim } 1279311116Sdim case bitc::METADATA_ENUMERATOR: { 1280311116Sdim if (Record.size() != 3) 1281311116Sdim return error("Invalid record"); 1282311116Sdim 1283341825Sdim IsDistinct = Record[0] & 1; 1284341825Sdim bool IsUnsigned = Record[0] & 2; 1285311116Sdim MetadataList.assignValue( 1286311116Sdim GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]), 1287341825Sdim IsUnsigned, getMDString(Record[2]))), 1288312967Sdim NextMetadataNo); 1289312967Sdim NextMetadataNo++; 1290311116Sdim break; 1291311116Sdim } 1292311116Sdim case bitc::METADATA_BASIC_TYPE: { 1293344779Sdim if (Record.size() < 6 || Record.size() > 7) 1294311116Sdim return error("Invalid record"); 1295311116Sdim 1296311116Sdim IsDistinct = Record[0]; 1297344779Sdim DINode::DIFlags Flags = (Record.size() > 6) ? 1298344779Sdim static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero; 1299344779Sdim 1300311116Sdim MetadataList.assignValue( 1301311116Sdim GET_OR_DISTINCT(DIBasicType, 1302311116Sdim (Context, Record[1], getMDString(Record[2]), Record[3], 1303344779Sdim Record[4], Record[5], Flags)), 1304312967Sdim NextMetadataNo); 1305312967Sdim NextMetadataNo++; 1306311116Sdim break; 1307311116Sdim } 1308311116Sdim case bitc::METADATA_DERIVED_TYPE: { 1309321369Sdim if (Record.size() < 12 || Record.size() > 13) 1310311116Sdim return error("Invalid record"); 1311311116Sdim 1312321369Sdim // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means 1313321369Sdim // that there is no DWARF address space associated with DIDerivedType. 1314321369Sdim Optional<unsigned> DWARFAddressSpace; 1315321369Sdim if (Record.size() > 12 && Record[12]) 1316321369Sdim DWARFAddressSpace = Record[12] - 1; 1317321369Sdim 1318311116Sdim IsDistinct = Record[0]; 1319311116Sdim DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); 1320311116Sdim MetadataList.assignValue( 1321311116Sdim GET_OR_DISTINCT(DIDerivedType, 1322311116Sdim (Context, Record[1], getMDString(Record[2]), 1323311116Sdim getMDOrNull(Record[3]), Record[4], 1324311116Sdim getDITypeRefOrNull(Record[5]), 1325311116Sdim getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1326321369Sdim Record[9], DWARFAddressSpace, Flags, 1327321369Sdim getDITypeRefOrNull(Record[11]))), 1328312967Sdim NextMetadataNo); 1329312967Sdim NextMetadataNo++; 1330311116Sdim break; 1331311116Sdim } 1332311116Sdim case bitc::METADATA_COMPOSITE_TYPE: { 1333341825Sdim if (Record.size() < 16 || Record.size() > 17) 1334311116Sdim return error("Invalid record"); 1335311116Sdim 1336311116Sdim // If we have a UUID and this is not a forward declaration, lookup the 1337311116Sdim // mapping. 1338311116Sdim IsDistinct = Record[0] & 0x1; 1339311116Sdim bool IsNotUsedInTypeRef = Record[0] >= 2; 1340311116Sdim unsigned Tag = Record[1]; 1341311116Sdim MDString *Name = getMDString(Record[2]); 1342311116Sdim Metadata *File = getMDOrNull(Record[3]); 1343311116Sdim unsigned Line = Record[4]; 1344311116Sdim Metadata *Scope = getDITypeRefOrNull(Record[5]); 1345311116Sdim Metadata *BaseType = nullptr; 1346311116Sdim uint64_t SizeInBits = Record[7]; 1347311116Sdim if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1348311116Sdim return error("Alignment value is too large"); 1349311116Sdim uint32_t AlignInBits = Record[8]; 1350311116Sdim uint64_t OffsetInBits = 0; 1351311116Sdim DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); 1352311116Sdim Metadata *Elements = nullptr; 1353311116Sdim unsigned RuntimeLang = Record[12]; 1354311116Sdim Metadata *VTableHolder = nullptr; 1355311116Sdim Metadata *TemplateParams = nullptr; 1356341825Sdim Metadata *Discriminator = nullptr; 1357311116Sdim auto *Identifier = getMDString(Record[15]); 1358311116Sdim // If this module is being parsed so that it can be ThinLTO imported 1359311116Sdim // into another module, composite types only need to be imported 1360311116Sdim // as type declarations (unless full type definitions requested). 1361311116Sdim // Create type declarations up front to save memory. Also, buildODRType 1362311116Sdim // handles the case where this is type ODRed with a definition needed 1363311116Sdim // by the importing module, in which case the existing definition is 1364311116Sdim // used. 1365311327Sdim if (IsImporting && !ImportFullTypeDefinitions && Identifier && 1366311116Sdim (Tag == dwarf::DW_TAG_enumeration_type || 1367311116Sdim Tag == dwarf::DW_TAG_class_type || 1368311116Sdim Tag == dwarf::DW_TAG_structure_type || 1369311116Sdim Tag == dwarf::DW_TAG_union_type)) { 1370311116Sdim Flags = Flags | DINode::FlagFwdDecl; 1371311116Sdim } else { 1372311116Sdim BaseType = getDITypeRefOrNull(Record[6]); 1373311116Sdim OffsetInBits = Record[9]; 1374311116Sdim Elements = getMDOrNull(Record[11]); 1375311116Sdim VTableHolder = getDITypeRefOrNull(Record[13]); 1376311116Sdim TemplateParams = getMDOrNull(Record[14]); 1377341825Sdim if (Record.size() > 16) 1378341825Sdim Discriminator = getMDOrNull(Record[16]); 1379311116Sdim } 1380311116Sdim DICompositeType *CT = nullptr; 1381311116Sdim if (Identifier) 1382311116Sdim CT = DICompositeType::buildODRType( 1383311116Sdim Context, *Identifier, Tag, Name, File, Line, Scope, BaseType, 1384311116Sdim SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 1385341825Sdim VTableHolder, TemplateParams, Discriminator); 1386311116Sdim 1387311116Sdim // Create a node if we didn't get a lazy ODR type. 1388311116Sdim if (!CT) 1389311116Sdim CT = GET_OR_DISTINCT(DICompositeType, 1390311116Sdim (Context, Tag, Name, File, Line, Scope, BaseType, 1391311116Sdim SizeInBits, AlignInBits, OffsetInBits, Flags, 1392311116Sdim Elements, RuntimeLang, VTableHolder, TemplateParams, 1393344779Sdim Identifier, Discriminator)); 1394311116Sdim if (!IsNotUsedInTypeRef && Identifier) 1395311116Sdim MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT)); 1396311116Sdim 1397312967Sdim MetadataList.assignValue(CT, NextMetadataNo); 1398312967Sdim NextMetadataNo++; 1399311116Sdim break; 1400311116Sdim } 1401311116Sdim case bitc::METADATA_SUBROUTINE_TYPE: { 1402311116Sdim if (Record.size() < 3 || Record.size() > 4) 1403311116Sdim return error("Invalid record"); 1404311116Sdim bool IsOldTypeRefArray = Record[0] < 2; 1405311116Sdim unsigned CC = (Record.size() > 3) ? Record[3] : 0; 1406311116Sdim 1407311116Sdim IsDistinct = Record[0] & 0x1; 1408311116Sdim DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]); 1409311116Sdim Metadata *Types = getMDOrNull(Record[2]); 1410311116Sdim if (LLVM_UNLIKELY(IsOldTypeRefArray)) 1411311116Sdim Types = MetadataList.upgradeTypeRefArray(Types); 1412311116Sdim 1413311116Sdim MetadataList.assignValue( 1414311116Sdim GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)), 1415312967Sdim NextMetadataNo); 1416312967Sdim NextMetadataNo++; 1417311116Sdim break; 1418311116Sdim } 1419311116Sdim 1420311116Sdim case bitc::METADATA_MODULE: { 1421311116Sdim if (Record.size() != 6) 1422311116Sdim return error("Invalid record"); 1423311116Sdim 1424311116Sdim IsDistinct = Record[0]; 1425311116Sdim MetadataList.assignValue( 1426311116Sdim GET_OR_DISTINCT(DIModule, 1427311116Sdim (Context, getMDOrNull(Record[1]), 1428311116Sdim getMDString(Record[2]), getMDString(Record[3]), 1429311116Sdim getMDString(Record[4]), getMDString(Record[5]))), 1430312967Sdim NextMetadataNo); 1431312967Sdim NextMetadataNo++; 1432311116Sdim break; 1433311116Sdim } 1434311116Sdim 1435311116Sdim case bitc::METADATA_FILE: { 1436341825Sdim if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6) 1437311116Sdim return error("Invalid record"); 1438311116Sdim 1439311116Sdim IsDistinct = Record[0]; 1440341825Sdim Optional<DIFile::ChecksumInfo<MDString *>> Checksum; 1441341825Sdim // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum 1442341825Sdim // is not present. This matches up with the old internal representation, 1443341825Sdim // and the old encoding for CSK_None in the ChecksumKind. The new 1444341825Sdim // representation reserves the value 0 in the ChecksumKind to continue to 1445341825Sdim // encode None in a backwards-compatible way. 1446341825Sdim if (Record.size() > 4 && Record[3] && Record[4]) 1447341825Sdim Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]), 1448341825Sdim getMDString(Record[4])); 1449311116Sdim MetadataList.assignValue( 1450311116Sdim GET_OR_DISTINCT( 1451311116Sdim DIFile, 1452341825Sdim (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum, 1453341825Sdim Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5])) 1454341825Sdim : None)), 1455312967Sdim NextMetadataNo); 1456312967Sdim NextMetadataNo++; 1457311116Sdim break; 1458311116Sdim } 1459311116Sdim case bitc::METADATA_COMPILE_UNIT: { 1460327952Sdim if (Record.size() < 14 || Record.size() > 19) 1461311116Sdim return error("Invalid record"); 1462311116Sdim 1463311116Sdim // Ignore Record[0], which indicates whether this compile unit is 1464311116Sdim // distinct. It's always distinct. 1465311116Sdim IsDistinct = true; 1466311116Sdim auto *CU = DICompileUnit::getDistinct( 1467311116Sdim Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]), 1468311116Sdim Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]), 1469311116Sdim Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]), 1470311116Sdim getMDOrNull(Record[12]), getMDOrNull(Record[13]), 1471311116Sdim Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]), 1472311116Sdim Record.size() <= 14 ? 0 : Record[14], 1473321369Sdim Record.size() <= 16 ? true : Record[16], 1474327952Sdim Record.size() <= 17 ? false : Record[17], 1475344779Sdim Record.size() <= 18 ? 0 : Record[18], 1476344779Sdim Record.size() <= 19 ? 0 : Record[19]); 1477311116Sdim 1478312967Sdim MetadataList.assignValue(CU, NextMetadataNo); 1479312967Sdim NextMetadataNo++; 1480311116Sdim 1481311116Sdim // Move the Upgrade the list of subprograms. 1482311116Sdim if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11])) 1483311116Sdim CUSubprograms.push_back({CU, SPs}); 1484311116Sdim break; 1485311116Sdim } 1486311116Sdim case bitc::METADATA_SUBPROGRAM: { 1487321369Sdim if (Record.size() < 18 || Record.size() > 21) 1488311116Sdim return error("Invalid record"); 1489311116Sdim 1490344779Sdim bool HasSPFlags = Record[0] & 4; 1491344779Sdim 1492353358Sdim DINode::DIFlags Flags; 1493353358Sdim DISubprogram::DISPFlags SPFlags; 1494353358Sdim if (!HasSPFlags) 1495353358Sdim Flags = static_cast<DINode::DIFlags>(Record[11 + 2]); 1496353358Sdim else { 1497353358Sdim Flags = static_cast<DINode::DIFlags>(Record[11]); 1498353358Sdim SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]); 1499353358Sdim } 1500353358Sdim 1501353358Sdim // Support for old metadata when 1502353358Sdim // subprogram specific flags are placed in DIFlags. 1503353358Sdim const unsigned DIFlagMainSubprogram = 1 << 21; 1504353358Sdim bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram; 1505353358Sdim if (HasOldMainSubprogramFlag) 1506353358Sdim // Remove old DIFlagMainSubprogram from DIFlags. 1507353358Sdim // Note: This assumes that any future use of bit 21 defaults to it 1508353358Sdim // being 0. 1509353358Sdim Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram); 1510353358Sdim 1511353358Sdim if (HasOldMainSubprogramFlag && HasSPFlags) 1512353358Sdim SPFlags |= DISubprogram::SPFlagMainSubprogram; 1513353358Sdim else if (!HasSPFlags) 1514353358Sdim SPFlags = DISubprogram::toSPFlags( 1515353358Sdim /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8], 1516353358Sdim /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11], 1517353358Sdim /*DIFlagMainSubprogram*/HasOldMainSubprogramFlag); 1518353358Sdim 1519344779Sdim // All definitions should be distinct. 1520344779Sdim IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition); 1521311116Sdim // Version 1 has a Function as Record[15]. 1522311116Sdim // Version 2 has removed Record[15]. 1523311116Sdim // Version 3 has the Unit as Record[15]. 1524311116Sdim // Version 4 added thisAdjustment. 1525344779Sdim // Version 5 repacked flags into DISPFlags, changing many element numbers. 1526344779Sdim bool HasUnit = Record[0] & 2; 1527344779Sdim if (!HasSPFlags && HasUnit && Record.size() < 19) 1528311116Sdim return error("Invalid record"); 1529344779Sdim if (HasSPFlags && !HasUnit) 1530344779Sdim return error("Invalid record"); 1531344779Sdim // Accommodate older formats. 1532344779Sdim bool HasFn = false; 1533344779Sdim bool HasThisAdj = true; 1534344779Sdim bool HasThrownTypes = true; 1535344779Sdim unsigned OffsetA = 0; 1536344779Sdim unsigned OffsetB = 0; 1537344779Sdim if (!HasSPFlags) { 1538344779Sdim OffsetA = 2; 1539344779Sdim OffsetB = 2; 1540344779Sdim if (Record.size() >= 19) { 1541344779Sdim HasFn = !HasUnit; 1542344779Sdim OffsetB++; 1543344779Sdim } 1544344779Sdim HasThisAdj = Record.size() >= 20; 1545344779Sdim HasThrownTypes = Record.size() >= 21; 1546344779Sdim } 1547344779Sdim Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]); 1548311116Sdim DISubprogram *SP = GET_OR_DISTINCT( 1549321369Sdim DISubprogram, 1550321369Sdim (Context, 1551321369Sdim getDITypeRefOrNull(Record[1]), // scope 1552321369Sdim getMDString(Record[2]), // name 1553321369Sdim getMDString(Record[3]), // linkageName 1554321369Sdim getMDOrNull(Record[4]), // file 1555321369Sdim Record[5], // line 1556321369Sdim getMDOrNull(Record[6]), // type 1557344779Sdim Record[7 + OffsetA], // scopeLine 1558344779Sdim getDITypeRefOrNull(Record[8 + OffsetA]), // containingType 1559344779Sdim Record[10 + OffsetA], // virtualIndex 1560344779Sdim HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment 1561353358Sdim Flags, // flags 1562344779Sdim SPFlags, // SPFlags 1563321369Sdim HasUnit ? CUorFn : nullptr, // unit 1564344779Sdim getMDOrNull(Record[13 + OffsetB]), // templateParams 1565344779Sdim getMDOrNull(Record[14 + OffsetB]), // declaration 1566344779Sdim getMDOrNull(Record[15 + OffsetB]), // retainedNodes 1567344779Sdim HasThrownTypes ? getMDOrNull(Record[17 + OffsetB]) 1568344779Sdim : nullptr // thrownTypes 1569321369Sdim )); 1570312967Sdim MetadataList.assignValue(SP, NextMetadataNo); 1571312967Sdim NextMetadataNo++; 1572311116Sdim 1573311116Sdim // Upgrade sp->function mapping to function->sp mapping. 1574311116Sdim if (HasFn) { 1575311116Sdim if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn)) 1576311116Sdim if (auto *F = dyn_cast<Function>(CMD->getValue())) { 1577311116Sdim if (F->isMaterializable()) 1578311116Sdim // Defer until materialized; unmaterialized functions may not have 1579311116Sdim // metadata. 1580311116Sdim FunctionsWithSPs[F] = SP; 1581311116Sdim else if (!F->empty()) 1582311116Sdim F->setSubprogram(SP); 1583311116Sdim } 1584311116Sdim } 1585311116Sdim break; 1586311116Sdim } 1587311116Sdim case bitc::METADATA_LEXICAL_BLOCK: { 1588311116Sdim if (Record.size() != 5) 1589311116Sdim return error("Invalid record"); 1590311116Sdim 1591311116Sdim IsDistinct = Record[0]; 1592311116Sdim MetadataList.assignValue( 1593311116Sdim GET_OR_DISTINCT(DILexicalBlock, 1594311116Sdim (Context, getMDOrNull(Record[1]), 1595311116Sdim getMDOrNull(Record[2]), Record[3], Record[4])), 1596312967Sdim NextMetadataNo); 1597312967Sdim NextMetadataNo++; 1598311116Sdim break; 1599311116Sdim } 1600311116Sdim case bitc::METADATA_LEXICAL_BLOCK_FILE: { 1601311116Sdim if (Record.size() != 4) 1602311116Sdim return error("Invalid record"); 1603311116Sdim 1604311116Sdim IsDistinct = Record[0]; 1605311116Sdim MetadataList.assignValue( 1606311116Sdim GET_OR_DISTINCT(DILexicalBlockFile, 1607311116Sdim (Context, getMDOrNull(Record[1]), 1608311116Sdim getMDOrNull(Record[2]), Record[3])), 1609312967Sdim NextMetadataNo); 1610312967Sdim NextMetadataNo++; 1611311116Sdim break; 1612311116Sdim } 1613353358Sdim case bitc::METADATA_COMMON_BLOCK: { 1614353358Sdim IsDistinct = Record[0] & 1; 1615353358Sdim MetadataList.assignValue( 1616353358Sdim GET_OR_DISTINCT(DICommonBlock, 1617353358Sdim (Context, getMDOrNull(Record[1]), 1618353358Sdim getMDOrNull(Record[2]), getMDString(Record[3]), 1619353358Sdim getMDOrNull(Record[4]), Record[5])), 1620353358Sdim NextMetadataNo); 1621353358Sdim NextMetadataNo++; 1622353358Sdim break; 1623353358Sdim } 1624311116Sdim case bitc::METADATA_NAMESPACE: { 1625321369Sdim // Newer versions of DINamespace dropped file and line. 1626321369Sdim MDString *Name; 1627321369Sdim if (Record.size() == 3) 1628321369Sdim Name = getMDString(Record[2]); 1629321369Sdim else if (Record.size() == 5) 1630321369Sdim Name = getMDString(Record[3]); 1631321369Sdim else 1632311116Sdim return error("Invalid record"); 1633311116Sdim 1634311116Sdim IsDistinct = Record[0] & 1; 1635311116Sdim bool ExportSymbols = Record[0] & 2; 1636311116Sdim MetadataList.assignValue( 1637311116Sdim GET_OR_DISTINCT(DINamespace, 1638321369Sdim (Context, getMDOrNull(Record[1]), Name, ExportSymbols)), 1639312967Sdim NextMetadataNo); 1640312967Sdim NextMetadataNo++; 1641311116Sdim break; 1642311116Sdim } 1643311116Sdim case bitc::METADATA_MACRO: { 1644311116Sdim if (Record.size() != 5) 1645311116Sdim return error("Invalid record"); 1646311116Sdim 1647311116Sdim IsDistinct = Record[0]; 1648311116Sdim MetadataList.assignValue( 1649311116Sdim GET_OR_DISTINCT(DIMacro, 1650311116Sdim (Context, Record[1], Record[2], getMDString(Record[3]), 1651311116Sdim getMDString(Record[4]))), 1652312967Sdim NextMetadataNo); 1653312967Sdim NextMetadataNo++; 1654311116Sdim break; 1655311116Sdim } 1656311116Sdim case bitc::METADATA_MACRO_FILE: { 1657311116Sdim if (Record.size() != 5) 1658311116Sdim return error("Invalid record"); 1659311116Sdim 1660311116Sdim IsDistinct = Record[0]; 1661311116Sdim MetadataList.assignValue( 1662311116Sdim GET_OR_DISTINCT(DIMacroFile, 1663311116Sdim (Context, Record[1], Record[2], getMDOrNull(Record[3]), 1664311116Sdim getMDOrNull(Record[4]))), 1665312967Sdim NextMetadataNo); 1666312967Sdim NextMetadataNo++; 1667311116Sdim break; 1668311116Sdim } 1669311116Sdim case bitc::METADATA_TEMPLATE_TYPE: { 1670311116Sdim if (Record.size() != 3) 1671311116Sdim return error("Invalid record"); 1672311116Sdim 1673311116Sdim IsDistinct = Record[0]; 1674311116Sdim MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter, 1675311116Sdim (Context, getMDString(Record[1]), 1676311116Sdim getDITypeRefOrNull(Record[2]))), 1677312967Sdim NextMetadataNo); 1678312967Sdim NextMetadataNo++; 1679311116Sdim break; 1680311116Sdim } 1681311116Sdim case bitc::METADATA_TEMPLATE_VALUE: { 1682311116Sdim if (Record.size() != 5) 1683311116Sdim return error("Invalid record"); 1684311116Sdim 1685311116Sdim IsDistinct = Record[0]; 1686311116Sdim MetadataList.assignValue( 1687311116Sdim GET_OR_DISTINCT(DITemplateValueParameter, 1688311116Sdim (Context, Record[1], getMDString(Record[2]), 1689311116Sdim getDITypeRefOrNull(Record[3]), 1690311116Sdim getMDOrNull(Record[4]))), 1691312967Sdim NextMetadataNo); 1692312967Sdim NextMetadataNo++; 1693311116Sdim break; 1694311116Sdim } 1695311116Sdim case bitc::METADATA_GLOBAL_VAR: { 1696344779Sdim if (Record.size() < 11 || Record.size() > 13) 1697311116Sdim return error("Invalid record"); 1698311116Sdim 1699311116Sdim IsDistinct = Record[0] & 1; 1700311116Sdim unsigned Version = Record[0] >> 1; 1701311116Sdim 1702344779Sdim if (Version == 2) { 1703311116Sdim MetadataList.assignValue( 1704344779Sdim GET_OR_DISTINCT( 1705344779Sdim DIGlobalVariable, 1706344779Sdim (Context, getMDOrNull(Record[1]), getMDString(Record[2]), 1707344779Sdim getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], 1708344779Sdim getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1709344779Sdim getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])), 1710344779Sdim NextMetadataNo); 1711344779Sdim 1712344779Sdim NextMetadataNo++; 1713344779Sdim } else if (Version == 1) { 1714344779Sdim // No upgrade necessary. A null field will be introduced to indicate 1715344779Sdim // that no parameter information is available. 1716344779Sdim MetadataList.assignValue( 1717311116Sdim GET_OR_DISTINCT(DIGlobalVariable, 1718311116Sdim (Context, getMDOrNull(Record[1]), 1719311116Sdim getMDString(Record[2]), getMDString(Record[3]), 1720311116Sdim getMDOrNull(Record[4]), Record[5], 1721311116Sdim getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1722344779Sdim getMDOrNull(Record[10]), nullptr, Record[11])), 1723312967Sdim NextMetadataNo); 1724344779Sdim 1725312967Sdim NextMetadataNo++; 1726311116Sdim } else if (Version == 0) { 1727311116Sdim // Upgrade old metadata, which stored a global variable reference or a 1728311116Sdim // ConstantInt here. 1729321369Sdim NeedUpgradeToDIGlobalVariableExpression = true; 1730311116Sdim Metadata *Expr = getMDOrNull(Record[9]); 1731311116Sdim uint32_t AlignInBits = 0; 1732311116Sdim if (Record.size() > 11) { 1733311116Sdim if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1734311116Sdim return error("Alignment value is too large"); 1735311116Sdim AlignInBits = Record[11]; 1736311116Sdim } 1737311116Sdim GlobalVariable *Attach = nullptr; 1738311116Sdim if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) { 1739311116Sdim if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) { 1740311116Sdim Attach = GV; 1741311116Sdim Expr = nullptr; 1742311116Sdim } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) { 1743311116Sdim Expr = DIExpression::get(Context, 1744311116Sdim {dwarf::DW_OP_constu, CI->getZExtValue(), 1745311116Sdim dwarf::DW_OP_stack_value}); 1746311116Sdim } else { 1747311116Sdim Expr = nullptr; 1748311116Sdim } 1749311116Sdim } 1750311116Sdim DIGlobalVariable *DGV = GET_OR_DISTINCT( 1751311116Sdim DIGlobalVariable, 1752311116Sdim (Context, getMDOrNull(Record[1]), getMDString(Record[2]), 1753311116Sdim getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], 1754311116Sdim getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1755344779Sdim getMDOrNull(Record[10]), nullptr, AlignInBits)); 1756311116Sdim 1757313643Sdim DIGlobalVariableExpression *DGVE = nullptr; 1758313643Sdim if (Attach || Expr) 1759327952Sdim DGVE = DIGlobalVariableExpression::getDistinct( 1760327952Sdim Context, DGV, Expr ? Expr : DIExpression::get(Context, {})); 1761311116Sdim if (Attach) 1762311116Sdim Attach->addDebugInfo(DGVE); 1763313643Sdim 1764313643Sdim auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV); 1765313643Sdim MetadataList.assignValue(MDNode, NextMetadataNo); 1766313643Sdim NextMetadataNo++; 1767311116Sdim } else 1768311116Sdim return error("Invalid record"); 1769311116Sdim 1770311116Sdim break; 1771311116Sdim } 1772311116Sdim case bitc::METADATA_LOCAL_VAR: { 1773311116Sdim // 10th field is for the obseleted 'inlinedAt:' field. 1774311116Sdim if (Record.size() < 8 || Record.size() > 10) 1775311116Sdim return error("Invalid record"); 1776311116Sdim 1777311116Sdim IsDistinct = Record[0] & 1; 1778311116Sdim bool HasAlignment = Record[0] & 2; 1779311116Sdim // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or 1780311116Sdim // DW_TAG_arg_variable, if we have alignment flag encoded it means, that 1781321369Sdim // this is newer version of record which doesn't have artificial tag. 1782311116Sdim bool HasTag = !HasAlignment && Record.size() > 8; 1783311116Sdim DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]); 1784311116Sdim uint32_t AlignInBits = 0; 1785311116Sdim if (HasAlignment) { 1786311116Sdim if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1787311116Sdim return error("Alignment value is too large"); 1788311116Sdim AlignInBits = Record[8 + HasTag]; 1789311116Sdim } 1790311116Sdim MetadataList.assignValue( 1791311116Sdim GET_OR_DISTINCT(DILocalVariable, 1792311116Sdim (Context, getMDOrNull(Record[1 + HasTag]), 1793311116Sdim getMDString(Record[2 + HasTag]), 1794311116Sdim getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag], 1795311116Sdim getDITypeRefOrNull(Record[5 + HasTag]), 1796311116Sdim Record[6 + HasTag], Flags, AlignInBits)), 1797312967Sdim NextMetadataNo); 1798312967Sdim NextMetadataNo++; 1799311116Sdim break; 1800311116Sdim } 1801341825Sdim case bitc::METADATA_LABEL: { 1802341825Sdim if (Record.size() != 5) 1803341825Sdim return error("Invalid record"); 1804341825Sdim 1805341825Sdim IsDistinct = Record[0] & 1; 1806341825Sdim MetadataList.assignValue( 1807341825Sdim GET_OR_DISTINCT(DILabel, 1808341825Sdim (Context, getMDOrNull(Record[1]), 1809341825Sdim getMDString(Record[2]), 1810341825Sdim getMDOrNull(Record[3]), Record[4])), 1811341825Sdim NextMetadataNo); 1812341825Sdim NextMetadataNo++; 1813341825Sdim break; 1814341825Sdim } 1815311116Sdim case bitc::METADATA_EXPRESSION: { 1816311116Sdim if (Record.size() < 1) 1817311116Sdim return error("Invalid record"); 1818311116Sdim 1819311116Sdim IsDistinct = Record[0] & 1; 1820321369Sdim uint64_t Version = Record[0] >> 1; 1821311116Sdim auto Elts = MutableArrayRef<uint64_t>(Record).slice(1); 1822311116Sdim 1823321369Sdim SmallVector<uint64_t, 6> Buffer; 1824321369Sdim if (Error Err = upgradeDIExpression(Version, Elts, Buffer)) 1825321369Sdim return Err; 1826321369Sdim 1827311116Sdim MetadataList.assignValue( 1828321369Sdim GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo); 1829312967Sdim NextMetadataNo++; 1830311116Sdim break; 1831311116Sdim } 1832311116Sdim case bitc::METADATA_GLOBAL_VAR_EXPR: { 1833311116Sdim if (Record.size() != 3) 1834311116Sdim return error("Invalid record"); 1835311116Sdim 1836311116Sdim IsDistinct = Record[0]; 1837327952Sdim Metadata *Expr = getMDOrNull(Record[2]); 1838327952Sdim if (!Expr) 1839327952Sdim Expr = DIExpression::get(Context, {}); 1840327952Sdim MetadataList.assignValue( 1841327952Sdim GET_OR_DISTINCT(DIGlobalVariableExpression, 1842327952Sdim (Context, getMDOrNull(Record[1]), Expr)), 1843327952Sdim NextMetadataNo); 1844312967Sdim NextMetadataNo++; 1845311116Sdim break; 1846311116Sdim } 1847311116Sdim case bitc::METADATA_OBJC_PROPERTY: { 1848311116Sdim if (Record.size() != 8) 1849311116Sdim return error("Invalid record"); 1850311116Sdim 1851311116Sdim IsDistinct = Record[0]; 1852311116Sdim MetadataList.assignValue( 1853311116Sdim GET_OR_DISTINCT(DIObjCProperty, 1854311116Sdim (Context, getMDString(Record[1]), 1855311116Sdim getMDOrNull(Record[2]), Record[3], 1856311116Sdim getMDString(Record[4]), getMDString(Record[5]), 1857311116Sdim Record[6], getDITypeRefOrNull(Record[7]))), 1858312967Sdim NextMetadataNo); 1859312967Sdim NextMetadataNo++; 1860311116Sdim break; 1861311116Sdim } 1862311116Sdim case bitc::METADATA_IMPORTED_ENTITY: { 1863321369Sdim if (Record.size() != 6 && Record.size() != 7) 1864311116Sdim return error("Invalid record"); 1865311116Sdim 1866311116Sdim IsDistinct = Record[0]; 1867321369Sdim bool HasFile = (Record.size() == 7); 1868311116Sdim MetadataList.assignValue( 1869311116Sdim GET_OR_DISTINCT(DIImportedEntity, 1870311116Sdim (Context, Record[1], getMDOrNull(Record[2]), 1871321369Sdim getDITypeRefOrNull(Record[3]), 1872321369Sdim HasFile ? getMDOrNull(Record[6]) : nullptr, 1873321369Sdim HasFile ? Record[4] : 0, getMDString(Record[5]))), 1874312967Sdim NextMetadataNo); 1875312967Sdim NextMetadataNo++; 1876311116Sdim break; 1877311116Sdim } 1878311116Sdim case bitc::METADATA_STRING_OLD: { 1879311116Sdim std::string String(Record.begin(), Record.end()); 1880311116Sdim 1881311116Sdim // Test for upgrading !llvm.loop. 1882311116Sdim HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String); 1883311544Sdim ++NumMDStringLoaded; 1884311116Sdim Metadata *MD = MDString::get(Context, String); 1885312967Sdim MetadataList.assignValue(MD, NextMetadataNo); 1886312967Sdim NextMetadataNo++; 1887311116Sdim break; 1888311116Sdim } 1889311544Sdim case bitc::METADATA_STRINGS: { 1890311544Sdim auto CreateNextMDString = [&](StringRef Str) { 1891311544Sdim ++NumMDStringLoaded; 1892312967Sdim MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo); 1893312967Sdim NextMetadataNo++; 1894311544Sdim }; 1895311544Sdim if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString)) 1896311116Sdim return Err; 1897311116Sdim break; 1898311544Sdim } 1899311116Sdim case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { 1900311116Sdim if (Record.size() % 2 == 0) 1901311116Sdim return error("Invalid record"); 1902311116Sdim unsigned ValueID = Record[0]; 1903311116Sdim if (ValueID >= ValueList.size()) 1904311116Sdim return error("Invalid record"); 1905311116Sdim if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) 1906311116Sdim if (Error Err = parseGlobalObjectAttachment( 1907311116Sdim *GO, ArrayRef<uint64_t>(Record).slice(1))) 1908311116Sdim return Err; 1909311116Sdim break; 1910311116Sdim } 1911311116Sdim case bitc::METADATA_KIND: { 1912311116Sdim // Support older bitcode files that had METADATA_KIND records in a 1913311116Sdim // block with METADATA_BLOCK_ID. 1914311116Sdim if (Error Err = parseMetadataKindRecord(Record)) 1915311116Sdim return Err; 1916311116Sdim break; 1917311116Sdim } 1918311116Sdim } 1919311544Sdim return Error::success(); 1920311116Sdim#undef GET_OR_DISTINCT 1921311116Sdim} 1922311116Sdim 1923311116SdimError MetadataLoader::MetadataLoaderImpl::parseMetadataStrings( 1924311544Sdim ArrayRef<uint64_t> Record, StringRef Blob, 1925321369Sdim function_ref<void(StringRef)> CallBack) { 1926311116Sdim // All the MDStrings in the block are emitted together in a single 1927311116Sdim // record. The strings are concatenated and stored in a blob along with 1928311116Sdim // their sizes. 1929311116Sdim if (Record.size() != 2) 1930311116Sdim return error("Invalid record: metadata strings layout"); 1931311116Sdim 1932311116Sdim unsigned NumStrings = Record[0]; 1933311116Sdim unsigned StringsOffset = Record[1]; 1934311116Sdim if (!NumStrings) 1935311116Sdim return error("Invalid record: metadata strings with no strings"); 1936311116Sdim if (StringsOffset > Blob.size()) 1937311116Sdim return error("Invalid record: metadata strings corrupt offset"); 1938311116Sdim 1939311116Sdim StringRef Lengths = Blob.slice(0, StringsOffset); 1940311116Sdim SimpleBitstreamCursor R(Lengths); 1941311116Sdim 1942311116Sdim StringRef Strings = Blob.drop_front(StringsOffset); 1943311116Sdim do { 1944311116Sdim if (R.AtEndOfStream()) 1945311116Sdim return error("Invalid record: metadata strings bad length"); 1946311116Sdim 1947353358Sdim Expected<uint32_t> MaybeSize = R.ReadVBR(6); 1948353358Sdim if (!MaybeSize) 1949353358Sdim return MaybeSize.takeError(); 1950353358Sdim uint32_t Size = MaybeSize.get(); 1951311116Sdim if (Strings.size() < Size) 1952311116Sdim return error("Invalid record: metadata strings truncated chars"); 1953311116Sdim 1954311544Sdim CallBack(Strings.slice(0, Size)); 1955311116Sdim Strings = Strings.drop_front(Size); 1956311116Sdim } while (--NumStrings); 1957311116Sdim 1958311116Sdim return Error::success(); 1959311116Sdim} 1960311116Sdim 1961311116SdimError MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment( 1962311116Sdim GlobalObject &GO, ArrayRef<uint64_t> Record) { 1963311116Sdim assert(Record.size() % 2 == 0); 1964311116Sdim for (unsigned I = 0, E = Record.size(); I != E; I += 2) { 1965311116Sdim auto K = MDKindMap.find(Record[I]); 1966311116Sdim if (K == MDKindMap.end()) 1967311116Sdim return error("Invalid ID"); 1968311116Sdim MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]); 1969311116Sdim if (!MD) 1970344779Sdim return error("Invalid metadata attachment: expect fwd ref to MDNode"); 1971311116Sdim GO.addMetadata(K->second, *MD); 1972311116Sdim } 1973311116Sdim return Error::success(); 1974311116Sdim} 1975311116Sdim 1976311116Sdim/// Parse metadata attachments. 1977311116SdimError MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment( 1978311116Sdim Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { 1979353358Sdim if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 1980353358Sdim return Err; 1981311116Sdim 1982311116Sdim SmallVector<uint64_t, 64> Record; 1983311544Sdim PlaceholderQueue Placeholders; 1984311544Sdim 1985311116Sdim while (true) { 1986353358Sdim Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); 1987353358Sdim if (!MaybeEntry) 1988353358Sdim return MaybeEntry.takeError(); 1989353358Sdim BitstreamEntry Entry = MaybeEntry.get(); 1990311116Sdim 1991311116Sdim switch (Entry.Kind) { 1992311116Sdim case BitstreamEntry::SubBlock: // Handled for us already. 1993311116Sdim case BitstreamEntry::Error: 1994311116Sdim return error("Malformed block"); 1995311116Sdim case BitstreamEntry::EndBlock: 1996311544Sdim resolveForwardRefsAndPlaceholders(Placeholders); 1997311116Sdim return Error::success(); 1998311116Sdim case BitstreamEntry::Record: 1999311116Sdim // The interesting case. 2000311116Sdim break; 2001311116Sdim } 2002311116Sdim 2003311116Sdim // Read a metadata attachment record. 2004311116Sdim Record.clear(); 2005311544Sdim ++NumMDRecordLoaded; 2006353358Sdim Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record); 2007353358Sdim if (!MaybeRecord) 2008353358Sdim return MaybeRecord.takeError(); 2009353358Sdim switch (MaybeRecord.get()) { 2010311116Sdim default: // Default behavior: ignore. 2011311116Sdim break; 2012311116Sdim case bitc::METADATA_ATTACHMENT: { 2013311116Sdim unsigned RecordLength = Record.size(); 2014311116Sdim if (Record.empty()) 2015311116Sdim return error("Invalid record"); 2016311116Sdim if (RecordLength % 2 == 0) { 2017311116Sdim // A function attachment. 2018311116Sdim if (Error Err = parseGlobalObjectAttachment(F, Record)) 2019311116Sdim return Err; 2020311116Sdim continue; 2021311116Sdim } 2022311116Sdim 2023311116Sdim // An instruction attachment. 2024311116Sdim Instruction *Inst = InstructionList[Record[0]]; 2025311116Sdim for (unsigned i = 1; i != RecordLength; i = i + 2) { 2026311116Sdim unsigned Kind = Record[i]; 2027311116Sdim DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind); 2028311116Sdim if (I == MDKindMap.end()) 2029311116Sdim return error("Invalid ID"); 2030311116Sdim if (I->second == LLVMContext::MD_tbaa && StripTBAA) 2031311116Sdim continue; 2032311116Sdim 2033311544Sdim auto Idx = Record[i + 1]; 2034311544Sdim if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) && 2035311833Sdim !MetadataList.lookup(Idx)) { 2036311544Sdim // Load the attachment if it is in the lazy-loadable range and hasn't 2037311544Sdim // been loaded yet. 2038311544Sdim lazyLoadOneMetadata(Idx, Placeholders); 2039311833Sdim resolveForwardRefsAndPlaceholders(Placeholders); 2040311833Sdim } 2041311544Sdim 2042311544Sdim Metadata *Node = MetadataList.getMetadataFwdRef(Idx); 2043311116Sdim if (isa<LocalAsMetadata>(Node)) 2044311116Sdim // Drop the attachment. This used to be legal, but there's no 2045311116Sdim // upgrade path. 2046311116Sdim break; 2047311116Sdim MDNode *MD = dyn_cast_or_null<MDNode>(Node); 2048311116Sdim if (!MD) 2049311116Sdim return error("Invalid metadata attachment"); 2050311116Sdim 2051311116Sdim if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop) 2052311116Sdim MD = upgradeInstructionLoopAttachment(*MD); 2053311116Sdim 2054311116Sdim if (I->second == LLVMContext::MD_tbaa) { 2055311116Sdim assert(!MD->isTemporary() && "should load MDs before attachments"); 2056311116Sdim MD = UpgradeTBAANode(*MD); 2057311116Sdim } 2058311116Sdim Inst->setMetadata(I->second, MD); 2059311116Sdim } 2060311116Sdim break; 2061311116Sdim } 2062311116Sdim } 2063311116Sdim } 2064311116Sdim} 2065311116Sdim 2066311116Sdim/// Parse a single METADATA_KIND record, inserting result in MDKindMap. 2067311116SdimError MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord( 2068311116Sdim SmallVectorImpl<uint64_t> &Record) { 2069311116Sdim if (Record.size() < 2) 2070311116Sdim return error("Invalid record"); 2071311116Sdim 2072311116Sdim unsigned Kind = Record[0]; 2073311116Sdim SmallString<8> Name(Record.begin() + 1, Record.end()); 2074311116Sdim 2075311116Sdim unsigned NewKind = TheModule.getMDKindID(Name.str()); 2076311116Sdim if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 2077311116Sdim return error("Conflicting METADATA_KIND records"); 2078311116Sdim return Error::success(); 2079311116Sdim} 2080311116Sdim 2081311116Sdim/// Parse the metadata kinds out of the METADATA_KIND_BLOCK. 2082311116SdimError MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() { 2083353358Sdim if (Error Err = Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID)) 2084353358Sdim return Err; 2085311116Sdim 2086311116Sdim SmallVector<uint64_t, 64> Record; 2087311116Sdim 2088311116Sdim // Read all the records. 2089311116Sdim while (true) { 2090353358Sdim Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); 2091353358Sdim if (!MaybeEntry) 2092353358Sdim return MaybeEntry.takeError(); 2093353358Sdim BitstreamEntry Entry = MaybeEntry.get(); 2094311116Sdim 2095311116Sdim switch (Entry.Kind) { 2096311116Sdim case BitstreamEntry::SubBlock: // Handled for us already. 2097311116Sdim case BitstreamEntry::Error: 2098311116Sdim return error("Malformed block"); 2099311116Sdim case BitstreamEntry::EndBlock: 2100311116Sdim return Error::success(); 2101311116Sdim case BitstreamEntry::Record: 2102311116Sdim // The interesting case. 2103311116Sdim break; 2104311116Sdim } 2105311116Sdim 2106311116Sdim // Read a record. 2107311116Sdim Record.clear(); 2108311544Sdim ++NumMDRecordLoaded; 2109353358Sdim Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record); 2110353358Sdim if (!MaybeCode) 2111353358Sdim return MaybeCode.takeError(); 2112353358Sdim switch (MaybeCode.get()) { 2113311116Sdim default: // Default behavior: ignore. 2114311116Sdim break; 2115311116Sdim case bitc::METADATA_KIND: { 2116311116Sdim if (Error Err = parseMetadataKindRecord(Record)) 2117311116Sdim return Err; 2118311116Sdim break; 2119311116Sdim } 2120311116Sdim } 2121311116Sdim } 2122311116Sdim} 2123311116Sdim 2124311116SdimMetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) { 2125311116Sdim Pimpl = std::move(RHS.Pimpl); 2126311116Sdim return *this; 2127311116Sdim} 2128311116SdimMetadataLoader::MetadataLoader(MetadataLoader &&RHS) 2129311116Sdim : Pimpl(std::move(RHS.Pimpl)) {} 2130311116Sdim 2131311116SdimMetadataLoader::~MetadataLoader() = default; 2132311116SdimMetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule, 2133311116Sdim BitcodeReaderValueList &ValueList, 2134311116Sdim bool IsImporting, 2135311116Sdim std::function<Type *(unsigned)> getTypeByID) 2136360784Sdim : Pimpl(std::make_unique<MetadataLoaderImpl>( 2137321369Sdim Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {} 2138311116Sdim 2139311116SdimError MetadataLoader::parseMetadata(bool ModuleLevel) { 2140311116Sdim return Pimpl->parseMetadata(ModuleLevel); 2141311116Sdim} 2142311116Sdim 2143311116Sdimbool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); } 2144311116Sdim 2145311116Sdim/// Return the given metadata, creating a replaceable forward reference if 2146311116Sdim/// necessary. 2147312719SdimMetadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) { 2148312719Sdim return Pimpl->getMetadataFwdRefOrLoad(Idx); 2149311116Sdim} 2150311116Sdim 2151311116SdimDISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) { 2152311116Sdim return Pimpl->lookupSubprogramForFunction(F); 2153311116Sdim} 2154311116Sdim 2155311116SdimError MetadataLoader::parseMetadataAttachment( 2156311116Sdim Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { 2157311116Sdim return Pimpl->parseMetadataAttachment(F, InstructionList); 2158311116Sdim} 2159311116Sdim 2160311116SdimError MetadataLoader::parseMetadataKinds() { 2161311116Sdim return Pimpl->parseMetadataKinds(); 2162311116Sdim} 2163311116Sdim 2164311116Sdimvoid MetadataLoader::setStripTBAA(bool StripTBAA) { 2165311116Sdim return Pimpl->setStripTBAA(StripTBAA); 2166311116Sdim} 2167311116Sdim 2168311116Sdimbool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); } 2169311116Sdim 2170311116Sdimunsigned MetadataLoader::size() const { return Pimpl->size(); } 2171311116Sdimvoid MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); } 2172321369Sdim 2173321369Sdimvoid MetadataLoader::upgradeDebugIntrinsics(Function &F) { 2174321369Sdim return Pimpl->upgradeDebugIntrinsics(F); 2175321369Sdim} 2176