60 #include <type_traits>
69 #define DEBUG_TYPE "bitcode-reader"
71 STATISTIC(NumMDStringLoaded,
"Number of MDStrings loaded");
72 STATISTIC(NumMDNodeTemporary,
"Number of MDNode::Temporary created");
73 STATISTIC(NumMDRecordLoaded,
"Number of Metadata records loaded");
79 cl::desc(
"Import full type definitions for ThinLTO."));
83 cl::desc(
"Force disable the lazy-loading on-demand of metadata when "
84 "loading bitcode for importing."));
88 static int64_t unrotateSign(
uint64_t U) {
return (U & 1) ? ~(U >> 1) : U >> 1; }
90 class BitcodeReaderMetadataList {
117 unsigned RefsUpperBound;
120 BitcodeReaderMetadataList(
LLVMContext &
C,
size_t RefsUpperBound)
122 RefsUpperBound(
std::
min((size_t)
std::numeric_limits<unsigned>::
max(),
126 unsigned size()
const {
return MetadataPtrs.size(); }
127 void resize(
unsigned N) { MetadataPtrs.
resize(
N); }
130 Metadata *back()
const {
return MetadataPtrs.back(); }
131 void pop_back() { MetadataPtrs.pop_back(); }
132 bool empty()
const {
return MetadataPtrs.empty(); }
135 assert(
i < MetadataPtrs.size());
136 return MetadataPtrs[
i];
140 if (
I < MetadataPtrs.size())
141 return MetadataPtrs[
I];
145 void shrinkTo(
unsigned N) {
146 assert(
N <=
size() &&
"Invalid shrinkTo request!");
148 assert(UnresolvedNodes.
empty() &&
"Unexpected unresolved node");
154 Metadata *getMetadataFwdRef(
unsigned Idx);
160 Metadata *getMetadataIfResolved(
unsigned Idx);
162 MDNode *getMDNodeFwdRefOrNull(
unsigned Idx);
163 void assignValue(
Metadata *MD,
unsigned Idx);
164 void tryToResolveCycles();
166 int getNextFwdRef() {
184 void BitcodeReaderMetadataList::assignValue(
Metadata *MD,
unsigned Idx) {
185 if (
auto *MDN = dyn_cast<MDNode>(MD))
186 if (!MDN->isResolved())
187 UnresolvedNodes.
insert(Idx);
204 TempMDTuple PrevMD(cast<MDTuple>(OldMD.
get()));
205 PrevMD->replaceAllUsesWith(MD);
209 Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(
unsigned Idx) {
211 if (Idx >= RefsUpperBound)
217 if (
Metadata *MD = MetadataPtrs[Idx])
224 ++NumMDNodeTemporary;
226 MetadataPtrs[Idx].reset(MD);
230 Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(
unsigned Idx) {
232 if (
auto *
N = dyn_cast_or_null<MDNode>(MD))
233 if (!
N->isResolved())
238 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(
unsigned Idx) {
239 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
242 void BitcodeReaderMetadataList::tryToResolveCycles() {
248 for (
const auto &Ref : OldTypeRefs.FwdDecls)
249 OldTypeRefs.Final.insert(Ref);
250 OldTypeRefs.FwdDecls.clear();
254 for (
const auto &Array : OldTypeRefs.Arrays)
255 Array.second->replaceAllUsesWith(resolveTypeRefArray(
Array.first.get()));
256 OldTypeRefs.Arrays.clear();
261 for (
const auto &Ref : OldTypeRefs.Unknown) {
263 Ref.second->replaceAllUsesWith(CT);
265 Ref.second->replaceAllUsesWith(
Ref.first);
267 OldTypeRefs.Unknown.clear();
269 if (UnresolvedNodes.
empty())
274 for (
unsigned I : UnresolvedNodes) {
275 auto &MD = MetadataPtrs[
I];
276 auto *
N = dyn_cast_or_null<MDNode>(MD);
280 assert(!
N->isTemporary() &&
"Unexpected forward reference");
285 UnresolvedNodes.clear();
288 void BitcodeReaderMetadataList::addTypeRef(
MDString &
UUID,
292 OldTypeRefs.FwdDecls.insert(std::make_pair(&
UUID, &CT));
294 OldTypeRefs.Final.insert(std::make_pair(&
UUID, &CT));
298 auto *
UUID = dyn_cast_or_null<MDString>(MaybeUUID);
302 if (
auto *CT = OldTypeRefs.Final.lookup(
UUID))
305 auto &
Ref = OldTypeRefs.Unknown[
UUID];
311 Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(
Metadata *MaybeTuple) {
312 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
313 if (!Tuple || Tuple->isDistinct())
317 if (!Tuple->isTemporary())
318 return resolveTypeRefArray(Tuple);
322 OldTypeRefs.Arrays.emplace_back(
323 std::piecewise_construct, std::forward_as_tuple(Tuple),
325 return OldTypeRefs.Arrays.back().second.get();
328 Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(
Metadata *MaybeTuple) {
329 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
330 if (!Tuple || Tuple->isDistinct())
335 Ops.
reserve(Tuple->getNumOperands());
336 for (
Metadata *MD : Tuple->operands())
337 Ops.push_back(upgradeTypeRef(MD));
344 class PlaceholderQueue {
347 std::deque<DistinctMDOperandPlaceholder> PHs;
350 ~PlaceholderQueue() {
352 "PlaceholderQueue hasn't been flushed before being destroyed");
354 bool empty()
const {
return PHs.empty(); }
356 void flush(BitcodeReaderMetadataList &MetadataList);
360 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
362 for (
auto &PH : PHs) {
363 auto ID = PH.getID();
364 auto *MD = MetadataList.lookup(
ID);
369 auto *
N = dyn_cast_or_null<MDNode>(MD);
370 if (
N &&
N->isTemporary())
379 PHs.emplace_back(
ID);
383 void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
384 while (!PHs.empty()) {
385 auto *MD = MetadataList.lookup(PHs.front().getID());
386 assert(MD &&
"Flushing placeholder on unassigned MD");
388 if (
auto *MDN = dyn_cast<MDNode>(MD))
389 assert(MDN->isResolved() &&
390 "Flushing Placeholder while cycles aren't resolved");
392 PHs.front().replaceUseWith(MD);
400 return make_error<StringError>(
405 BitcodeReaderMetadataList MetadataList;
418 std::vector<StringRef> MDStringRef;
422 MDString *lazyLoadOneMDString(
unsigned Idx);
425 std::vector<uint64_t> GlobalMetadataBitPosIndex;
430 uint64_t GlobalDeclAttachmentPos = 0;
435 unsigned NumGlobalDeclAttachSkipped = 0;
436 unsigned NumGlobalDeclAttachParsed = 0;
449 void lazyLoadOneMetadata(
unsigned Idx, PlaceholderQueue &Placeholders);
453 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
462 bool StripTBAA =
false;
463 bool HasSeenOldLoopTags =
false;
464 bool NeedUpgradeToDIGlobalVariableExpression =
false;
465 bool NeedDeclareExpressionUpgrade =
false;
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)
484 if (
auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
485 for (
auto &
Op : SPs->operands())
486 if (
auto *SP = dyn_cast_or_null<DISubprogram>(
Op))
487 SP->replaceUnit(CU_SP.first);
488 CUSubprograms.clear();
492 void upgradeCUVariables() {
493 if (!NeedUpgradeToDIGlobalVariableExpression)
498 for (
unsigned I = 0,
E = CUNodes->getNumOperands();
I !=
E; ++
I) {
499 auto *
CU = cast<DICompileUnit>(CUNodes->getOperand(
I));
500 if (
auto *GVs = dyn_cast_or_null<MDTuple>(
CU->getRawGlobalVariables()))
501 for (
unsigned I = 0;
I < GVs->getNumOperands();
I++)
503 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(
I))) {
506 GVs->replaceOperandWith(
I, DGVE);
511 for (
auto &GV : TheModule.
globals()) {
513 GV.getMetadata(LLVMContext::MD_dbg, MDs);
514 GV.eraseMetadata(LLVMContext::MD_dbg);
516 if (
auto *DGV = dyn_cast<DIGlobalVariable>(MD)) {
519 GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
521 GV.addMetadata(LLVMContext::MD_dbg, *MD);
527 void upgradeDeclareExpressions(
Function &
F) {
528 if (!NeedDeclareExpressionUpgrade)
533 if (
auto *DDI = dyn_cast<DbgDeclareInst>(&
I))
534 if (
auto *DIExpr = DDI->getExpression())
535 if (DIExpr->startsWithDeref() &&
536 isa_and_nonnull<Argument>(DDI->getAddress())) {
538 Ops.
append(std::next(DIExpr->elements_begin()),
539 DIExpr->elements_end());
548 auto N = Expr.
size();
549 switch (FromVersion) {
551 return error(
"Invalid record");
553 if (
N >= 3 && Expr[
N - 3] == dwarf::DW_OP_bit_piece)
558 if (
N && Expr[0] == dwarf::DW_OP_deref) {
559 auto End = Expr.
end();
560 if (Expr.
size() >= 3 &&
562 End = std::prev(End, 3);
564 *std::prev(End) = dwarf::DW_OP_deref;
566 NeedDeclareExpressionUpgrade =
true;
572 while (!SubExpr.empty()) {
577 switch (SubExpr.front()) {
581 case dwarf::DW_OP_constu:
582 case dwarf::DW_OP_minus:
583 case dwarf::DW_OP_plus:
593 HistoricSize =
std::min(SubExpr.size(), HistoricSize);
596 switch (SubExpr.front()) {
597 case dwarf::DW_OP_plus:
598 Buffer.push_back(dwarf::DW_OP_plus_uconst);
601 case dwarf::DW_OP_minus:
602 Buffer.push_back(dwarf::DW_OP_constu);
604 Buffer.push_back(dwarf::DW_OP_minus);
607 Buffer.push_back(*SubExpr.begin());
613 SubExpr = SubExpr.slice(HistoricSize);
626 void upgradeDebugInfo() {
627 upgradeCUSubprograms();
628 upgradeCUVariables();
636 : MetadataList(TheModule.getContext(), Stream.SizeInBytes()),
637 ValueList(ValueList), Stream(Stream),
Context(TheModule.getContext()),
638 TheModule(TheModule), getTypeByID(
std::
move(getTypeByID)),
639 IsImporting(IsImporting) {}
643 bool hasFwdRefs()
const {
return MetadataList.hasFwdRefs(); }
646 if (
ID < MDStringRef.size())
647 return lazyLoadOneMDString(
ID);
648 if (
auto *MD = MetadataList.lookup(
ID))
652 if (
ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
653 PlaceholderQueue Placeholders;
654 lazyLoadOneMetadata(
ID, Placeholders);
655 resolveForwardRefsAndPlaceholders(Placeholders);
656 return MetadataList.lookup(
ID);
658 return MetadataList.getMetadataFwdRef(
ID);
662 return FunctionsWithSPs.
lookup(
F);
675 unsigned size()
const {
return MetadataList.size(); }
681 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
682 IndexCursor = Stream;
684 GlobalDeclAttachmentPos = 0;
687 uint64_t SavedPos = IndexCursor.GetCurrentBitNo();
691 .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
695 switch (Entry.Kind) {
696 case BitstreamEntry::SubBlock:
698 return error(
"Malformed block");
699 case BitstreamEntry::EndBlock: {
702 case BitstreamEntry::Record: {
705 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
707 if (
Error E = IndexCursor.skipRecord(Entry.ID).moveInto(
Code))
712 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
717 IndexCursor.readRecord(Entry.ID,
Record, &Blob))
720 return MaybeRecord.takeError();
721 unsigned NumStrings =
Record[0];
722 MDStringRef.reserve(NumStrings);
723 auto IndexNextMDString = [&](
StringRef Str) {
724 MDStringRef.push_back(Str);
726 if (
auto Err = parseMetadataStrings(
Record, Blob, IndexNextMDString))
733 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
737 IndexCursor.readRecord(Entry.ID,
Record))
740 return MaybeRecord.takeError();
742 return error(
"Invalid record");
744 auto BeginPos = IndexCursor.GetCurrentBitNo();
745 if (
Error Err = IndexCursor.JumpToBit(BeginPos +
Offset))
748 IndexCursor.advanceSkippingSubblocks(
749 BitstreamCursor::AF_DontPopBlockAtEnd);
752 Entry = MaybeEntry.
get();
753 assert(Entry.Kind == BitstreamEntry::Record &&
754 "Corrupted bitcode: Expected `Record` when trying to find the "
758 IndexCursor.readRecord(Entry.ID,
Record))
760 "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
761 "find the Metadata index");
763 return MaybeCode.takeError();
765 auto CurrentValue = BeginPos;
766 GlobalMetadataBitPosIndex.reserve(
Record.size());
767 for (
auto &Elt :
Record) {
769 GlobalMetadataBitPosIndex.push_back(CurrentValue);
776 return error(
"Corrupted Metadata block");
779 if (
Error Err = IndexCursor.JumpToBit(CurrentPos))
785 IndexCursor.readRecord(Entry.ID,
Record)) {
786 Code = MaybeCode.get();
789 return MaybeCode.takeError();
794 Code = MaybeCode.get();
796 return MaybeCode.takeError();
805 return MaybeNextBitCode.takeError();
810 for (
unsigned i = 0;
i !=
Size; ++
i) {
816 assert(MD &&
"Invalid metadata: expect fwd ref to MDNode");
822 if (!GlobalDeclAttachmentPos)
823 GlobalDeclAttachmentPos = SavedPos;
825 NumGlobalDeclAttachSkipped++;
868 GlobalMetadataBitPosIndex.clear();
882 Expected<bool> MetadataLoader::MetadataLoaderImpl::loadGlobalDeclAttachments() {
884 if (!GlobalDeclAttachmentPos)
898 .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
902 switch (Entry.Kind) {
903 case BitstreamEntry::SubBlock:
905 return error(
"Malformed block");
906 case BitstreamEntry::EndBlock:
908 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
910 case BitstreamEntry::Record:
920 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
924 NumGlobalDeclAttachParsed++;
935 return MaybeRecord.takeError();
936 if (
Record.size() % 2 == 0)
937 return error(
"Invalid record");
938 unsigned ValueID =
Record[0];
939 if (ValueID >= ValueList.
size())
940 return error(
"Invalid record");
941 if (
auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) {
946 if (
Error Err = parseGlobalObjectAttachment(
958 if (!ModuleLevel && MetadataList.hasFwdRefs())
959 return error(
"Invalid metadata: fwd refs into function blocks");
963 auto EntryPos = Stream.GetCurrentBitNo();
969 PlaceholderQueue Placeholders;
973 if (ModuleLevel && IsImporting && MetadataList.empty() &&
975 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
977 return SuccessOrErr.takeError();
978 if (SuccessOrErr.get()) {
981 MetadataList.resize(MDStringRef.size() +
982 GlobalMetadataBitPosIndex.size());
987 SuccessOrErr = loadGlobalDeclAttachments();
989 return SuccessOrErr.takeError();
990 assert(SuccessOrErr.get());
994 resolveForwardRefsAndPlaceholders(Placeholders);
998 Stream.ReadBlockEnd();
999 if (
Error Err = IndexCursor.JumpToBit(EntryPos))
1001 if (
Error Err = Stream.SkipBlock()) {
1005 return Error::success();
1007 return Error::success();
1012 unsigned NextMetadataNo = MetadataList.size();
1017 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
1020 switch (Entry.Kind) {
1021 case BitstreamEntry::SubBlock:
1023 return error(
"Malformed block");
1024 case BitstreamEntry::EndBlock:
1025 resolveForwardRefsAndPlaceholders(Placeholders);
1027 return Error::success();
1028 case BitstreamEntry::Record:
1036 ++NumMDRecordLoaded;
1038 Stream.readRecord(Entry.ID,
Record, &Blob)) {
1039 if (
Error Err = parseOneMetadata(
Record, MaybeCode.
get(), Placeholders,
1040 Blob, NextMetadataNo))
1047 MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(
unsigned ID) {
1048 ++NumMDStringLoaded;
1050 return cast<MDString>(MD);
1052 MetadataList.assignValue(MDS,
ID);
1056 void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
1057 unsigned ID, PlaceholderQueue &Placeholders) {
1058 assert(
ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
1059 assert(
ID >= MDStringRef.size() &&
"Unexpected lazy-loading of MDString");
1061 if (
auto *MD = MetadataList.lookup(
ID)) {
1062 auto *
N = cast<MDNode>(MD);
1063 if (!
N->isTemporary())
1068 if (
Error Err = IndexCursor.JumpToBit(
1069 GlobalMetadataBitPosIndex[
ID - MDStringRef.size()]))
1073 if (
Error E = IndexCursor.advanceSkippingSubblocks().moveInto(Entry))
1077 ++NumMDRecordLoaded;
1079 IndexCursor.readRecord(Entry.ID,
Record, &Blob)) {
1081 parseOneMetadata(
Record, MaybeCode.
get(), Placeholders, Blob,
ID))
1091 void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
1092 PlaceholderQueue &Placeholders) {
1096 Placeholders.getTemporaries(MetadataList, Temporaries);
1099 if (Temporaries.
empty() && !MetadataList.hasFwdRefs())
1104 for (
auto ID : Temporaries)
1105 lazyLoadOneMetadata(
ID, Placeholders);
1106 Temporaries.clear();
1110 while (MetadataList.hasFwdRefs())
1111 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
1116 MetadataList.tryToResolveCycles();
1120 Placeholders.flush(MetadataList);
1123 Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
1125 PlaceholderQueue &Placeholders,
StringRef Blob,
unsigned &NextMetadataNo) {
1127 bool IsDistinct =
false;
1128 auto getMD = [&](
unsigned ID) ->
Metadata * {
1129 if (
ID < MDStringRef.size())
1130 return lazyLoadOneMDString(
ID);
1132 if (
auto *MD = MetadataList.lookup(
ID))
1136 if (
ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
1140 MetadataList.getMetadataFwdRef(NextMetadataNo);
1141 lazyLoadOneMetadata(
ID, Placeholders);
1142 return MetadataList.lookup(
ID);
1145 return MetadataList.getMetadataFwdRef(
ID);
1147 if (
auto *MD = MetadataList.getMetadataIfResolved(
ID))
1149 return &Placeholders.getPlaceholderOp(
ID);
1151 auto getMDOrNull = [&](
unsigned ID) ->
Metadata * {
1153 return getMD(
ID - 1);
1156 auto getMDOrNullWithoutPlaceholders = [&](
unsigned ID) ->
Metadata * {
1158 return MetadataList.getMetadataFwdRef(
ID - 1);
1161 auto getMDString = [&](
unsigned ID) ->
MDString * {
1164 auto MDS = getMDOrNull(
ID);
1165 return cast_or_null<MDString>(MDS);
1169 auto getDITypeRefOrNull = [&](
unsigned ID) {
1170 return MetadataList.upgradeTypeRef(getMDOrNull(
ID));
1173 #define GET_OR_DISTINCT(CLASS, ARGS) \
1174 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1186 ++NumMDRecordLoaded;
1189 return error(
"METADATA_NAME not followed by METADATA_NAMED_NODE");
1191 return MaybeNextBitCode.takeError();
1196 for (
unsigned i = 0;
i !=
Size; ++
i) {
1199 return error(
"Invalid named metadata: expect fwd ref to MDNode");
1208 if (
Record.size() % 2 == 1)
1209 return error(
"Invalid record");
1213 auto dropRecord = [&] {
1217 if (
Record.size() != 2) {
1222 unsigned TyID =
Record[0];
1223 Type *Ty = getTypeByID(TyID);
1232 return error(
"Invalid value reference from old fn metadata");
1240 if (
Record.size() % 2 == 1)
1241 return error(
"Invalid record");
1245 for (
unsigned i = 0;
i !=
Size;
i += 2) {
1247 Type *Ty = getTypeByID(TyID);
1249 return error(
"Invalid record");
1251 Elts.push_back(getMD(
Record[
i + 1]));
1256 return error(
"Invalid value reference from old metadata");
1258 assert(isa<ConstantAsMetadata>(MD) &&
1259 "Expected non-function-local metadata");
1262 Elts.push_back(
nullptr);
1270 return error(
"Invalid record");
1272 unsigned TyID =
Record[0];
1273 Type *Ty = getTypeByID(TyID);
1275 return error(
"Invalid record");
1280 return error(
"Invalid value reference from metadata");
1293 Elts.push_back(getMDOrNull(
ID));
1294 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(
Context, Elts)
1302 return error(
"Invalid record");
1305 unsigned Line =
Record[1];
1306 unsigned Column =
Record[2];
1310 MetadataList.assignValue(
1319 return error(
"Invalid record");
1326 return error(
"Invalid record");
1328 auto *Header = getMDString(
Record[3]);
1330 for (
unsigned I = 4,
E =
Record.size();
I !=
E; ++
I)
1331 DwarfOps.push_back(getMDOrNull(
Record[
I]));
1332 MetadataList.assignValue(
1348 switch (
Record[0] >> 1) {
1355 unrotateSign(
Record[2])));
1363 return error(
"Invalid record: Unsupported version of DISubrange");
1366 MetadataList.assignValue(Val, NextMetadataNo);
1367 IsDistinct =
Record[0] & 1;
1376 getMDOrNull(
Record[4])));
1378 MetadataList.assignValue(Val, NextMetadataNo);
1379 IsDistinct =
Record[0] & 1;
1385 return error(
"Invalid record");
1387 IsDistinct =
Record[0] & 1;
1388 bool IsUnsigned =
Record[0] & 2;
1389 bool IsBigInt =
Record[0] & 4;
1394 const size_t NumWords =
Record.size() - 3;
1399 MetadataList.assignValue(
1408 return error(
"Invalid record");
1415 MetadataList.assignValue(
1425 return error(
"Invalid record");
1428 bool SizeIs8 =
Record.size() == 8;
1431 Metadata *StringLocationExp = SizeIs8 ? nullptr : getMDOrNull(
Record[5]);
1432 unsigned Offset = SizeIs8 ? 5 : 6;
1433 MetadataList.assignValue(
1445 return error(
"Invalid record");
1451 DWARFAddressSpace =
Record[12] - 1;
1459 MetadataList.assignValue(
1463 getDITypeRefOrNull(
Record[5]),
1465 Record[9], DWARFAddressSpace, Flags,
1473 return error(
"Invalid record");
1477 IsDistinct =
Record[0] & 0x1;
1478 bool IsNotUsedInTypeRef =
Record[0] >= 2;
1482 unsigned Line =
Record[4];
1487 return error(
"Alignment value is too large");
1492 unsigned RuntimeLang =
Record[12];
1494 Metadata *TemplateParams =
nullptr;
1510 (
Tag == dwarf::DW_TAG_enumeration_type ||
1511 Tag == dwarf::DW_TAG_class_type ||
1512 Tag == dwarf::DW_TAG_structure_type ||
1513 Tag == dwarf::DW_TAG_union_type)) {
1514 Flags = Flags | DINode::FlagFwdDecl;
1522 TemplateParams = getMDOrNull(
Record[14]);
1526 OffsetInBits =
Record[9];
1527 Elements = getMDOrNull(
Record[11]);
1528 VTableHolder = getDITypeRefOrNull(
Record[13]);
1529 TemplateParams = getMDOrNull(
Record[14]);
1531 Discriminator = getMDOrNull(
Record[16]);
1533 DataLocation = getMDOrNull(
Record[17]);
1534 if (
Record.size() > 19) {
1535 Associated = getMDOrNull(
Record[18]);
1536 Allocated = getMDOrNull(
Record[19]);
1538 if (
Record.size() > 20) {
1539 Rank = getMDOrNull(
Record[20]);
1541 if (
Record.size() > 21) {
1547 CT = DICompositeType::buildODRType(
1549 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1550 VTableHolder, TemplateParams, Discriminator, DataLocation, Associated,
1557 SizeInBits, AlignInBits, OffsetInBits, Flags,
1558 Elements, RuntimeLang, VTableHolder, TemplateParams,
1559 Identifier, Discriminator, DataLocation, Associated,
1562 MetadataList.addTypeRef(*
Identifier, *cast<DICompositeType>(CT));
1564 MetadataList.assignValue(CT, NextMetadataNo);
1570 return error(
"Invalid record");
1571 bool IsOldTypeRefArray =
Record[0] < 2;
1574 IsDistinct =
Record[0] & 0x1;
1578 Types = MetadataList.upgradeTypeRefArray(Types);
1580 MetadataList.assignValue(
1589 return error(
"Invalid record");
1593 MetadataList.assignValue(
1609 return error(
"Invalid record");
1621 MetadataList.assignValue(
1633 return error(
"Invalid record");
1638 auto *
CU = DICompileUnit::getDistinct(
1643 Record.size() <= 15 ?
nullptr : getMDOrNull(
Record[15]),
1649 Record.size() <= 20 ?
nullptr : getMDString(
Record[20]),
1650 Record.size() <= 21 ?
nullptr : getMDString(
Record[21]));
1652 MetadataList.assignValue(
CU, NextMetadataNo);
1657 CUSubprograms.push_back({
CU, SPs});
1662 return error(
"Invalid record");
1664 bool HasSPFlags =
Record[0] & 4;
1677 const unsigned DIFlagMainSubprogram = 1 << 21;
1678 bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
1679 if (HasOldMainSubprogramFlag)
1683 Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
1685 if (HasOldMainSubprogramFlag && HasSPFlags)
1686 SPFlags |= DISubprogram::SPFlagMainSubprogram;
1687 else if (!HasSPFlags)
1688 SPFlags = DISubprogram::toSPFlags(
1691 HasOldMainSubprogramFlag);
1694 IsDistinct = (
Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
1700 bool HasUnit =
Record[0] & 2;
1701 if (!HasSPFlags && HasUnit &&
Record.size() < 19)
1702 return error(
"Invalid record");
1703 if (HasSPFlags && !HasUnit)
1704 return error(
"Invalid record");
1707 bool HasThisAdj =
true;
1708 bool HasThrownTypes =
true;
1709 bool HasAnnotations =
false;
1710 bool HasTargetFuncName =
false;
1711 unsigned OffsetA = 0;
1712 unsigned OffsetB = 0;
1716 if (
Record.size() >= 19) {
1720 HasThisAdj =
Record.size() >= 20;
1721 HasThrownTypes =
Record.size() >= 21;
1723 HasAnnotations =
Record.size() >= 19;
1724 HasTargetFuncName =
Record.size() >= 20;
1730 getDITypeRefOrNull(
Record[1]),
1737 getDITypeRefOrNull(
Record[8 + OffsetA]),
1739 HasThisAdj ?
Record[16 + OffsetB] : 0,
1742 HasUnit ? CUorFn :
nullptr,
1743 getMDOrNull(
Record[13 + OffsetB]),
1744 getMDOrNull(
Record[14 + OffsetB]),
1745 getMDOrNull(
Record[15 + OffsetB]),
1746 HasThrownTypes ? getMDOrNull(
Record[17 + OffsetB])
1748 HasAnnotations ? getMDOrNull(
Record[18 + OffsetB])
1750 HasTargetFuncName ? getMDString(
Record[19 + OffsetB])
1753 MetadataList.assignValue(SP, NextMetadataNo);
1758 if (
auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1759 if (
auto *
F = dyn_cast<Function>(CMD->getValue())) {
1760 if (
F->isMaterializable())
1763 FunctionsWithSPs[
F] = SP;
1764 else if (!
F->empty())
1765 F->setSubprogram(SP);
1772 return error(
"Invalid record");
1775 MetadataList.assignValue(
1785 return error(
"Invalid record");
1788 MetadataList.assignValue(
1797 IsDistinct =
Record[0] & 1;
1798 MetadataList.assignValue(
1812 else if (
Record.size() == 5)
1815 return error(
"Invalid record");
1817 IsDistinct =
Record[0] & 1;
1818 bool ExportSymbols =
Record[0] & 2;
1819 MetadataList.assignValue(
1828 return error(
"Invalid record");
1831 MetadataList.assignValue(
1834 getMDString(
Record[4]))),
1841 return error(
"Invalid record");
1844 MetadataList.assignValue(
1847 getMDOrNull(
Record[4]))),
1854 return error(
"Invalid record");
1857 MetadataList.assignValue(
1860 getDITypeRefOrNull(
Record[2]),
1862 : getMDOrNull(
false))),
1869 return error(
"Invalid record");
1873 MetadataList.assignValue(
1877 getDITypeRefOrNull(
Record[3]),
1878 (
Record.size() == 6) ? getMDOrNull(
Record[4]) : getMDOrNull(
false),
1880 : getMDOrNull(
Record[4]))),
1887 return error(
"Invalid record");
1889 IsDistinct =
Record[0] & 1;
1897 MetadataList.assignValue(
1911 MetadataList.assignValue(
1917 getMDOrNull(
Record[10]),
nullptr,
Record[11],
nullptr)),
1924 NeedUpgradeToDIGlobalVariableExpression =
true;
1927 if (
Record.size() > 11) {
1929 return error(
"Alignment value is too large");
1930 AlignInBits =
Record[11];
1933 if (
auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1934 if (
auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1937 }
else if (
auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1939 {dwarf::DW_OP_constu, CI->getZExtValue(),
1940 dwarf::DW_OP_stack_value});
1950 getMDOrNull(
Record[10]),
nullptr, AlignInBits,
nullptr));
1954 DGVE = DIGlobalVariableExpression::getDistinct(
1960 MetadataList.assignValue(
MDNode, NextMetadataNo);
1963 return error(
"Invalid record");
1970 return error(
"Invalid record");
1972 IsDistinct =
Record[0] & 1;
1973 bool HasAlignment =
Record[0] & 2;
1977 bool HasTag = !HasAlignment &&
Record.size() > 8;
1983 return error(
"Alignment value is too large");
1989 MetadataList.assignValue(
1992 getMDString(
Record[2 + HasTag]),
1994 getDITypeRefOrNull(
Record[5 + HasTag]),
2002 return error(
"Invalid record");
2004 IsDistinct =
Record[0] & 1;
2005 MetadataList.assignValue(
2015 return error(
"Invalid record");
2017 IsDistinct =
Record[0] & 1;
2022 if (
Error Err = upgradeDIExpression(
Version, Elts, Buffer))
2032 return error(
"Invalid record");
2038 MetadataList.assignValue(
2047 return error(
"Invalid record");
2050 MetadataList.assignValue(
2062 return error(
"Invalid DIImportedEntity record");
2065 bool HasFile = (
Record.size() >= 7);
2066 bool HasElements = (
Record.size() >= 8);
2067 MetadataList.assignValue(
2070 getDITypeRefOrNull(
Record[3]),
2071 HasFile ? getMDOrNull(
Record[6]) :
nullptr,
2073 HasElements ? getMDOrNull(
Record[7]) :
nullptr)),
2083 ++NumMDStringLoaded;
2085 MetadataList.assignValue(MD, NextMetadataNo);
2090 auto CreateNextMDString = [&](
StringRef Str) {
2091 ++NumMDStringLoaded;
2095 if (
Error Err = parseMetadataStrings(
Record, Blob, CreateNextMDString))
2100 if (
Record.size() % 2 == 0)
2101 return error(
"Invalid record");
2102 unsigned ValueID =
Record[0];
2103 if (ValueID >= ValueList.
size())
2104 return error(
"Invalid record");
2105 if (
auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
2106 if (
Error Err = parseGlobalObjectAttachment(
2123 if (isa<MDNode>(MD) && cast<MDNode>(MD)->isTemporary())
2125 "Invalid record: DIArgList should not contain forward refs");
2126 if (!isa<ValueAsMetadata>(MD))
2127 return error(
"Invalid record");
2128 Elts.push_back(cast<ValueAsMetadata>(MD));
2136 return Error::success();
2137 #undef GET_OR_DISTINCT
2140 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
2147 return error(
"Invalid record: metadata strings layout");
2149 unsigned NumStrings =
Record[0];
2150 unsigned StringsOffset =
Record[1];
2152 return error(
"Invalid record: metadata strings with no strings");
2153 if (StringsOffset > Blob.
size())
2154 return error(
"Invalid record: metadata strings corrupt offset");
2161 if (
R.AtEndOfStream())
2162 return error(
"Invalid record: metadata strings bad length");
2167 if (Strings.size() <
Size)
2168 return error(
"Invalid record: metadata strings truncated chars");
2170 CallBack(Strings.slice(0,
Size));
2171 Strings = Strings.drop_front(
Size);
2172 }
while (--NumStrings);
2174 return Error::success();
2177 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
2180 for (
unsigned I = 0,
E =
Record.size();
I !=
E;
I += 2) {
2182 if (K == MDKindMap.
end())
2183 return error(
"Invalid ID");
2185 dyn_cast_or_null<MDNode>(getMetadataFwdRefOrLoad(
Record[
I + 1]));
2187 return error(
"Invalid metadata attachment: expect fwd ref to MDNode");
2190 return Error::success();
2200 PlaceholderQueue Placeholders;
2204 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2207 switch (Entry.Kind) {
2208 case BitstreamEntry::SubBlock:
2210 return error(
"Malformed block");
2211 case BitstreamEntry::EndBlock:
2212 resolveForwardRefsAndPlaceholders(Placeholders);
2213 return Error::success();
2214 case BitstreamEntry::Record:
2221 ++NumMDRecordLoaded;
2225 switch (MaybeRecord.
get()) {
2229 unsigned RecordLength =
Record.size();
2231 return error(
"Invalid record");
2232 if (RecordLength % 2 == 0) {
2234 if (
Error Err = parseGlobalObjectAttachment(
F,
Record))
2241 for (
unsigned i = 1;
i != RecordLength;
i =
i + 2) {
2244 if (
I == MDKindMap.
end())
2245 return error(
"Invalid ID");
2246 if (
I->second == LLVMContext::MD_tbaa && StripTBAA)
2250 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
2251 !MetadataList.lookup(Idx)) {
2254 lazyLoadOneMetadata(Idx, Placeholders);
2255 resolveForwardRefsAndPlaceholders(Placeholders);
2258 Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
2259 if (isa<LocalAsMetadata>(Node))
2263 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
2265 return error(
"Invalid metadata attachment");
2267 if (HasSeenOldLoopTags &&
I->second == LLVMContext::MD_loop)
2270 if (
I->second == LLVMContext::MD_tbaa) {
2283 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
2286 return error(
"Invalid record");
2292 if (!MDKindMap.
insert(std::make_pair(
Kind, NewKind)).second)
2293 return error(
"Conflicting METADATA_KIND records");
2294 return Error::success();
2307 if (
Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2310 switch (Entry.Kind) {
2311 case BitstreamEntry::SubBlock:
2313 return error(
"Malformed block");
2314 case BitstreamEntry::EndBlock:
2315 return Error::success();
2316 case BitstreamEntry::Record:
2323 ++NumMDRecordLoaded;
2327 switch (MaybeCode.
get()) {
2352 Stream, TheModule, ValueList,
std::
move(getTypeByID), IsImporting)) {}
2354 Error MetadataLoader::parseMetadata(
bool ModuleLevel) {
2355 return Pimpl->parseMetadata(ModuleLevel);
2363 return Pimpl->getMetadataFwdRefOrLoad(Idx);
2367 return Pimpl->lookupSubprogramForFunction(
F);
2372 return Pimpl->parseMetadataAttachment(
F, InstructionList);
2376 return Pimpl->parseMetadataKinds();
2380 return Pimpl->setStripTBAA(StripTBAA);
2389 return Pimpl->upgradeDebugIntrinsics(
F);