84 #include <system_error>
91 #define DEBUG_TYPE "bitcode-reader"
93 STATISTIC(NumMDStringLoaded,
"Number of MDStrings loaded");
94 STATISTIC(NumMDNodeTemporary,
"Number of MDNode::Temporary created");
95 STATISTIC(NumMDRecordLoaded,
"Number of Metadata records loaded");
101 cl::desc(
"Import full type definitions for ThinLTO."));
105 cl::desc(
"Force disable the lazy-loading on-demand of metadata when "
106 "loading bitcode for importing."));
110 static int64_t unrotateSign(uint64_t U) {
return U & 1 ? ~(U >> 1) : U >> 1; }
112 class BitcodeReaderMetadataList {
141 unsigned size()
const {
return MetadataPtrs.size(); }
142 void resize(
unsigned N) { MetadataPtrs.resize(N); }
143 void push_back(
Metadata *MD) { MetadataPtrs.emplace_back(MD); }
144 void clear() { MetadataPtrs.clear(); }
145 Metadata *back()
const {
return MetadataPtrs.back(); }
146 void pop_back() { MetadataPtrs.pop_back(); }
147 bool empty()
const {
return MetadataPtrs.empty(); }
150 assert(i < MetadataPtrs.size());
151 return MetadataPtrs[
i];
155 if (I < MetadataPtrs.size())
156 return MetadataPtrs[I];
160 void shrinkTo(
unsigned N) {
161 assert(N <= size() &&
"Invalid shrinkTo request!");
163 assert(UnresolvedNodes.empty() &&
"Unexpected unresolved node");
164 MetadataPtrs.resize(N);
169 Metadata *getMetadataFwdRef(
unsigned Idx);
175 Metadata *getMetadataIfResolved(
unsigned Idx);
177 MDNode *getMDNodeFwdRefOrNull(
unsigned Idx);
178 void assignValue(
Metadata *MD,
unsigned Idx);
179 void tryToResolveCycles();
181 int getNextFwdRef() {
199 void BitcodeReaderMetadataList::assignValue(
Metadata *MD,
unsigned Idx) {
200 if (
auto *MDN = dyn_cast<MDNode>(MD))
201 if (!MDN->isResolved())
202 UnresolvedNodes.insert(Idx);
219 TempMDTuple PrevMD(cast<MDTuple>(OldMD.
get()));
220 PrevMD->replaceAllUsesWith(MD);
224 Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(
unsigned Idx) {
228 if (
Metadata *MD = MetadataPtrs[Idx])
235 ++NumMDNodeTemporary;
237 MetadataPtrs[Idx].reset(MD);
241 Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(
unsigned Idx) {
243 if (
auto *N = dyn_cast_or_null<MDNode>(MD))
244 if (!N->isResolved())
249 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(
unsigned Idx) {
250 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
253 void BitcodeReaderMetadataList::tryToResolveCycles() {
259 for (
const auto &Ref : OldTypeRefs.FwdDecls)
260 OldTypeRefs.Final.insert(Ref);
261 OldTypeRefs.FwdDecls.clear();
265 for (
const auto &Array : OldTypeRefs.Arrays)
267 OldTypeRefs.Arrays.clear();
272 for (
const auto &Ref : OldTypeRefs.Unknown) {
274 Ref.second->replaceAllUsesWith(CT);
276 Ref.second->replaceAllUsesWith(Ref.first);
278 OldTypeRefs.Unknown.clear();
280 if (UnresolvedNodes.empty())
285 for (
unsigned I : UnresolvedNodes) {
286 auto &MD = MetadataPtrs[
I];
287 auto *N = dyn_cast_or_null<MDNode>(MD);
291 assert(!N->isTemporary() &&
"Unexpected forward reference");
296 UnresolvedNodes.clear();
299 void BitcodeReaderMetadataList::addTypeRef(
MDString &UUID,
303 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
305 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
309 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
313 if (
auto *CT = OldTypeRefs.Final.lookup(UUID))
316 auto &Ref = OldTypeRefs.Unknown[UUID];
322 Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(
Metadata *MaybeTuple) {
323 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
324 if (!Tuple || Tuple->isDistinct())
328 if (!Tuple->isTemporary())
329 return resolveTypeRefArray(Tuple);
333 OldTypeRefs.Arrays.emplace_back(
334 std::piecewise_construct, std::forward_as_tuple(Tuple),
336 return OldTypeRefs.Arrays.back().second.get();
339 Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(
Metadata *MaybeTuple) {
340 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
341 if (!Tuple || Tuple->isDistinct())
346 Ops.
reserve(Tuple->getNumOperands());
347 for (
Metadata *MD : Tuple->operands())
355 class PlaceholderQueue {
358 std::deque<DistinctMDOperandPlaceholder> PHs;
361 bool empty() {
return PHs.empty(); }
363 void flush(BitcodeReaderMetadataList &MetadataList);
367 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
369 for (
auto &PH : PHs) {
370 auto ID = PH.getID();
371 auto *MD = MetadataList.lookup(
ID);
376 auto *N = dyn_cast_or_null<MDNode>(MD);
377 if (N && N->isTemporary())
386 PHs.emplace_back(ID);
390 void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
391 while (!PHs.empty()) {
392 auto *MD = MetadataList.lookup(PHs.front().getID());
393 assert(MD &&
"Flushing placeholder on unassigned MD");
395 if (
auto *MDN = dyn_cast<MDNode>(MD))
396 assert(MDN->isResolved() &&
397 "Flushing Placeholder while cycles aren't resolved");
399 PHs.front().replaceUseWith(MD);
407 BitcodeReaderMetadataList MetadataList;
412 std::function<Type *(unsigned)> getTypeByID;
420 std::vector<StringRef> MDStringRef;
424 MDString *lazyLoadOneMDString(
unsigned Idx);
427 std::vector<uint64_t> GlobalMetadataBitPosIndex;
436 void lazyLoadOneMetadata(
unsigned Idx, PlaceholderQueue &Placeholders);
440 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
449 bool StripTBAA =
false;
450 bool HasSeenOldLoopTags =
false;
451 bool NeedUpgradeToDIGlobalVariableExpression =
false;
454 bool IsImporting =
false;
457 PlaceholderQueue &Placeholders,
StringRef Blob,
458 unsigned &NextMetadataNo);
465 void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
468 void upgradeCUSubprograms() {
469 for (
auto CU_SP : CUSubprograms)
470 if (
auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
471 for (
auto &
Op : SPs->operands())
472 if (
auto *SP = dyn_cast_or_null<MDNode>(
Op))
473 SP->replaceOperandWith(7, CU_SP.first);
474 CUSubprograms.clear();
478 void upgradeCUVariables() {
479 if (!NeedUpgradeToDIGlobalVariableExpression)
483 if (
NamedMDNode *CUNodes = TheModule.getNamedMetadata(
"llvm.dbg.cu"))
484 for (
unsigned I = 0,
E = CUNodes->getNumOperands(); I !=
E; ++
I) {
485 auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
486 if (
auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
487 for (
unsigned I = 0; I < GVs->getNumOperands(); I++)
489 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
492 GVs->replaceOperandWith(I, DGVE);
497 for (
auto &GV : TheModule.globals()) {
502 if (
auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) {
511 void upgradeDebugInfo() {
512 upgradeCUSubprograms();
513 upgradeCUVariables();
521 : MetadataList(TheModule.getContext()), ValueList(ValueList),
522 Stream(Stream),
Context(TheModule.getContext()), TheModule(TheModule),
523 getTypeByID(getTypeByID), IsImporting(IsImporting) {}
527 bool hasFwdRefs()
const {
return MetadataList.hasFwdRefs(); }
530 if (ID < MDStringRef.size())
531 return lazyLoadOneMDString(ID);
532 if (
auto *MD = MetadataList.lookup(ID))
536 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
537 PlaceholderQueue Placeholders;
538 lazyLoadOneMetadata(ID, Placeholders);
539 resolveForwardRefsAndPlaceholders(Placeholders);
540 return MetadataList.lookup(ID);
542 return MetadataList.getMetadataFwdRef(ID);
546 return MetadataList.getMDNodeFwdRefOrNull(Idx);
550 return FunctionsWithSPs.lookup(F);
563 unsigned size()
const {
return MetadataList.size(); }
564 void shrinkTo(
unsigned N) { MetadataList.shrinkTo(N); }
568 return make_error<StringError>(
573 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
574 IndexCursor = Stream;
579 BitstreamCursor::AF_DontPopBlockAtEnd);
580 switch (Entry.
Kind) {
581 case BitstreamEntry::SubBlock:
583 return error(
"Malformed block");
584 case BitstreamEntry::EndBlock: {
587 case BitstreamEntry::Record: {
599 unsigned NumStrings = Record[0];
600 MDStringRef.reserve(NumStrings);
601 auto IndexNextMDString = [&](
StringRef Str) {
602 MDStringRef.push_back(Str);
604 if (
auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
605 return std::move(Err);
614 if (Record.
size() != 2)
615 return error(
"Invalid record");
616 auto Offset = Record[0] + (Record[1] << 32);
620 BitstreamCursor::AF_DontPopBlockAtEnd);
621 assert(Entry.
Kind == BitstreamEntry::Record &&
622 "Corrupted bitcode: Expected `Record` when trying to find the "
628 "`METADATA_INDEX` when trying "
629 "to find the Metadata index");
632 auto CurrentValue = BeginPos;
633 GlobalMetadataBitPosIndex.reserve(Record.
size());
634 for (
auto &Elt : Record) {
636 GlobalMetadataBitPosIndex.push_back(CurrentValue);
643 return error(
"Corrupted Metadata block");
648 unsigned Code = IndexCursor.
readRecord(Entry.
ID, Record);
658 unsigned NextBitCode = IndexCursor.
readRecord(Code, Record);
663 unsigned Size = Record.size();
665 for (
unsigned i = 0; i != Size; ++
i) {
670 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
671 assert(MD &&
"Invalid record");
682 if (Record.size() % 2 == 0)
683 return error(
"Invalid record");
684 unsigned ValueID = Record[0];
685 if (ValueID >= ValueList.
size())
686 return error(
"Invalid record");
687 if (
auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
688 if (
Error Err = parseGlobalObjectAttachment(
690 return std::move(Err);
728 GlobalMetadataBitPosIndex.clear();
740 if (!ModuleLevel && MetadataList.hasFwdRefs())
741 return error(
"Invalid metadata: fwd refs into function blocks");
745 auto EntryPos = Stream.GetCurrentBitNo();
748 return error(
"Invalid record");
751 PlaceholderQueue Placeholders;
755 if (ModuleLevel && IsImporting && MetadataList.empty() &&
757 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
759 return SuccessOrErr.takeError();
760 if (SuccessOrErr.get()) {
763 MetadataList.resize(MDStringRef.size() +
764 GlobalMetadataBitPosIndex.size());
768 resolveForwardRefsAndPlaceholders(Placeholders);
772 Stream.ReadBlockEnd();
773 Stream.JumpToBit(EntryPos);
774 if (Stream.SkipBlock())
775 return error(
"Invalid record");
781 unsigned NextMetadataNo = MetadataList.size();
787 switch (Entry.
Kind) {
788 case BitstreamEntry::SubBlock:
790 return error(
"Malformed block");
791 case BitstreamEntry::EndBlock:
792 resolveForwardRefsAndPlaceholders(Placeholders);
795 case BitstreamEntry::Record:
804 unsigned Code = Stream.readRecord(Entry.
ID, Record, &Blob);
806 parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
811 MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(
unsigned ID) {
813 if (
Metadata *MD = MetadataList.lookup(ID))
814 return cast<MDString>(MD);
815 auto MDS = MDString::get(
Context, MDStringRef[ID]);
816 MetadataList.assignValue(MDS, ID);
820 void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
821 unsigned ID, PlaceholderQueue &Placeholders) {
822 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
823 assert(ID >= MDStringRef.size() &&
"Unexpected lazy-loading of MDString");
825 if (
auto *MD = MetadataList.lookup(ID)) {
826 auto *N = dyn_cast_or_null<MDNode>(MD);
827 if (!N->isTemporary())
832 IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
833 auto Entry = IndexCursor.advanceSkippingSubblocks();
835 unsigned Code = IndexCursor.readRecord(Entry.
ID, Record, &Blob);
836 if (
Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
842 void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
843 PlaceholderQueue &Placeholders) {
847 Placeholders.getTemporaries(MetadataList, Temporaries);
850 if (Temporaries.
empty() && !MetadataList.hasFwdRefs())
855 for (
auto ID : Temporaries)
856 lazyLoadOneMetadata(ID, Placeholders);
861 while (MetadataList.hasFwdRefs())
862 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
867 MetadataList.tryToResolveCycles();
871 Placeholders.flush(MetadataList);
874 Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
876 PlaceholderQueue &Placeholders,
StringRef Blob,
unsigned &NextMetadataNo) {
878 bool IsDistinct =
false;
880 if (ID < MDStringRef.size())
881 return lazyLoadOneMDString(ID);
883 if (
auto *MD = MetadataList.lookup(ID))
887 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
891 MetadataList.getMetadataFwdRef(NextMetadataNo);
892 lazyLoadOneMetadata(ID, Placeholders);
893 return MetadataList.lookup(ID);
896 return MetadataList.getMetadataFwdRef(ID);
898 if (
auto *MD = MetadataList.getMetadataIfResolved(ID))
900 return &Placeholders.getPlaceholderOp(ID);
902 auto getMDOrNull = [&](
unsigned ID) ->
Metadata * {
904 return getMD(ID - 1);
907 auto getMDOrNullWithoutPlaceholders = [&](
unsigned ID) ->
Metadata * {
909 return MetadataList.getMetadataFwdRef(ID - 1);
912 auto getMDString = [&](
unsigned ID) ->
MDString * {
915 auto MDS = getMDOrNull(ID);
916 return cast_or_null<MDString>(MDS);
920 auto getDITypeRefOrNull = [&](
unsigned ID) {
921 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
924 #define GET_OR_DISTINCT(CLASS, ARGS) \
925 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
934 Code = Stream.ReadCode();
937 unsigned NextBitCode = Stream.readRecord(Code, Record);
939 return error(
"METADATA_NAME not followed by METADATA_NAMED_NODE");
942 unsigned Size = Record.
size();
944 for (
unsigned i = 0; i != Size; ++
i) {
945 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
947 return error(
"Invalid record");
956 if (Record.
size() % 2 == 1)
957 return error(
"Invalid record");
961 auto dropRecord = [&] {
962 MetadataList.assignValue(MDNode::get(
Context,
None), NextMetadataNo);
965 if (Record.
size() != 2) {
970 Type *Ty = getTypeByID(Record[0]);
976 MetadataList.assignValue(
977 LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
984 if (Record.
size() % 2 == 1)
985 return error(
"Invalid record");
987 unsigned Size = Record.
size();
989 for (
unsigned i = 0; i != Size; i += 2) {
990 Type *Ty = getTypeByID(Record[i]);
992 return error(
"Invalid record");
997 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
998 assert(isa<ConstantAsMetadata>(MD) &&
999 "Expected non-function-local metadata");
1004 MetadataList.assignValue(MDNode::get(
Context, Elts), NextMetadataNo);
1009 if (Record.
size() != 2)
1010 return error(
"Invalid record");
1012 Type *Ty = getTypeByID(Record[0]);
1014 return error(
"Invalid record");
1016 MetadataList.assignValue(
1017 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1028 for (
unsigned ID : Record)
1030 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(
Context, Elts)
1037 if (Record.size() != 5)
1038 return error(
"Invalid record");
1040 IsDistinct = Record[0];
1041 unsigned Line = Record[1];
1042 unsigned Column = Record[2];
1043 Metadata *Scope = getMD(Record[3]);
1044 Metadata *InlinedAt = getMDOrNull(Record[4]);
1045 MetadataList.assignValue(
1052 if (Record.size() < 4)
1053 return error(
"Invalid record");
1055 IsDistinct = Record[0];
1056 unsigned Tag = Record[1];
1059 if (Tag >= 1u << 16 || Version != 0)
1060 return error(
"Invalid record");
1062 auto *Header = getMDString(Record[3]);
1064 for (
unsigned I = 4,
E = Record.size(); I !=
E; ++
I)
1065 DwarfOps.
push_back(getMDOrNull(Record[I]));
1066 MetadataList.assignValue(
1073 if (Record.size() != 3)
1074 return error(
"Invalid record");
1076 IsDistinct = Record[0];
1077 MetadataList.assignValue(
1079 (
Context, Record[1], unrotateSign(Record[2]))),
1085 if (Record.size() != 3)
1086 return error(
"Invalid record");
1088 IsDistinct = Record[0];
1089 MetadataList.assignValue(
1091 getMDString(Record[2]))),
1097 if (Record.size() != 6)
1098 return error(
"Invalid record");
1100 IsDistinct = Record[0];
1101 MetadataList.assignValue(
1103 (
Context, Record[1], getMDString(Record[2]), Record[3],
1104 Record[4], Record[5])),
1110 if (Record.size() != 12)
1111 return error(
"Invalid record");
1113 IsDistinct = Record[0];
1115 MetadataList.assignValue(
1117 (
Context, Record[1], getMDString(Record[2]),
1118 getMDOrNull(Record[3]), Record[4],
1119 getDITypeRefOrNull(Record[5]),
1120 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1121 Record[9], Flags, getDITypeRefOrNull(Record[11]))),
1127 if (Record.size() != 16)
1128 return error(
"Invalid record");
1132 IsDistinct = Record[0] & 0x1;
1133 bool IsNotUsedInTypeRef = Record[0] >= 2;
1134 unsigned Tag = Record[1];
1137 unsigned Line = Record[4];
1138 Metadata *Scope = getDITypeRefOrNull(Record[5]);
1140 uint64_t SizeInBits = Record[7];
1141 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1142 return error(
"Alignment value is too large");
1144 uint64_t OffsetInBits = 0;
1147 unsigned RuntimeLang = Record[12];
1149 Metadata *TemplateParams =
nullptr;
1150 auto *Identifier = getMDString(Record[15]);
1159 (Tag == dwarf::DW_TAG_enumeration_type ||
1160 Tag == dwarf::DW_TAG_class_type ||
1161 Tag == dwarf::DW_TAG_structure_type ||
1162 Tag == dwarf::DW_TAG_union_type)) {
1163 Flags = Flags | DINode::FlagFwdDecl;
1165 BaseType = getDITypeRefOrNull(Record[6]);
1166 OffsetInBits = Record[9];
1167 Elements = getMDOrNull(Record[11]);
1168 VTableHolder = getDITypeRefOrNull(Record[13]);
1169 TemplateParams = getMDOrNull(Record[14]);
1173 CT = DICompositeType::buildODRType(
1174 Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
1175 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1176 VTableHolder, TemplateParams);
1181 (
Context, Tag, Name, File, Line, Scope, BaseType,
1182 SizeInBits, AlignInBits, OffsetInBits, Flags,
1183 Elements, RuntimeLang, VTableHolder, TemplateParams,
1185 if (!IsNotUsedInTypeRef && Identifier)
1186 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1188 MetadataList.assignValue(CT, NextMetadataNo);
1193 if (Record.size() < 3 || Record.size() > 4)
1194 return error(
"Invalid record");
1195 bool IsOldTypeRefArray = Record[0] < 2;
1196 unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1198 IsDistinct = Record[0] & 0x1;
1200 Metadata *Types = getMDOrNull(Record[2]);
1202 Types = MetadataList.upgradeTypeRefArray(Types);
1204 MetadataList.assignValue(
1212 if (Record.size() != 6)
1213 return error(
"Invalid record");
1215 IsDistinct = Record[0];
1216 MetadataList.assignValue(
1218 (
Context, getMDOrNull(Record[1]),
1219 getMDString(Record[2]), getMDString(Record[3]),
1220 getMDString(Record[4]), getMDString(Record[5]))),
1227 if (Record.size() != 3 && Record.size() != 5)
1228 return error(
"Invalid record");
1230 IsDistinct = Record[0];
1231 MetadataList.assignValue(
1234 (
Context, getMDString(Record[1]), getMDString(Record[2]),
1235 Record.size() == 3 ? DIFile::CSK_None
1237 Record.size() == 3 ?
nullptr : getMDString(Record[4]))),
1243 if (Record.size() < 14 || Record.size() > 17)
1244 return error(
"Invalid record");
1249 auto *CU = DICompileUnit::getDistinct(
1250 Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
1251 Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
1252 Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1253 getMDOrNull(Record[12]), getMDOrNull(Record[13]),
1254 Record.size() <= 15 ?
nullptr : getMDOrNull(Record[15]),
1255 Record.size() <= 14 ? 0 : Record[14],
1256 Record.size() <= 16 ?
true : Record[16]);
1258 MetadataList.assignValue(CU, NextMetadataNo);
1262 if (
Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1263 CUSubprograms.push_back({CU, SPs});
1267 if (Record.size() < 18 || Record.size() > 20)
1268 return error(
"Invalid record");
1271 (Record[0] & 1) || Record[8];
1276 bool HasUnit = Record[0] >= 2;
1277 if (HasUnit && Record.size() < 19)
1278 return error(
"Invalid record");
1279 Metadata *CUorFn = getMDOrNull(Record[15]);
1280 unsigned Offset = Record.size() >= 19 ? 1 : 0;
1281 bool HasFn = Offset && !HasUnit;
1282 bool HasThisAdj = Record.size() >= 20;
1285 getDITypeRefOrNull(Record[1]),
1286 getMDString(Record[2]),
1287 getMDString(Record[3]),
1288 getMDOrNull(Record[4]),
1290 getMDOrNull(Record[6]),
1294 getDITypeRefOrNull(Record[10]),
1297 HasThisAdj ? Record[19] : 0,
1298 static_cast<DINode::DIFlags>(Record[13]
1301 HasUnit ? CUorFn :
nullptr,
1302 getMDOrNull(Record[15 + Offset]),
1303 getMDOrNull(Record[16 + Offset]),
1304 getMDOrNull(Record[17 + Offset])
1306 MetadataList.assignValue(SP, NextMetadataNo);
1311 if (
auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1312 if (
auto *
F = dyn_cast<Function>(CMD->getValue())) {
1313 if (
F->isMaterializable())
1316 FunctionsWithSPs[
F] = SP;
1317 else if (!
F->empty())
1318 F->setSubprogram(SP);
1324 if (Record.size() != 5)
1325 return error(
"Invalid record");
1327 IsDistinct = Record[0];
1328 MetadataList.assignValue(
1330 (
Context, getMDOrNull(Record[1]),
1331 getMDOrNull(Record[2]), Record[3], Record[4])),
1337 if (Record.size() != 4)
1338 return error(
"Invalid record");
1340 IsDistinct = Record[0];
1341 MetadataList.assignValue(
1343 (
Context, getMDOrNull(Record[1]),
1344 getMDOrNull(Record[2]), Record[3])),
1350 if (Record.size() != 5)
1351 return error(
"Invalid record");
1353 IsDistinct = Record[0] & 1;
1354 bool ExportSymbols = Record[0] & 2;
1355 MetadataList.assignValue(
1357 (
Context, getMDOrNull(Record[1]),
1358 getMDOrNull(Record[2]), getMDString(Record[3]),
1359 Record[4], ExportSymbols)),
1365 if (Record.size() != 5)
1366 return error(
"Invalid record");
1368 IsDistinct = Record[0];
1369 MetadataList.assignValue(
1371 (
Context, Record[1], Record[2], getMDString(Record[3]),
1372 getMDString(Record[4]))),
1378 if (Record.size() != 5)
1379 return error(
"Invalid record");
1381 IsDistinct = Record[0];
1382 MetadataList.assignValue(
1384 (
Context, Record[1], Record[2], getMDOrNull(Record[3]),
1385 getMDOrNull(Record[4]))),
1391 if (Record.size() != 3)
1392 return error(
"Invalid record");
1394 IsDistinct = Record[0];
1396 (
Context, getMDString(Record[1]),
1397 getDITypeRefOrNull(Record[2]))),
1403 if (Record.size() != 5)
1404 return error(
"Invalid record");
1406 IsDistinct = Record[0];
1407 MetadataList.assignValue(
1409 (
Context, Record[1], getMDString(Record[2]),
1410 getDITypeRefOrNull(Record[3]),
1411 getMDOrNull(Record[4]))),
1417 if (Record.size() < 11 || Record.size() > 12)
1418 return error(
"Invalid record");
1420 IsDistinct = Record[0] & 1;
1421 unsigned Version = Record[0] >> 1;
1424 MetadataList.assignValue(
1426 (
Context, getMDOrNull(Record[1]),
1427 getMDString(Record[2]), getMDString(Record[3]),
1428 getMDOrNull(Record[4]), Record[5],
1429 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1430 getMDOrNull(Record[10]), Record[11])),
1433 }
else if (Version == 0) {
1436 Metadata *Expr = getMDOrNull(Record[9]);
1438 if (Record.size() > 11) {
1439 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1440 return error(
"Alignment value is too large");
1441 AlignInBits = Record[11];
1444 if (
auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1445 if (
auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1448 }
else if (
auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1449 Expr = DIExpression::get(
Context,
1450 {dwarf::DW_OP_constu, CI->getZExtValue(),
1451 dwarf::DW_OP_stack_value});
1458 (
Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1459 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1460 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1461 getMDOrNull(Record[10]), AlignInBits));
1465 DGVE = DIGlobalVariableExpression::getDistinct(
Context, DGV, Expr);
1467 NeedUpgradeToDIGlobalVariableExpression =
true;
1471 auto *
MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1472 MetadataList.assignValue(
MDNode, NextMetadataNo);
1475 return error(
"Invalid record");
1481 if (Record.size() < 8 || Record.size() > 10)
1482 return error(
"Invalid record");
1484 IsDistinct = Record[0] & 1;
1485 bool HasAlignment = Record[0] & 2;
1489 bool HasTag = !HasAlignment && Record.size() > 8;
1493 if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1494 return error(
"Alignment value is too large");
1495 AlignInBits = Record[8 + HasTag];
1497 MetadataList.assignValue(
1499 (
Context, getMDOrNull(Record[1 + HasTag]),
1500 getMDString(Record[2 + HasTag]),
1501 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1502 getDITypeRefOrNull(Record[5 + HasTag]),
1503 Record[6 + HasTag], Flags, AlignInBits)),
1509 if (Record.size() < 1)
1510 return error(
"Invalid record");
1512 IsDistinct = Record[0] & 1;
1513 bool HasOpFragment = Record[0] & 2;
1516 if (
unsigned N = Elts.
size())
1517 if (N >= 3 && Elts[N - 3] == dwarf::DW_OP_bit_piece)
1520 MetadataList.assignValue(
1527 if (Record.size() != 3)
1528 return error(
"Invalid record");
1530 IsDistinct = Record[0];
1532 (
Context, getMDOrNull(Record[1]),
1533 getMDOrNull(Record[2]))),
1539 if (Record.size() != 8)
1540 return error(
"Invalid record");
1542 IsDistinct = Record[0];
1543 MetadataList.assignValue(
1545 (
Context, getMDString(Record[1]),
1546 getMDOrNull(Record[2]), Record[3],
1547 getMDString(Record[4]), getMDString(Record[5]),
1548 Record[6], getDITypeRefOrNull(Record[7]))),
1554 if (Record.size() != 6)
1555 return error(
"Invalid record");
1557 IsDistinct = Record[0];
1558 MetadataList.assignValue(
1560 (
Context, Record[1], getMDOrNull(Record[2]),
1561 getDITypeRefOrNull(Record[3]), Record[4],
1562 getMDString(Record[5]))),
1568 std::string
String(Record.begin(), Record.end());
1572 ++NumMDStringLoaded;
1574 MetadataList.assignValue(MD, NextMetadataNo);
1579 auto CreateNextMDString = [&](
StringRef Str) {
1580 ++NumMDStringLoaded;
1581 MetadataList.assignValue(MDString::get(
Context, Str), NextMetadataNo);
1584 if (
Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
1589 if (Record.size() % 2 == 0)
1590 return error(
"Invalid record");
1591 unsigned ValueID = Record[0];
1592 if (ValueID >= ValueList.size())
1593 return error(
"Invalid record");
1594 if (
auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1595 if (
Error Err = parseGlobalObjectAttachment(
1603 if (
Error Err = parseMetadataKindRecord(Record))
1609 #undef GET_OR_DISTINCT
1612 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
1618 if (Record.
size() != 2)
1619 return error(
"Invalid record: metadata strings layout");
1621 unsigned NumStrings = Record[0];
1622 unsigned StringsOffset = Record[1];
1624 return error(
"Invalid record: metadata strings with no strings");
1625 if (StringsOffset > Blob.
size())
1626 return error(
"Invalid record: metadata strings corrupt offset");
1633 if (R.AtEndOfStream())
1634 return error(
"Invalid record: metadata strings bad length");
1636 unsigned Size = R.ReadVBR(6);
1637 if (Strings.
size() < Size)
1638 return error(
"Invalid record: metadata strings truncated chars");
1640 CallBack(Strings.
slice(0, Size));
1642 }
while (--NumStrings);
1647 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1650 for (
unsigned I = 0,
E = Record.
size(); I !=
E; I += 2) {
1651 auto K = MDKindMap.find(Record[I]);
1652 if (K == MDKindMap.end())
1653 return error(
"Invalid ID");
1654 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1656 return error(
"Invalid metadata attachment");
1666 return error(
"Invalid record");
1669 PlaceholderQueue Placeholders;
1674 switch (Entry.
Kind) {
1675 case BitstreamEntry::SubBlock:
1677 return error(
"Malformed block");
1678 case BitstreamEntry::EndBlock:
1679 resolveForwardRefsAndPlaceholders(Placeholders);
1681 case BitstreamEntry::Record:
1688 ++NumMDRecordLoaded;
1689 switch (Stream.readRecord(Entry.
ID, Record)) {
1693 unsigned RecordLength = Record.
size();
1695 return error(
"Invalid record");
1696 if (RecordLength % 2 == 0) {
1698 if (
Error Err = parseGlobalObjectAttachment(F, Record))
1705 for (
unsigned i = 1; i != RecordLength; i = i + 2) {
1706 unsigned Kind = Record[
i];
1708 if (I == MDKindMap.
end())
1709 return error(
"Invalid ID");
1710 if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1713 auto Idx = Record[i + 1];
1714 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
1715 !MetadataList.lookup(Idx)) {
1718 lazyLoadOneMetadata(Idx, Placeholders);
1719 resolveForwardRefsAndPlaceholders(Placeholders);
1722 Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
1723 if (isa<LocalAsMetadata>(Node))
1727 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
1729 return error(
"Invalid metadata attachment");
1731 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1734 if (I->second == LLVMContext::MD_tbaa) {
1747 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1749 if (Record.
size() < 2)
1750 return error(
"Invalid record");
1752 unsigned Kind = Record[0];
1755 unsigned NewKind = TheModule.getMDKindID(Name.str());
1756 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1757 return error(
"Conflicting METADATA_KIND records");
1764 return error(
"Invalid record");
1772 switch (Entry.
Kind) {
1773 case BitstreamEntry::SubBlock:
1775 return error(
"Malformed block");
1776 case BitstreamEntry::EndBlock:
1778 case BitstreamEntry::Record:
1785 ++NumMDRecordLoaded;
1786 unsigned Code = Stream.readRecord(Entry.
ID, Record);
1791 if (
Error Err = parseMetadataKindRecord(Record))
1800 Pimpl = std::move(RHS.Pimpl);
1804 : Pimpl(std::move(RHS.Pimpl)) {}
1812 getTypeByID, IsImporting)) {}
1814 Error MetadataLoader::parseMetadata(
bool ModuleLevel) {
1815 return Pimpl->parseMetadata(ModuleLevel);
1823 return Pimpl->getMetadataFwdRefOrLoad(Idx);
1827 return Pimpl->getMDNodeFwdRefOrNull(Idx);
1831 return Pimpl->lookupSubprogramForFunction(F);
1836 return Pimpl->parseMetadataAttachment(F, InstructionList);
1840 return Pimpl->parseMetadataKinds();
1844 return Pimpl->setStripTBAA(StripTBAA);
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
bool mayBeOldLoopAttachmentTag(StringRef Name)
Check whether a string looks like an old loop attachment tag.
void push_back(const T &Elt)
Atomic ordering constants.
STATISTIC(NumFunctions,"Total number of functions")
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
A Module instance is used to store all the information related to an LLVM module. ...
#define LLVM_UNLIKELY(EXPR)
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
#define LLVM_LIKELY(EXPR)
Tracking metadata reference.
Implements a dense probed hash-table based set.
void addOperand(MDNode *M)
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
void reserve(size_type N)
MDNode * upgradeInstructionLoopAttachment(MDNode &N)
Upgrade the loop attachment metadata node.
struct fuzzer::@269 Flags
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
std::error_code make_error_code(BitcodeError E)
This file contains the simple types necessary to represent the attributes associated with functions a...
Placeholder metadata for operands of distinct MDNodes.
Only used in LLVM metadata.
Tagged union holding either a T or a Error.
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
This file implements a class to represent arbitrary precision integral constant values and operations...
LLVM_NODISCARD bool empty() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
BitstreamEntry advanceSkippingSubblocks(unsigned Flags=0)
This is a convenience function for clients that don't expect any subblocks.
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
size_t size() const
size - Get the array size.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
initializer< Ty > init(const Ty &Val)
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&...args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
The instances of the Type class are immutable: once they are created, they are never changed...
This is an important class for using LLVM in a threaded context.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(const ValueT &V)
A pair of DIGlobalVariable and DIExpression.
This file declares a class to represent arbitrary precision floating point values and provide a varie...
void JumpToBit(uint64_t BitNo)
Reset the stream to the specified bit number.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
An imported module (C++ using directive or similar).
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Module.h This file contains the declarations for the Module class.
unsigned readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
Implements a dense probed hash-table based set with some number of buckets stored inline...
MDNode * UpgradeTBAANode(MDNode &TBAANode)
If the given TBAA tag uses the scalar TBAA format, create a new node corresponding to the upgrade to ...
unsigned skipRecord(unsigned AbbrevID)
Read the current record and discard it, returning the code for the record.
A (clang) module that has been imported by the compile unit.
bool isForwardDecl() const
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Generic tagged DWARF-like metadata node.
static void clear(coro::Shape &Shape)
Type array for a subprogram.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
enum llvm::BitstreamEntry::@32 Kind
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
MDString * getRawIdentifier() const
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Lightweight error class with error context and mandatory checking.
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
This represents a position within a bitstream.
bool isVoidTy() const
Return true if this is 'void'.
Basic type, like 'int' or 'float'.
bool isMetadataTy() const
Return true if this is 'metadata'.