63#define DEBUG_TYPE "bitcode-reader"
65STATISTIC(NumMDStringLoaded,
"Number of MDStrings loaded");
66STATISTIC(NumMDNodeTemporary,
"Number of MDNode::Temporary created");
67STATISTIC(NumMDRecordLoaded,
"Number of Metadata records loaded");
71class BitcodeReaderMetadataList {
98 unsigned RefsUpperBound;
101 BitcodeReaderMetadataList(LLVMContext &
C,
size_t RefsUpperBound)
103 RefsUpperBound(std::
min((size_t)std::numeric_limits<unsigned>::
max(),
106 using const_iterator = SmallVector<TrackingMDRef, 1>::const_iterator;
109 unsigned size()
const {
return MetadataPtrs.size(); }
110 void resize(
unsigned N) { MetadataPtrs.resize(
N); }
111 void push_back(
Metadata *MD) { MetadataPtrs.emplace_back(MD); }
112 void clear() { MetadataPtrs.clear(); }
114 void pop_back() { MetadataPtrs.pop_back(); }
115 bool empty()
const {
return MetadataPtrs.empty(); }
116 const_iterator
begin()
const {
return MetadataPtrs.begin(); }
117 const_iterator
end()
const {
return MetadataPtrs.end(); }
119 Metadata *operator[](
unsigned i)
const {
return MetadataPtrs[i]; }
122 if (
I < MetadataPtrs.size())
123 return MetadataPtrs[
I];
127 void shrinkTo(
unsigned N) {
128 assert(
N <=
size() &&
"Invalid shrinkTo request!");
129 assert(ForwardReference.empty() &&
"Unexpected forward refs");
130 assert(UnresolvedNodes.empty() &&
"Unexpected unresolved node");
131 MetadataPtrs.resize(
N);
136 Metadata *getMetadataFwdRef(
unsigned Idx);
142 Metadata *getMetadataIfResolved(
unsigned Idx);
144 MDNode *getMDNodeFwdRefOrNull(
unsigned Idx);
145 void assignValue(
Metadata *MD,
unsigned Idx);
146 void tryToResolveCycles();
147 bool hasFwdRefs()
const {
return !ForwardReference.empty(); }
148 int getNextFwdRef() {
150 return *ForwardReference.begin();
154 void addTypeRef(MDString &
UUID, DICompositeType &CT);
169void BitcodeReaderMetadataList::assignValue(
Metadata *MD,
unsigned Idx) {
171 if (!MDN->isResolved())
172 UnresolvedNodes.
insert(Idx);
182 TrackingMDRef &OldMD = MetadataPtrs[
Idx];
190 PrevMD->replaceAllUsesWith(MD);
194Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(
unsigned Idx) {
196 if (Idx >= RefsUpperBound)
202 if (
Metadata *MD = MetadataPtrs[Idx])
209 ++NumMDNodeTemporary;
211 MetadataPtrs[
Idx].reset(MD);
215Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(
unsigned Idx) {
218 if (!
N->isResolved())
223MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(
unsigned Idx) {
227void BitcodeReaderMetadataList::tryToResolveCycles() {
233 for (
const auto &[
UUID, CT] : OldTypeRefs.FwdDecls)
234 OldTypeRefs.Final.try_emplace(
UUID, CT);
235 OldTypeRefs.FwdDecls.clear();
239 for (
const auto &Array : OldTypeRefs.Arrays)
240 Array.second->replaceAllUsesWith(resolveTypeArray(
Array.first.get()));
241 OldTypeRefs.Arrays.clear();
246 for (
const auto &
Ref : OldTypeRefs.Unknown) {
247 if (DICompositeType *CT = OldTypeRefs.Final.lookup(
Ref.first))
248 Ref.second->replaceAllUsesWith(CT);
250 Ref.second->replaceAllUsesWith(
Ref.first);
252 OldTypeRefs.Unknown.clear();
254 if (UnresolvedNodes.
empty())
259 for (
unsigned I : UnresolvedNodes) {
260 auto &MD = MetadataPtrs[
I];
265 assert(!
N->isTemporary() &&
"Unexpected forward reference");
270 UnresolvedNodes.clear();
273void BitcodeReaderMetadataList::addTypeRef(MDString &
UUID,
274 DICompositeType &CT) {
277 OldTypeRefs.FwdDecls.insert(std::make_pair(&
UUID, &CT));
279 OldTypeRefs.Final.insert(std::make_pair(&
UUID, &CT));
287 if (
auto *CT = OldTypeRefs.Final.lookup(
UUID))
290 auto &
Ref = OldTypeRefs.Unknown[
UUID];
296Metadata *BitcodeReaderMetadataList::upgradeTypeArray(
Metadata *MaybeTuple) {
298 if (!Tuple ||
Tuple->isDistinct())
302 if (!
Tuple->isTemporary())
303 return resolveTypeArray(Tuple);
307 OldTypeRefs.Arrays.emplace_back(
308 std::piecewise_construct, std::forward_as_tuple(Tuple),
310 return OldTypeRefs.Arrays.back().second.get();
313Metadata *BitcodeReaderMetadataList::resolveTypeArray(
Metadata *MaybeTuple) {
315 if (!Tuple ||
Tuple->isDistinct())
320 Ops.reserve(
Tuple->getNumOperands());
322 Ops.push_back(upgradeTypeRef(MD));
329class PlaceholderQueue {
332 std::deque<DistinctMDOperandPlaceholder> PHs;
335 ~PlaceholderQueue() {
337 "PlaceholderQueue hasn't been flushed before being destroyed");
339 bool empty()
const {
return PHs.empty(); }
340 DistinctMDOperandPlaceholder &getPlaceholderOp(
unsigned ID);
341 void flush(BitcodeReaderMetadataList &MetadataList);
345 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
346 DenseSet<unsigned> &Temporaries) {
347 for (
auto &PH : PHs) {
348 auto ID = PH.getID();
349 auto *MD = MetadataList.lookup(ID);
355 if (
N &&
N->isTemporary())
363DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(
unsigned ID) {
364 PHs.emplace_back(ID);
368void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
369 while (!PHs.empty()) {
370 auto *MD = MetadataList.lookup(PHs.front().getID());
371 assert(MD &&
"Flushing placeholder on unassigned MD");
374 assert(MDN->isResolved() &&
375 "Flushing Placeholder while cycles aren't resolved");
377 PHs.front().replaceUseWith(MD);
388 const BitReaderOptions &Opts;
389 BitcodeReaderMetadataList MetadataList;
402 std::vector<StringRef> MDStringRef;
406 MDString *lazyLoadOneMDString(
unsigned Idx);
409 std::vector<uint64_t> GlobalMetadataBitPosIndex;
414 uint64_t GlobalDeclAttachmentPos = 0;
419 unsigned NumGlobalDeclAttachSkipped = 0;
420 unsigned NumGlobalDeclAttachParsed = 0;
433 void lazyLoadOneMetadata(
unsigned Idx, PlaceholderQueue &Placeholders);
437 std::vector<std::pair<DICompileUnit *, unsigned>> CUSubprograms;
451 bool StripTBAA =
false;
452 bool HasSeenOldLoopTags =
false;
457 bool NeedUpgradeToDIGlobalVariableExpression =
false;
458 bool NeedDeclareExpressionUpgrade =
false;
462 GlobalVariableExpression;
468 bool IsImporting =
false;
471 PlaceholderQueue &Placeholders,
StringRef Blob,
472 unsigned &NextMetadataNo);
479 void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
482 void upgradeCUSubprograms() {
483 for (
auto CU_SP : CUSubprograms)
486 for (
auto &
Op : SPs->operands())
488 SP->replaceUnit(CU_SP.first);
489 CUSubprograms.clear();
493 void upgradeCUVariables() {
494 if (!NeedUpgradeToDIGlobalVariableExpression)
498 if (
NamedMDNode *CUNodes = TheModule.getNamedMetadata(
"llvm.dbg.cu"))
499 for (
unsigned I = 0, E = CUNodes->getNumOperands();
I != E; ++
I) {
502 for (
unsigned I = 0;
I < GVs->getNumOperands();
I++)
515 for (
auto &GV : TheModule.globals()) {
517 GV.getMetadata(LLVMContext::MD_dbg, MDs);
518 GV.eraseMetadata(LLVMContext::MD_dbg);
526 GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
528 GV.addMetadata(LLVMContext::MD_dbg, *MD);
535 if (
auto *SP = ParentSubprogram[S]) {
543 if (!Visited.
insert(S).second)
547 return ParentSubprogram[InitialScope] =
553 using SPToEntitiesMap =
559 template <
typename NodeT>
560 void upgradeOneCULocalsList(SPToEntitiesMap &SPToEntities,
DICompileUnit *
CU,
561 unsigned ListIndex) {
567 return !isa_and_nonnull<DILocalScope>(getScope(cast<NodeT>(MD)));
577 else if (
auto *SP = findEnclosingSubprogram(LS))
578 SPToEntities[SP].push_back(MD);
586 void upgradeCULocals() {
587 NamedMDNode *CUNodes = TheModule.getNamedMetadata(
"llvm.dbg.cu");
591 SPToEntitiesMap SPToEntities;
598 upgradeOneCULocalsList<DIGlobalVariableExpression>(SPToEntities,
CU, 6);
600 upgradeOneCULocalsList<DIImportedEntity>(SPToEntities,
CU, 7);
602 upgradeOneCULocalsList<DICompositeType>(SPToEntities,
CU, 4);
606 for (
auto &[SP, Nodes] : SPToEntities)
607 SP->retainNodes(Nodes.begin(), Nodes.end());
608 SPToEntities.clear();
611 ParentSubprogram.clear();
616 void upgradeDeclareExpressions(
Function &
F) {
617 if (!NeedDeclareExpressionUpgrade)
620 auto UpdateDeclareIfNeeded = [&](
auto *Declare) {
621 auto *DIExpr = Declare->getExpression();
622 if (!DIExpr || !DIExpr->startsWithDeref() ||
626 Ops.append(std::next(DIExpr->elements_begin()), DIExpr->elements_end());
633 if (DVR.isDbgDeclare())
634 UpdateDeclareIfNeeded(&DVR);
637 UpdateDeclareIfNeeded(DDI);
642 Error upgradeDIExpression(uint64_t FromVersion,
645 auto N = Expr.
size();
646 switch (FromVersion) {
648 return error(
"Invalid record");
650 if (
N >= 3 && Expr[
N - 3] == dwarf::DW_OP_bit_piece)
655 if (
N && Expr[0] == dwarf::DW_OP_deref) {
657 if (Expr.
size() >= 3 &&
661 *std::prev(
End) = dwarf::DW_OP_deref;
663 NeedDeclareExpressionUpgrade =
true;
669 while (!SubExpr.empty()) {
674 switch (SubExpr.front()) {
678 case dwarf::DW_OP_constu:
679 case dwarf::DW_OP_minus:
680 case dwarf::DW_OP_plus:
690 HistoricSize = std::min(SubExpr.size(), HistoricSize);
693 switch (SubExpr.front()) {
694 case dwarf::DW_OP_plus:
695 Buffer.
push_back(dwarf::DW_OP_plus_uconst);
696 Buffer.
append(Args.begin(), Args.end());
698 case dwarf::DW_OP_minus:
700 Buffer.
append(Args.begin(), Args.end());
705 Buffer.
append(Args.begin(), Args.end());
710 SubExpr = SubExpr.slice(HistoricSize);
728 enum class DebugInfoUpgradeMode {
737 void upgradeDebugInfo(DebugInfoUpgradeMode Mode) {
738 if (Mode == DebugInfoUpgradeMode::None)
740 upgradeCUSubprograms();
741 upgradeCUVariables();
742 if (Mode == DebugInfoUpgradeMode::ModuleLevel)
747 void resolveLoadedMetadata(PlaceholderQueue &Placeholders,
748 DebugInfoUpgradeMode DIUpgradeMode) {
749 resolveForwardRefsAndPlaceholders(Placeholders);
750 upgradeDebugInfo(DIUpgradeMode);
753 << NewDistinctSPs.size() <<
" subprogram(s).\n");
754 NewDistinctSPs.clear();
757 void callMDTypeCallback(
Metadata **Val,
unsigned TypeID);
764 MetadataList(TheModule.
getContext(), Stream.SizeInBytes()),
765 ValueList(ValueList), Stream(Stream), Context(TheModule.
getContext()),
766 TheModule(TheModule), Callbacks(
std::
move(Callbacks)),
767 IsImporting(IsImporting) {}
771 bool hasFwdRefs()
const {
return MetadataList.hasFwdRefs(); }
774 if (ID < MDStringRef.size())
775 return lazyLoadOneMDString(ID);
776 if (
auto *MD = MetadataList.lookup(ID))
780 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
781 PlaceholderQueue Placeholders;
782 lazyLoadOneMetadata(ID, Placeholders);
784 resolveLoadedMetadata(Placeholders, DebugInfoUpgradeMode::None);
785 return MetadataList.lookup(ID);
787 return MetadataList.getMetadataFwdRef(ID);
791 return FunctionsWithSPs.lookup(
F);
808 unsigned size()
const {
return MetadataList.size(); }
814MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
815 IndexCursor = Stream;
817 GlobalDeclAttachmentPos = 0;
820 uint64_t SavedPos = IndexCursor.GetCurrentBitNo();
828 switch (Entry.Kind) {
831 return error(
"Malformed block");
838 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
840 if (
Error E = IndexCursor.skipRecord(Entry.ID).moveInto(Code))
845 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
846 return std::move(Err);
850 IndexCursor.readRecord(Entry.ID,
Record, &Blob))
853 return MaybeRecord.takeError();
854 unsigned NumStrings =
Record[0];
855 MDStringRef.reserve(NumStrings);
856 auto IndexNextMDString = [&](
StringRef Str) {
857 MDStringRef.push_back(Str);
859 if (
auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
860 return std::move(Err);
866 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
867 return std::move(Err);
869 if (Expected<unsigned> MaybeRecord =
870 IndexCursor.readRecord(
Entry.ID, Record))
873 return MaybeRecord.takeError();
875 return error(
"Invalid record");
877 auto BeginPos = IndexCursor.GetCurrentBitNo();
878 if (
Error Err = IndexCursor.JumpToBit(BeginPos +
Offset))
879 return std::move(Err);
880 Expected<BitstreamEntry> MaybeEntry =
881 IndexCursor.advanceSkippingSubblocks(
887 "Corrupted bitcode: Expected `Record` when trying to find the "
890 if (Expected<unsigned> MaybeCode =
891 IndexCursor.readRecord(
Entry.ID, Record))
893 "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
894 "find the Metadata index");
896 return MaybeCode.takeError();
898 auto CurrentValue = BeginPos;
899 GlobalMetadataBitPosIndex.reserve(
Record.size());
900 for (
auto &Elt : Record) {
902 GlobalMetadataBitPosIndex.push_back(CurrentValue);
909 return error(
"Corrupted Metadata block");
912 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
913 return std::move(Err);
917 if (Expected<unsigned> MaybeCode =
918 IndexCursor.readRecord(
Entry.ID, Record)) {
919 Code = MaybeCode.get();
922 return MaybeCode.takeError();
926 if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode())
927 Code = MaybeCode.get();
929 return MaybeCode.takeError();
934 if (Expected<unsigned> MaybeNextBitCode =
935 IndexCursor.readRecord(Code, Record))
938 return MaybeNextBitCode.takeError();
942 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
943 for (
unsigned i = 0; i !=
Size; ++i) {
948 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
949 assert(MD &&
"Invalid metadata: expect fwd ref to MDNode");
955 if (!GlobalDeclAttachmentPos)
956 GlobalDeclAttachmentPos = SavedPos;
958 NumGlobalDeclAttachSkipped++;
1002 MDStringRef.clear();
1003 GlobalMetadataBitPosIndex.clear();
1017Expected<bool> MetadataLoader::MetadataLoaderImpl::loadGlobalDeclAttachments() {
1019 if (!GlobalDeclAttachmentPos)
1023 BitstreamCursor TempCursor = Stream;
1024 SmallVector<uint64_t, 64>
Record;
1028 return std::move(Err);
1030 BitstreamEntry
Entry;
1035 return std::move(
E);
1037 switch (
Entry.Kind) {
1040 return error(
"Malformed block");
1043 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
1055 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
1059 NumGlobalDeclAttachParsed++;
1064 return std::move(Err);
1066 if (Expected<unsigned> MaybeRecord =
1070 return MaybeRecord.takeError();
1071 if (
Record.size() % 2 == 0)
1072 return error(
"Invalid record");
1073 unsigned ValueID =
Record[0];
1074 if (ValueID >= ValueList.size())
1075 return error(
"Invalid record");
1081 if (
Error Err = parseGlobalObjectAttachment(
1082 *GO, ArrayRef<uint64_t>(Record).slice(1)))
1083 return std::move(Err);
1085 return std::move(Err);
1090void MetadataLoader::MetadataLoaderImpl::callMDTypeCallback(
Metadata **Val,
1092 if (Callbacks.MDType) {
1093 (*Callbacks.MDType)(Val,
TypeID, Callbacks.GetTypeByID,
1094 Callbacks.GetContainedTypeID);
1102 if (!ModuleLevel && MetadataList.hasFwdRefs())
1103 return error(
"Invalid metadata: fwd refs into function blocks");
1107 auto EntryPos = Stream.GetCurrentBitNo();
1113 PlaceholderQueue Placeholders;
1114 auto DIUpgradeMode = ModuleLevel ? DebugInfoUpgradeMode::ModuleLevel
1115 : DebugInfoUpgradeMode::Partial;
1119 if (ModuleLevel && IsImporting && MetadataList.empty() &&
1120 Opts.ondemand_mds_loading) {
1121 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
1123 return SuccessOrErr.takeError();
1124 if (SuccessOrErr.get()) {
1127 MetadataList.resize(MDStringRef.size() +
1128 GlobalMetadataBitPosIndex.size());
1133 SuccessOrErr = loadGlobalDeclAttachments();
1135 return SuccessOrErr.takeError();
1136 assert(SuccessOrErr.get());
1141 resolveLoadedMetadata(Placeholders, DIUpgradeMode);
1144 Stream.ReadBlockEnd();
1145 if (
Error Err = IndexCursor.JumpToBit(EntryPos))
1147 if (
Error Err = Stream.SkipBlock()) {
1158 unsigned NextMetadataNo = MetadataList.size();
1163 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
1166 switch (Entry.Kind) {
1169 return error(
"Malformed block");
1172 resolveLoadedMetadata(Placeholders, DIUpgradeMode);
1182 ++NumMDRecordLoaded;
1184 Stream.readRecord(Entry.ID,
Record, &Blob)) {
1185 if (
Error Err = parseOneMetadata(
Record, MaybeCode.
get(), Placeholders,
1186 Blob, NextMetadataNo))
1193MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(
unsigned ID) {
1194 ++NumMDStringLoaded;
1195 if (
Metadata *MD = MetadataList.lookup(ID))
1198 MetadataList.assignValue(MDS, ID);
1202void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
1203 unsigned ID, PlaceholderQueue &Placeholders) {
1204 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
1205 assert(ID >= MDStringRef.size() &&
"Unexpected lazy-loading of MDString");
1207 if (
auto *MD = MetadataList.lookup(ID)) {
1211 if (!
N || !
N->isTemporary())
1216 if (
Error Err = IndexCursor.JumpToBit(
1217 GlobalMetadataBitPosIndex[ID - MDStringRef.size()]))
1221 if (
Error E = IndexCursor.advanceSkippingSubblocks().moveInto(Entry))
1225 ++NumMDRecordLoaded;
1227 IndexCursor.readRecord(Entry.ID,
Record, &Blob)) {
1229 parseOneMetadata(
Record, MaybeCode.
get(), Placeholders, Blob, ID))
1239void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
1240 PlaceholderQueue &Placeholders) {
1241 DenseSet<unsigned> Temporaries;
1244 Placeholders.getTemporaries(MetadataList, Temporaries);
1247 if (Temporaries.
empty() && !MetadataList.hasFwdRefs())
1252 for (
auto ID : Temporaries)
1253 lazyLoadOneMetadata(ID, Placeholders);
1254 Temporaries.clear();
1258 while (MetadataList.hasFwdRefs())
1259 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
1264 MetadataList.tryToResolveCycles();
1268 Placeholders.flush(MetadataList);
1272 Type *Ty,
unsigned TyID) {
1284 if (Idx < ValueList.
size() && ValueList[Idx] &&
1285 ValueList[Idx]->getType() == Ty)
1291Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
1292 SmallVectorImpl<uint64_t> &Record,
unsigned Code,
1293 PlaceholderQueue &Placeholders, StringRef Blob,
unsigned &NextMetadataNo) {
1295 bool IsDistinct =
false;
1296 auto getMD = [&](
unsigned ID) ->
Metadata * {
1297 if (ID < MDStringRef.size())
1298 return lazyLoadOneMDString(ID);
1300 if (
auto *MD = MetadataList.lookup(ID))
1304 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
1308 MetadataList.getMetadataFwdRef(NextMetadataNo);
1309 lazyLoadOneMetadata(ID, Placeholders);
1310 return MetadataList.lookup(ID);
1313 return MetadataList.getMetadataFwdRef(ID);
1315 if (
auto *MD = MetadataList.getMetadataIfResolved(ID))
1317 return &Placeholders.getPlaceholderOp(ID);
1319 auto getMDOrNull = [&](
unsigned ID) ->
Metadata * {
1321 return getMD(ID - 1);
1324 auto getMDString = [&](
unsigned ID) -> MDString * {
1327 auto MDS = getMDOrNull(ID);
1332 auto getDITypeRefOrNull = [&](
unsigned ID) {
1333 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1336 auto getMetadataOrConstant = [&](
bool IsMetadata,
1339 return getMDOrNull(Entry);
1341 ConstantInt::get(Type::getInt64Ty(
Context), Entry));
1344#define GET_OR_DISTINCT(CLASS, ARGS) \
1345 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1354 if (
Error E = Stream.ReadCode().moveInto(Code))
1357 ++NumMDRecordLoaded;
1358 if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) {
1360 return error(
"METADATA_NAME not followed by METADATA_NAMED_NODE");
1362 return MaybeNextBitCode.takeError();
1366 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1367 for (
unsigned i = 0; i !=
Size; ++i) {
1368 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1370 return error(
"Invalid named metadata: expect fwd ref to MDNode");
1379 if (
Record.size() % 2 == 1)
1380 return error(
"Invalid record");
1384 auto dropRecord = [&] {
1388 if (
Record.size() != 2) {
1393 unsigned TyID =
Record[0];
1394 Type *Ty = Callbacks.GetTypeByID(TyID);
1400 Value *
V = ValueList.getValueFwdRef(Record[1], Ty, TyID,
1403 return error(
"Invalid value reference from old fn metadata");
1411 if (
Record.size() % 2 == 1)
1412 return error(
"Invalid record");
1416 for (
unsigned i = 0; i !=
Size; i += 2) {
1417 unsigned TyID =
Record[i];
1418 Type *Ty = Callbacks.GetTypeByID(TyID);
1420 return error(
"Invalid record");
1426 return error(
"Invalid value reference from old metadata");
1429 "Expected non-function-local metadata");
1430 callMDTypeCallback(&MD, TyID);
1441 return error(
"Invalid record");
1443 unsigned TyID =
Record[0];
1444 Type *Ty = Callbacks.GetTypeByID(TyID);
1446 return error(
"Invalid record");
1450 return error(
"Invalid value reference from metadata");
1453 callMDTypeCallback(&MD, TyID);
1454 MetadataList.assignValue(MD, NextMetadataNo);
1464 for (
unsigned ID : Record)
1475 return error(
"Invalid record");
1479 unsigned Column =
Record[2];
1481 Metadata *InlinedAt = getMDOrNull(Record[4]);
1485 Metadata *IRLayers =
Record.size() >= 9 ? getMDOrNull(Record[8]) : nullptr;
1486 MetadataList.assignValue(
1488 (
Context, Line, Column, Scope, InlinedAt, ImplicitCode,
1489 AtomGroup, AtomRank, IRLayers)),
1496 return error(
"Invalid record");
1500 unsigned Column =
Record[2];
1505 MetadataList.assignValue(
1513 return error(
"Invalid record");
1517 for (
unsigned I = 1,
E =
Record.size();
I !=
E; ++
I)
1526 return error(
"Invalid record");
1533 return error(
"Invalid record");
1535 auto *Header = getMDString(Record[3]);
1537 for (
unsigned I = 4,
E =
Record.size();
I !=
E; ++
I)
1539 MetadataList.assignValue(
1555 switch (Record[0] >> 1) {
1566 DISubrange, (
Context, getMDOrNull(Record[1]), getMDOrNull(Record[2]),
1567 getMDOrNull(Record[3]), getMDOrNull(Record[4])));
1570 return error(
"Invalid record: Unsupported version of DISubrange");
1573 MetadataList.assignValue(Val, NextMetadataNo);
1574 IsDistinct =
Record[0] & 1;
1581 (
Context, getMDOrNull(Record[1]),
1582 getMDOrNull(Record[2]), getMDOrNull(Record[3]),
1583 getMDOrNull(Record[4])));
1585 MetadataList.assignValue(Val, NextMetadataNo);
1586 IsDistinct =
Record[0] & 1;
1592 return error(
"Invalid record");
1594 IsDistinct =
Record[0] & 1;
1595 bool IsUnsigned =
Record[0] & 2;
1596 bool IsBigInt =
Record[0] & 4;
1601 const size_t NumWords =
Record.size() - 3;
1606 MetadataList.assignValue(
1615 return error(
"Invalid record");
1617 IsDistinct =
Record[0] & 1;
1618 bool SizeIsMetadata =
Record[0] & 2;
1622 uint32_t NumExtraInhabitants = (
Record.size() > 7) ?
Record[7] : 0;
1623 uint32_t DataSizeInBits = (
Record.size() > 8) ?
Record[8] : 0;
1624 Metadata *SizeInBits = getMetadataOrConstant(SizeIsMetadata, Record[3]);
1626 unsigned LineNo = 0;
1629 File = getMDOrNull(Record[9]);
1631 Scope = getMDOrNull(Record[11]);
1633 MetadataList.assignValue(
1635 (
Context, Record[1], getMDString(Record[2]), File,
1636 LineNo, Scope, SizeInBits, Record[4], Record[5],
1637 NumExtraInhabitants, DataSizeInBits, Flags)),
1644 return error(
"Invalid record");
1646 IsDistinct =
Record[0] & 1;
1647 bool SizeIsMetadata =
Record[0] & 2;
1650 Metadata *SizeInBits = getMetadataOrConstant(SizeIsMetadata, Record[3]);
1654 auto ReadWideInt = [&]() {
1656 unsigned NumWords =
Encoded >> 32;
1663 APInt Numerator = ReadWideInt();
1664 APInt Denominator = ReadWideInt();
1667 unsigned LineNo = 0;
1675 return error(
"Invalid record");
1677 MetadataList.assignValue(
1679 (
Context, Record[1], getMDString(Record[2]), File,
1680 LineNo, Scope, SizeInBits, Record[4], Record[5], Flags,
1681 Record[7], Record[8], Numerator, Denominator)),
1688 return error(
"Invalid record");
1690 IsDistinct =
Record[0] & 1;
1691 bool SizeIsMetadata =
Record[0] & 2;
1696 Metadata *StringLocationExp =
nullptr;
1699 bool StringLocPresent =
Record.size() > 8;
1700 size_t SizeOffset = StringLocPresent ? 6 : 5;
1703 getMetadataOrConstant(SizeIsMetadata, Record[SizeOffset]);
1704 if (StringLocPresent) {
1705 StringLocationExp = getMDOrNull(Record[5]);
1707 if (
Record.size() == 10) {
1708 CharType = getMDOrNull(Record[9]);
1711 MetadataList.assignValue(
1713 (
Context, Record[1], getMDString(Record[2]),
1714 getMDOrNull(Record[3]), getMDOrNull(Record[4]),
1715 StringLocationExp, SizeInBits, Record[SizeOffset + 1],
1716 Record[SizeOffset + 2], CharType)),
1723 return error(
"Invalid record");
1727 std::optional<unsigned> DWARFAddressSpace;
1728 if (
Record.size() > 12 && Record[12])
1729 DWARFAddressSpace =
Record[12] - 1;
1732 std::optional<DIDerivedType::PtrAuthData> PtrAuthData;
1737 if (
Record.size() > 14) {
1739 Annotations = getMDOrNull(Record[13]);
1741 PtrAuthData.emplace(Record[14]);
1744 IsDistinct =
Record[0] & 1;
1745 bool SizeIsMetadata =
Record[0] & 2;
1748 Metadata *SizeInBits = getMetadataOrConstant(SizeIsMetadata, Record[7]);
1749 Metadata *OffsetInBits = getMetadataOrConstant(SizeIsMetadata, Record[9]);
1751 MetadataList.assignValue(
1753 (
Context, Record[1], getMDString(Record[2]),
1754 getMDOrNull(Record[3]), Record[4],
1755 getDITypeRefOrNull(Record[5]),
1756 getDITypeRefOrNull(Record[6]), SizeInBits, Record[8],
1757 OffsetInBits, DWARFAddressSpace, PtrAuthData, Flags,
1758 getDITypeRefOrNull(Record[11]), Annotations)),
1765 return error(
"Invalid record");
1767 IsDistinct =
Record[0] & 1;
1768 bool SizeIsMetadata =
Record[0] & 2;
1771 Metadata *SizeInBits = getMetadataOrConstant(SizeIsMetadata, Record[5]);
1773 MetadataList.assignValue(
1775 (
Context, getMDString(Record[1]),
1776 getMDOrNull(Record[2]), Record[3],
1777 getMDOrNull(Record[4]), SizeInBits, Record[6], Flags,
1778 getDITypeRefOrNull(Record[8]), getMDOrNull(Record[9]),
1779 getMDOrNull(Record[10]), getMDOrNull(Record[11]),
1780 getMDOrNull(Record[12]))),
1787 return error(
"Invalid record");
1791 IsDistinct =
Record[0] & 0x1;
1792 bool IsNotUsedInTypeRef =
Record[0] & 2;
1793 bool SizeIsMetadata =
Record[0] & 4;
1795 MDString *
Name = getMDString(Record[2]);
1800 if (Record[8] > (
uint64_t)std::numeric_limits<uint32_t>::max())
1801 return error(
"Alignment value is too large");
1802 uint32_t AlignInBits =
Record[8];
1804 uint32_t NumExtraInhabitants = (
Record.size() > 22) ?
Record[22] : 0;
1807 unsigned RuntimeLang =
Record[12];
1808 std::optional<uint32_t> EnumKind;
1811 Metadata *TemplateParams =
nullptr;
1835 if (IsImporting && !Opts.import_full_type_definitions && Identifier &&
1837 (
Tag == dwarf::DW_TAG_enumeration_type ||
1838 Tag == dwarf::DW_TAG_class_type ||
1839 Tag == dwarf::DW_TAG_structure_type ||
1840 Tag == dwarf::DW_TAG_union_type)) {
1846 StringRef NameStr =
Name->getString();
1848 TemplateParams = getMDOrNull(Record[14]);
1850 BaseType = getDITypeRefOrNull(Record[6]);
1852 OffsetInBits = getMetadataOrConstant(SizeIsMetadata, Record[9]);
1854 Elements = getMDOrNull(Record[11]);
1855 VTableHolder = getDITypeRefOrNull(Record[13]);
1856 TemplateParams = getMDOrNull(Record[14]);
1860 DataLocation = getMDOrNull(Record[17]);
1861 if (
Record.size() > 19) {
1862 Associated = getMDOrNull(Record[18]);
1863 Allocated = getMDOrNull(Record[19]);
1865 if (
Record.size() > 20) {
1866 Rank = getMDOrNull(Record[20]);
1868 if (
Record.size() > 21) {
1869 Annotations = getMDOrNull(Record[21]);
1871 if (
Record.size() > 23) {
1872 Specification = getMDOrNull(Record[23]);
1875 BitStride = getMDOrNull(Record[25]);
1881 Metadata *SizeInBits = getMetadataOrConstant(SizeIsMetadata, Record[7]);
1883 DICompositeType *CT =
nullptr;
1887 SizeInBits, AlignInBits, OffsetInBits, Specification,
1888 NumExtraInhabitants, Flags, Elements, RuntimeLang, EnumKind,
1889 VTableHolder, TemplateParams, Discriminator, DataLocation, Associated,
1890 Allocated, Rank, Annotations, BitStride);
1897 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, EnumKind,
1898 VTableHolder, TemplateParams, Identifier, Discriminator,
1899 DataLocation, Associated, Allocated, Rank, Annotations,
1900 Specification, NumExtraInhabitants, BitStride));
1901 if (!IsNotUsedInTypeRef && Identifier)
1904 MetadataList.assignValue(CT, NextMetadataNo);
1910 return error(
"Invalid record");
1911 bool IsOldTypeArray =
Record[0] < 2;
1914 IsDistinct =
Record[0] & 0x1;
1918 Types = MetadataList.upgradeTypeArray(Types);
1920 MetadataList.assignValue(
1929 return error(
"Invalid record");
1933 MetadataList.assignValue(
1936 (
Context,
Record.size() >= 8 ? getMDOrNull(Record[1]) :
nullptr,
1937 getMDOrNull(Record[0 +
Offset]), getMDString(Record[1 +
Offset]),
1938 getMDString(Record[2 +
Offset]), getMDString(Record[3 +
Offset]),
1939 getMDString(Record[4 +
Offset]),
1940 Record.size() <= 7 ? 0 : Record[7],
1941 Record.size() <= 8 ?
false : Record[8])),
1949 return error(
"Invalid record");
1952 std::optional<DIFile::ChecksumInfo<MDString *>> Checksum;
1958 if (
Record.size() > 4 && Record[3] && Record[4])
1960 getMDString(Record[4]));
1961 MetadataList.assignValue(
1963 (
Context, getMDString(Record[1]),
1964 getMDString(Record[2]), Checksum,
1965 Record.size() > 5 ? getMDString(Record[5]) :
nullptr)),
1972 return error(
"Invalid record");
1978 const auto LangVersionMask = (
uint64_t(1) << 63);
1979 const bool HasVersionedLanguage =
Record[1] & LangVersionMask;
1986 if (
Record.size() > 23 &&
1988 return error(
"Invalid DICompileUnit dialect value");
1989 const uint16_t Dialect =
1990 Record.size() > 23 ?
static_cast<uint16_t
>(
Record[23]) : uint16_t(0);
1992 auto *CU = DICompileUnit::getDistinct(
1994 HasVersionedLanguage
1995 ? DISourceLanguageName(Record[1] & ~LangVersionMask,
1996 LanguageVersion, Dialect)
1997 : DISourceLanguageName(Record[1], Dialect),
1998 getMDOrNull(Record[2]), getMDString(Record[3]), Record[4],
1999 getMDString(Record[5]), Record[6], getMDString(Record[7]), Record[8],
2000 getMDOrNull(Record[9]), getMDOrNull(Record[10]),
2001 getMDOrNull(Record[12]), getMDOrNull(Record[13]),
2002 Record.size() <= 15 ?
nullptr : getMDOrNull(Record[15]),
2003 Record.size() <= 14 ? 0 : Record[14],
2004 Record.size() <= 16 ?
true : Record[16],
2005 Record.size() <= 17 ?
false : Record[17],
2006 Record.size() <= 18 ? 0 : Record[18],
2007 Record.size() <= 19 ?
false : Record[19],
2012 Record.size() <= 20 ?
nullptr : getMDString(Record[20]),
2013 Record.size() <= 21 ?
nullptr : getMDString(Record[21]));
2015 MetadataList.assignValue(CU, NextMetadataNo);
2020 CUSubprograms.push_back({CU,
Record[11]});
2025 return error(
"Invalid record");
2027 bool HasSPFlags =
Record[0] & 4;
2040 const unsigned DIFlagMainSubprogram = 1 << 21;
2041 bool HasOldMainSubprogramFlag =
Flags & DIFlagMainSubprogram;
2042 if (HasOldMainSubprogramFlag)
2046 Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
2048 if (HasOldMainSubprogramFlag && HasSPFlags)
2049 SPFlags |= DISubprogram::SPFlagMainSubprogram;
2050 else if (!HasSPFlags)
2052 Record[7], Record[8],
2053 Record[14], Record[11],
2054 HasOldMainSubprogramFlag);
2057 IsDistinct = (
Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
2063 bool HasUnit =
Record[0] & 2;
2064 if (!HasSPFlags && HasUnit &&
Record.size() < 19)
2065 return error(
"Invalid record");
2066 if (HasSPFlags && !HasUnit)
2067 return error(
"Invalid record");
2070 bool HasThisAdj =
true;
2071 bool HasThrownTypes =
true;
2072 bool HasAnnotations =
false;
2073 bool HasTargetFuncName =
false;
2074 unsigned OffsetA = 0;
2075 unsigned OffsetB = 0;
2078 bool UsesKeyInstructions =
false;
2082 if (
Record.size() >= 19) {
2086 HasThisAdj =
Record.size() >= 20;
2087 HasThrownTypes =
Record.size() >= 21;
2089 HasAnnotations =
Record.size() >= 19;
2090 HasTargetFuncName =
Record.size() >= 20;
2091 UsesKeyInstructions =
Record.size() >= 21 ?
Record[20] : 0;
2094 Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
2098 getDITypeRefOrNull(Record[1]),
2099 getMDString(Record[2]),
2100 getMDString(Record[3]),
2101 getMDOrNull(Record[4]),
2103 getMDOrNull(Record[6]),
2104 Record[7 + OffsetA],
2105 getDITypeRefOrNull(Record[8 + OffsetA]),
2106 Record[10 + OffsetA],
2107 HasThisAdj ? Record[16 + OffsetB] : 0,
2110 HasUnit ? CUorFn :
nullptr,
2111 getMDOrNull(Record[13 + OffsetB]),
2112 getMDOrNull(Record[14 + OffsetB]),
2113 getMDOrNull(Record[15 + OffsetB]),
2114 HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
2116 HasAnnotations ? getMDOrNull(Record[18 + OffsetB])
2118 HasTargetFuncName ? getMDString(Record[19 + OffsetB])
2120 UsesKeyInstructions));
2121 MetadataList.assignValue(SP, NextMetadataNo);
2125 NewDistinctSPs.push_back(SP);
2131 if (
F->isMaterializable())
2134 FunctionsWithSPs[
F] =
SP;
2135 else if (!
F->empty())
2136 F->setSubprogram(SP);
2143 return error(
"Invalid record");
2146 MetadataList.assignValue(
2148 (
Context, getMDOrNull(Record[1]),
2149 getMDOrNull(Record[2]), Record[3], Record[4])),
2156 return error(
"Invalid record");
2159 MetadataList.assignValue(
2161 (
Context, getMDOrNull(Record[1]),
2162 getMDOrNull(Record[2]), Record[3])),
2168 IsDistinct =
Record[0] & 1;
2169 MetadataList.assignValue(
2171 (
Context, getMDOrNull(Record[1]),
2172 getMDOrNull(Record[2]), getMDString(Record[3]),
2173 getMDOrNull(Record[4]), Record[5])),
2182 Name = getMDString(Record[2]);
2183 else if (
Record.size() == 5)
2184 Name = getMDString(Record[3]);
2186 return error(
"Invalid record");
2188 IsDistinct =
Record[0] & 1;
2189 bool ExportSymbols =
Record[0] & 2;
2190 MetadataList.assignValue(
2192 (
Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
2199 return error(
"Invalid record");
2202 MetadataList.assignValue(
2204 (
Context, Record[1], Record[2], getMDString(Record[3]),
2205 getMDString(Record[4]))),
2212 return error(
"Invalid record");
2215 MetadataList.assignValue(
2217 (
Context, Record[1], Record[2], getMDOrNull(Record[3]),
2218 getMDOrNull(Record[4]))),
2225 return error(
"Invalid record");
2228 MetadataList.assignValue(
2230 (
Context, getMDString(Record[1]),
2231 getDITypeRefOrNull(Record[2]),
2232 (
Record.size() == 4) ? getMDOrNull(Record[3])
2233 : getMDOrNull(
false))),
2240 return error(
"Invalid record");
2244 MetadataList.assignValue(
2246 DITemplateValueParameter,
2247 (
Context, Record[1], getMDString(Record[2]),
2248 getDITypeRefOrNull(Record[3]),
2249 (
Record.size() == 6) ? getMDOrNull(Record[4]) : getMDOrNull(
false),
2250 (
Record.size() == 6) ? getMDOrNull(Record[5])
2251 : getMDOrNull(Record[4]))),
2258 return error(
"Invalid record");
2260 IsDistinct =
Record[0] & 1;
2266 Annotations = getMDOrNull(Record[12]);
2268 MetadataList.assignValue(
2270 (
Context, getMDOrNull(Record[1]),
2271 getMDString(Record[2]), getMDString(Record[3]),
2272 getMDOrNull(Record[4]), Record[5],
2273 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2274 getMDOrNull(Record[9]), getMDOrNull(Record[10]),
2275 Record[11], Annotations)),
2282 MetadataList.assignValue(
2285 (
Context, getMDOrNull(Record[1]), getMDString(Record[2]),
2286 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
2287 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2288 getMDOrNull(Record[10]),
nullptr, Record[11],
nullptr)),
2295 NeedUpgradeToDIGlobalVariableExpression =
true;
2296 Metadata *Expr = getMDOrNull(Record[9]);
2297 uint32_t AlignInBits = 0;
2298 if (
Record.size() > 11) {
2299 if (Record[11] > (
uint64_t)std::numeric_limits<uint32_t>::max())
2300 return error(
"Alignment value is too large");
2301 AlignInBits =
Record[11];
2303 GlobalVariable *Attach =
nullptr;
2309 Expr = DIExpression::get(
Context,
2310 {dwarf::DW_OP_constu, CI->getZExtValue(),
2311 dwarf::DW_OP_stack_value});
2318 (
Context, getMDOrNull(Record[1]), getMDString(Record[2]),
2319 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
2320 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2321 getMDOrNull(Record[10]),
nullptr, AlignInBits,
nullptr));
2323 DIGlobalVariableExpression *&DGVE = GlobalVariableExpression[DGV];
2324 if (Attach || Expr) {
2326 DGVE = DIGlobalVariableExpression::getDistinct(
2334 MetadataList.assignValue(MDNode, NextMetadataNo);
2337 return error(
"Invalid record");
2343 return error(
"Invalid DIAssignID record.");
2345 IsDistinct =
Record[0] & 1;
2347 return error(
"Invalid DIAssignID record. Must be distinct");
2356 return error(
"Invalid record");
2358 IsDistinct =
Record[0] & 1;
2359 bool HasAlignment =
Record[0] & 2;
2363 bool HasTag = !HasAlignment &&
Record.size() > 8;
2365 uint32_t AlignInBits = 0;
2368 if (Record[8] > (
uint64_t)std::numeric_limits<uint32_t>::max())
2369 return error(
"Alignment value is too large");
2372 Annotations = getMDOrNull(Record[9]);
2375 MetadataList.assignValue(
2377 (
Context, getMDOrNull(Record[1 + HasTag]),
2378 getMDString(Record[2 + HasTag]),
2379 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
2380 getDITypeRefOrNull(Record[5 + HasTag]),
2381 Record[6 + HasTag], Flags, AlignInBits, Annotations)),
2388 return error(
"Invalid record");
2390 IsDistinct =
Record[0] & 1;
2393 bool IsArtificial =
Record[0] & 2;
2394 std::optional<unsigned> CoroSuspendIdx;
2397 if (RawSuspendIdx != std::numeric_limits<uint64_t>::max()) {
2398 if (RawSuspendIdx > (
uint64_t)std::numeric_limits<unsigned>::max())
2399 return error(
"CoroSuspendIdx value is too large");
2400 CoroSuspendIdx = RawSuspendIdx;
2404 MetadataList.assignValue(
2406 (
Context, getMDOrNull(Record[1]),
2407 getMDString(Record[2]), getMDOrNull(Record[3]), Line,
2408 Column, IsArtificial, CoroSuspendIdx)),
2415 return error(
"Invalid record");
2417 IsDistinct =
Record[0] & 1;
2422 if (
Error Err = upgradeDIExpression(
Version, Elts, Buffer))
2432 return error(
"Invalid record");
2435 Metadata *Expr = getMDOrNull(Record[2]);
2437 Expr = DIExpression::get(
Context, {});
2438 MetadataList.assignValue(
2440 (
Context, getMDOrNull(Record[1]), Expr)),
2447 return error(
"Invalid record");
2450 MetadataList.assignValue(
2452 (
Context, getMDString(Record[1]),
2453 getMDOrNull(Record[2]), Record[3],
2454 getMDString(Record[5]),
2455 getMDString(Record[4]), Record[6],
2456 getDITypeRefOrNull(Record[7]))),
2463 return error(
"Invalid record");
2466 MetadataList.assignValue(
2468 getMDOrNull(Record[2]), Record[3],
2469 getDITypeRefOrNull(Record[4]),
2470 getMDOrNull(Record[5]))),
2477 return error(
"Invalid DIImportedEntity record");
2480 bool HasFile = (
Record.size() >= 7);
2481 bool HasElements = (
Record.size() >= 8);
2482 MetadataList.assignValue(
2484 (
Context, Record[1], getMDOrNull(Record[2]),
2485 getDITypeRefOrNull(Record[3]),
2486 HasFile ? getMDOrNull(Record[6]) :
nullptr,
2487 HasFile ? Record[4] : 0, getMDString(Record[5]),
2488 HasElements ? getMDOrNull(Record[7]) :
nullptr)),
2498 ++NumMDStringLoaded;
2500 MetadataList.assignValue(MD, NextMetadataNo);
2505 auto CreateNextMDString = [&](StringRef Str) {
2509 ++NumMDStringLoaded;
2513 if (
Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
2518 if (
Record.size() % 2 == 0)
2519 return error(
"Invalid record");
2520 unsigned ValueID =
Record[0];
2521 if (ValueID >= ValueList.size())
2522 return error(
"Invalid record");
2524 if (
Error Err = parseGlobalObjectAttachment(
2525 *GO, ArrayRef<uint64_t>(Record).slice(1)))
2532 if (
Error Err = parseMetadataKindRecord(Record))
2543 "Invalid record: DIArgList should not contain forward refs");
2545 return error(
"Invalid record");
2555#undef GET_OR_DISTINCT
2558Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
2559 ArrayRef<uint64_t> Record, StringRef Blob,
2560 function_ref<
void(StringRef)> CallBack) {
2565 return error(
"Invalid record: metadata strings layout");
2567 unsigned NumStrings =
Record[0];
2568 unsigned StringsOffset =
Record[1];
2570 return error(
"Invalid record: metadata strings with no strings");
2571 if (StringsOffset > Blob.
size())
2572 return error(
"Invalid record: metadata strings corrupt offset");
2574 StringRef Lengths = Blob.
slice(0, StringsOffset);
2575 SimpleBitstreamCursor
R(Lengths);
2577 StringRef Strings = Blob.
drop_front(StringsOffset);
2579 if (
R.AtEndOfStream())
2580 return error(
"Invalid record: metadata strings bad length");
2586 return error(
"Invalid record: metadata strings truncated chars");
2590 }
while (--NumStrings);
2595Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
2596 GlobalObject &GO, ArrayRef<uint64_t> Record) {
2598 for (
unsigned I = 0,
E =
Record.size();
I !=
E;
I += 2) {
2599 auto K = MDKindMap.find(Record[
I]);
2600 if (K == MDKindMap.end())
2601 return error(
"Invalid ID");
2605 return error(
"Invalid metadata attachment: expect fwd ref to MDNode");
2618 PlaceholderQueue Placeholders;
2622 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2625 switch (Entry.Kind) {
2628 return error(
"Malformed block");
2631 resolveLoadedMetadata(Placeholders, DebugInfoUpgradeMode::None);
2640 ++NumMDRecordLoaded;
2644 switch (MaybeRecord.
get()) {
2648 unsigned RecordLength =
Record.size();
2650 return error(
"Invalid record");
2651 if (RecordLength % 2 == 0) {
2653 if (
Error Err = parseGlobalObjectAttachment(
F,
Record))
2660 for (
unsigned i = 1; i != RecordLength; i = i + 2) {
2661 unsigned Kind =
Record[i];
2662 auto I = MDKindMap.find(Kind);
2663 if (
I == MDKindMap.end())
2664 return error(
"Invalid ID");
2665 if (
I->second == LLVMContext::MD_tbaa && StripTBAA)
2668 auto Idx =
Record[i + 1];
2669 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
2670 !MetadataList.lookup(Idx)) {
2673 lazyLoadOneMetadata(Idx, Placeholders);
2675 resolveLoadedMetadata(Placeholders, DebugInfoUpgradeMode::None);
2685 return error(
"Invalid metadata attachment");
2687 if (HasSeenOldLoopTags &&
I->second == LLVMContext::MD_loop)
2690 if (
I->second == LLVMContext::MD_tbaa) {
2693 }
else if (
I->second == LLVMContext::MD_tbaa_struct) {
2698 if (
I->second == LLVMContext::MD_alias_scope ||
2699 I->second == LLVMContext::MD_noalias)
2711Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
2714 return error(
"Invalid record");
2716 unsigned Kind =
Record[0];
2719 unsigned NewKind = TheModule.getMDKindID(Name.str());
2720 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
2721 return error(
"Conflicting METADATA_KIND records");
2735 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2738 switch (Entry.Kind) {
2741 return error(
"Malformed block");
2751 ++NumMDRecordLoaded;
2755 switch (MaybeCode.
get()) {
2768 Pimpl = std::move(RHS.Pimpl);
2772 : Pimpl(
std::
move(RHS.Pimpl)) {}
2780 Stream, TheModule, ValueList,
std::
move(Callbacks), IsImporting)) {}
2782Error MetadataLoader::parseMetadata(
bool ModuleLevel) {
2783 return Pimpl->parseMetadata(ModuleLevel);
2791 return Pimpl->getMetadataFwdRefOrLoad(Idx);
2795 return Pimpl->lookupSubprogramForFunction(
F);
2800 return Pimpl->parseMetadataAttachment(
F, InstructionList);
2804 return Pimpl->parseMetadataKinds();
2808 return Pimpl->setStripTBAA(StripTBAA);
2817 return Pimpl->upgradeDebugIntrinsics(
F);
2821 return Pimpl->upgradeAliasScopeList(ScopeList);
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_UNLIKELY(EXPR)
#define LLVM_LIKELY(EXPR)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
This file contains constants used for implementing Dwarf debug support.
Module.h This file contains the declarations for the Module class.
static bool lookup(const GsymReader &GR, GsymDataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)
A Lookup helper functions.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
#define GET_OR_DISTINCT(CLASS, ARGS)
Func getContext().diagnose(DiagnosticInfoUnsupported(Func
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
static bool parseMetadata(const StringRef &Input, uint64_t &FunctionHash, uint32_t &Attributes)
Parse Input that contains metadata.
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
std::pair< llvm::MachO::Target, std::string > UUID
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
Value * getValueFwdRef(unsigned Idx, Type *Ty, unsigned TyID, BasicBlock *ConstExprInsertBB)
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
LLVM_ABI Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
LLVM_ABI Expected< unsigned > skipRecord(unsigned AbbrevID)
Read the current record and discard it, returning the code for the record.
@ AF_DontPopBlockAtEnd
If this flag is used, the advance() method does not automatically pop the block scope when the end of...
Error JumpToBit(uint64_t NewBitNo)
Reset the stream to the specified bit number.
static LLVM_ABI DIArgList * get(LLVMContext &Context, ArrayRef< ValueAsMetadata * > Args)
static DIAssignID * getDistinct(LLVMContext &Context)
static LLVM_ABI DICompositeType * buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, Metadata *SizeInBits, uint32_t AlignInBits, Metadata *OffsetInBits, Metadata *Specification, uint32_t NumExtraInhabitants, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, std::optional< uint32_t > EnumKind, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank, Metadata *Annotations, Metadata *BitStride)
Build a DICompositeType with the given ODR identifier.
MDString * getRawIdentifier() const
ChecksumKind
Which algorithm (e.g.
A pair of DIGlobalVariable and DIExpression.
LLVM_ABI DIScope * getScope() const
Subprogram description. Uses SubclassData1.
LLVM_ABI void cleanupRetainedNodes()
When IR modules are merged, typically during LTO, the merged module may contain several types having ...
static LLVM_ABI DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
DISPFlags
Debug info subprogram flags.
bool isForwardDecl() const
Record of a variable value-assignment, aka a non instruction representation of the dbg....
Implements a dense probed hash-table based set.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
reference get()
Returns a reference to the stored T value.
LLVM_ABI void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
LLVM_ABI void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
This is an important class for using LLVM in a threaded context.
LLVM_ABI void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static LLVM_ABI MDString * get(LLVMContext &Context, StringRef Str)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
A Module instance is used to store all the information related to an LLVM module.
Represent a mutable reference to an array (0 or more elements consecutively in memory),...
iterator_range< op_iterator > operands()
LLVM_ABI void addOperand(MDNode *M)
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Implements a dense probed hash-table based set with some number of buckets stored inline.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
constexpr size_t size() const
Get the string size.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
The TimeTraceScope is a helper class to call the begin and end functions of the time trace profiler.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVoidTy() const
Return true if this is 'void'.
bool isMetadataTy() const
Return true if this is 'metadata'.
LLVM Value Representation.
std::pair< iterator, bool > insert(const ValueT &V)
An efficient, type-erasing, non-owning reference to a callable.
constexpr char LanguageVersion[]
Key for Kernel::Metadata::mLanguageVersion.
@ METADATA_TEMPLATE_VALUE
@ METADATA_LEXICAL_BLOCK_FILE
@ METADATA_SUBROUTINE_TYPE
@ METADATA_GLOBAL_DECL_ATTACHMENT
@ METADATA_IMPORTED_ENTITY
@ METADATA_GENERIC_SUBRANGE
@ METADATA_COMPOSITE_TYPE
@ METADATA_FIXED_POINT_TYPE
@ METADATA_GLOBAL_VAR_EXPR
@ DW_LLVM_LANG_DIALECT_max
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
@ DW_APPLE_ENUM_KIND_invalid
Enum kind for invalid results.
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
NodeAddr< CodeNode * > Code
LLVM_ABI Instruction & back() const
LLVM_ABI iterator begin() const
This is an optimization pass for GlobalISel generic memory operations.
auto cast_if_present(const Y &Val)
cast_if_present<X> - Functionally identical to cast, except that a null value is accepted.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
@ Unknown
Not known to have no common set bits.
std::error_code make_error_code(BitcodeError E)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
constexpr NextUseDistance min(NextUseDistance A, NextUseDistance B)
LLVM_ABI MDNode * upgradeInstructionLoopAttachment(MDNode &N)
Upgrade the loop attachment metadata node.
auto dyn_cast_if_present(const Y &Val)
dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case ...
auto cast_or_null(const Y &Val)
bool isa_and_nonnull(const Y &Val)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
static const DIScope * getScope(const NodeT *N)
auto dyn_cast_or_null(const Y &Val)
const BitReaderOptions & getBitReaderOptions(const LLVMContext &C)
bool mayBeOldLoopAttachmentTag(StringRef Name)
Check whether a string looks like an old loop attachment tag.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
LLVM_ABI MDNode * UpgradeTBAAStructNode(MDNode &TBAAStructNode)
If the given !tbaa.struct node has old-style scalar field tags, return an equivalent node with each f...
LLVM_ABI MDNode * UpgradeAliasScopeList(MDNode &ScopeList, DenseMap< MDNode *, MDNode * > &UpgradedAliasScopes)
Mark any domains from scopes in ScopeList that don't have a disjointness flag as non-disjoint.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
MutableArrayRef(T &OneElt) -> MutableArrayRef< T >
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
@ Ref
The access may reference the value stored in memory.
constexpr NextUseDistance max(NextUseDistance A, NextUseDistance B)
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
constexpr unsigned BitWidth
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI APInt readWideAPInt(ArrayRef< uint64_t > Vals, unsigned TypeBits)
@ End
Run the machine verifier once, at the end of the pipeline.
LLVM_ABI MDNode * UpgradeTBAANode(MDNode &TBAANode)
If the given TBAA tag uses the scalar TBAA format, create a new node corresponding to the upgrade to ...
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
void consumeError(Error Err)
Consume a Error without doing anything.
Implement std::hash so that hash_code can be used in STL containers.
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...