24#include "llvm/Config/llvm-config.h"
54#include "llvm/IR/IntrinsicsAArch64.h"
55#include "llvm/IR/IntrinsicsARM.h"
87#include <system_error>
97 "Print the global id for each value when reading the module summary"));
102 "Expand constant expressions to instructions for testing purposes"));
107 SWITCH_INST_MAGIC = 0x4B5
120 "file too small to contain bitcode header");
121 for (
unsigned C : {
'B',
'C'})
125 "file doesn't start with bitcode header");
127 return Res.takeError();
128 for (
unsigned C : {0x0, 0xC, 0xE, 0xD})
132 "file doesn't start with bitcode header");
134 return Res.takeError();
139 const unsigned char *BufPtr = (
const unsigned char *)Buffer.
getBufferStart();
140 const unsigned char *BufEnd = BufPtr + Buffer.
getBufferSize();
143 return error(
"Invalid bitcode signature");
149 return error(
"Invalid bitcode wrapper header");
153 return std::move(Err);
155 return std::move(Stream);
159template <
typename StrTy>
172 if (
F.isMaterializable())
175 I.setMetadata(LLVMContext::MD_tbaa,
nullptr);
183 return std::move(Err);
188 std::string ProducerIdentification;
195 switch (Entry.Kind) {
198 return error(
"Malformed block");
200 return ProducerIdentification;
211 switch (MaybeBitCode.
get()) {
213 return error(
"Invalid value");
221 Twine(
"Incompatible epoch: Bitcode '") +
Twine(epoch) +
240 switch (Entry.Kind) {
243 return error(
"Malformed block");
251 return std::move(Err);
263 return std::move(Err);
274 switch (Entry.Kind) {
277 return error(
"Malformed block");
289 switch (MaybeRecord.
get()) {
295 return error(
"Invalid section name record");
300 Segment = Segment.trim();
301 Section = Section.trim();
303 if (Segment ==
"__DATA" && Section.starts_with(
"__objc_catlist"))
305 if (Segment ==
"__OBJC" && Section.starts_with(
"__category"))
307 if (Segment ==
"__TEXT" && Section.starts_with(
"__swift"))
325 switch (Entry.Kind) {
327 return error(
"Malformed block");
337 return std::move(Err);
350 return std::move(Err);
363 switch (Entry.Kind) {
366 return error(
"Malformed block");
378 switch (MaybeRecord.
get()) {
383 return error(
"Invalid triple record");
402 switch (Entry.Kind) {
404 return error(
"Malformed block");
414 return std::move(Err);
421 return Skipped.takeError();
428class BitcodeReaderBase {
430 BitcodeReaderBase(BitstreamCursor Stream, StringRef Strtab)
431 : Stream(std::
move(Stream)), Strtab(Strtab) {
432 this->Stream.setBlockInfo(&BlockInfo);
435 BitstreamBlockInfo BlockInfo;
436 BitstreamCursor Stream;
441 bool UseStrtab =
false;
443 Expected<unsigned> parseVersionRecord(ArrayRef<uint64_t> Record);
448 std::pair<StringRef, ArrayRef<uint64_t>>
449 readNameFromStrtab(ArrayRef<uint64_t> Record);
451 Error readBlockInfo();
454 std::string ProducerIdentification;
461Error BitcodeReaderBase::error(
const Twine &Message) {
462 std::string FullMsg = Message.
str();
463 if (!ProducerIdentification.empty())
464 FullMsg +=
" (Producer: '" + ProducerIdentification +
"' Reader: 'LLVM " +
465 LLVM_VERSION_STRING
"')";
466 return ::error(FullMsg);
470BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t> Record) {
472 return error(
"Invalid version record");
473 unsigned ModuleVersion = Record[0];
474 if (ModuleVersion > 2)
475 return error(
"Invalid value");
476 UseStrtab = ModuleVersion >= 2;
477 return ModuleVersion;
480std::pair<StringRef, ArrayRef<uint64_t>>
481BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t> Record) {
485 if (Record[0] + Record[1] > Strtab.
size())
487 return {StringRef(Strtab.
data() + Record[0], Record[1]), Record.
slice(2)};
498class BitcodeConstant final :
public Value,
499 TrailingObjects<BitcodeConstant, unsigned> {
500 friend TrailingObjects;
503 static constexpr uint8_t SubclassID = 255;
511 static constexpr uint8_t ConstantStructOpcode = 255;
512 static constexpr uint8_t ConstantArrayOpcode = 254;
513 static constexpr uint8_t ConstantVectorOpcode = 253;
514 static constexpr uint8_t NoCFIOpcode = 252;
515 static constexpr uint8_t DSOLocalEquivalentOpcode = 251;
516 static constexpr uint8_t BlockAddressOpcode = 250;
517 static constexpr uint8_t ConstantPtrAuthOpcode = 249;
518 static constexpr uint8_t FirstSpecialOpcode = ConstantPtrAuthOpcode;
525 unsigned BlockAddressBB = 0;
526 Type *SrcElemTy =
nullptr;
527 std::optional<ConstantRange>
InRange;
529 ExtraInfo(uint8_t Opcode, uint8_t Flags = 0,
Type *SrcElemTy =
nullptr,
530 std::optional<ConstantRange>
InRange = std::nullopt)
531 : Opcode(Opcode),
Flags(
Flags), SrcElemTy(SrcElemTy),
534 ExtraInfo(uint8_t Opcode, uint8_t Flags,
unsigned BlockAddressBB)
535 : Opcode(Opcode),
Flags(
Flags), BlockAddressBB(BlockAddressBB) {}
540 unsigned NumOperands;
541 unsigned BlockAddressBB;
543 std::optional<ConstantRange>
InRange;
546 BitcodeConstant(
Type *Ty,
const ExtraInfo &
Info, ArrayRef<unsigned> OpIDs)
548 NumOperands(OpIDs.
size()), BlockAddressBB(
Info.BlockAddressBB),
553 BitcodeConstant &operator=(
const BitcodeConstant &) =
delete;
557 const ExtraInfo &
Info,
558 ArrayRef<unsigned> OpIDs) {
559 void *Mem =
A.Allocate(totalSizeToAlloc<unsigned>(OpIDs.
size()),
560 alignof(BitcodeConstant));
561 return new (Mem) BitcodeConstant(Ty,
Info, OpIDs);
564 static bool classof(
const Value *V) {
return V->getValueID() == SubclassID; }
566 ArrayRef<unsigned> getOperandIDs()
const {
567 return ArrayRef(getTrailingObjects(), NumOperands);
570 std::optional<ConstantRange> getInRange()
const {
571 assert(Opcode == Instruction::GetElementPtr);
580class BitcodeReader :
public BitcodeReaderBase,
public GVMaterializer {
582 Module *TheModule =
nullptr;
584 uint64_t NextUnreadBit = 0;
586 uint64_t LastFunctionBlockBit = 0;
587 bool SeenValueSymbolTable =
false;
588 uint64_t VSTOffset = 0;
590 std::vector<std::string> SectionTable;
591 std::vector<std::string> GCTable;
593 std::vector<Type *> TypeList;
597 DenseMap<unsigned, SmallVector<unsigned, 1>> ContainedTypeIDs;
604 DenseMap<std::pair<Type *, unsigned>,
unsigned> VirtualTypeIDs;
605 DenseMap<Function *, unsigned> FunctionTypeIDs;
610 BitcodeReaderValueList ValueList;
611 std::optional<MetadataLoader> MDLoader;
612 std::vector<Comdat *> ComdatList;
613 DenseSet<GlobalObject *> ImplicitComdatObjects;
616 std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInits;
617 std::vector<std::pair<GlobalValue *, unsigned>> IndirectSymbolInits;
619 struct FunctionOperandInfo {
621 unsigned PersonalityFn;
625 std::vector<FunctionOperandInfo> FunctionOperands;
629 std::vector<AttributeList> MAttributes;
632 std::map<unsigned, AttributeList> MAttributeGroups;
636 std::vector<BasicBlock*> FunctionBBs;
640 std::vector<Function*> FunctionsWithBodies;
644 using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
645 UpdatedIntrinsicMap UpgradedIntrinsics;
650 bool SeenFirstFunctionBody =
false;
654 DenseMap<Function*, uint64_t> DeferredFunctionInfo;
659 std::vector<uint64_t> DeferredMetadataInfo;
664 DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
665 std::deque<Function *> BasicBlockFwdRefQueue;
672 std::vector<Function *> BackwardRefFunctions;
680 bool UseRelativeIDs =
false;
684 bool WillMaterializeAllForwardRefs =
false;
688 bool SeenDebugIntrinsic =
false;
689 bool SeenDebugRecord =
false;
692 TBAAVerifier TBAAVerifyHelper;
694 std::vector<std::string> BundleTags;
697 std::optional<ValueTypeCallbackTy> ValueTypeCallback;
700 BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
701 StringRef ProducerIdentification, LLVMContext &
Context);
703 Error materializeForwardReferencedFunctions();
705 Error materialize(GlobalValue *GV)
override;
706 Error materializeModule()
override;
707 std::vector<StructType *> getIdentifiedStructTypes()
const override;
711 Error parseBitcodeInto(
Module *M,
bool ShouldLazyLoadMetadata,
712 bool IsImporting, ParserCallbacks Callbacks = {});
717 Error materializeMetadata()
override;
719 void setStripDebugInfo()
override;
722 std::vector<StructType *> IdentifiedStructTypes;
723 StructType *createIdentifiedStructType(LLVMContext &
Context, StringRef Name);
724 StructType *createIdentifiedStructType(LLVMContext &
Context);
726 static constexpr unsigned InvalidTypeID = ~0
u;
728 Type *getTypeByID(
unsigned ID);
729 Type *getPtrElementTypeByID(
unsigned ID);
730 unsigned getContainedTypeID(
unsigned ID,
unsigned Idx = 0);
731 unsigned getVirtualTypeID(
Type *Ty, ArrayRef<unsigned> ContainedTypeIDs = {});
734 Expected<Value *> materializeValue(
unsigned ValID, BasicBlock *InsertBB);
735 Expected<Constant *> getValueForInitializer(
unsigned ID);
737 Value *getFnValueByID(
unsigned ID,
Type *Ty,
unsigned TyID,
738 BasicBlock *ConstExprInsertBB) {
745 return MDLoader->getMetadataFwdRefOrLoad(
ID);
749 if (
ID >= FunctionBBs.size())
return nullptr;
750 return FunctionBBs[
ID];
754 if (i-1 < MAttributes.size())
755 return MAttributes[i-1];
756 return AttributeList();
762 bool getValueTypePair(
const SmallVectorImpl<uint64_t> &Record,
unsigned &Slot,
763 unsigned InstNum,
Value *&ResVal,
unsigned &
TypeID,
764 BasicBlock *ConstExprInsertBB) {
765 if (Slot == Record.
size())
return true;
766 unsigned ValNo = (unsigned)Record[Slot++];
769 ValNo = InstNum - ValNo;
770 if (ValNo < InstNum) {
774 ResVal = getFnValueByID(ValNo,
nullptr,
TypeID, ConstExprInsertBB);
776 "Incorrect type ID stored for value");
777 return ResVal ==
nullptr;
779 if (Slot == Record.
size())
782 TypeID = (unsigned)Record[Slot++];
783 ResVal = getFnValueByID(ValNo, getTypeByID(
TypeID),
TypeID,
785 return ResVal ==
nullptr;
788 bool getValueOrMetadata(
const SmallVectorImpl<uint64_t> &Record,
789 unsigned &Slot,
unsigned InstNum,
Value *&ResVal,
790 BasicBlock *ConstExprInsertBB) {
791 if (Slot == Record.
size())
793 unsigned ValID = Record[
Slot++];
796 return getValueTypePair(Record, --Slot, InstNum, ResVal, TypeId,
799 if (Slot == Record.
size())
801 unsigned ValNo = InstNum - (unsigned)Record[Slot++];
809 bool popValue(
const SmallVectorImpl<uint64_t> &Record,
unsigned &Slot,
810 unsigned InstNum,
Type *Ty,
unsigned TyID,
Value *&ResVal,
811 BasicBlock *ConstExprInsertBB) {
812 if (getValue(Record, Slot, InstNum, Ty, TyID, ResVal, ConstExprInsertBB))
820 bool getValue(
const SmallVectorImpl<uint64_t> &Record,
unsigned Slot,
821 unsigned InstNum,
Type *Ty,
unsigned TyID,
Value *&ResVal,
822 BasicBlock *ConstExprInsertBB) {
823 ResVal = getValue(Record, Slot, InstNum, Ty, TyID, ConstExprInsertBB);
824 return ResVal ==
nullptr;
829 Value *getValue(
const SmallVectorImpl<uint64_t> &Record,
unsigned Slot,
830 unsigned InstNum,
Type *Ty,
unsigned TyID,
831 BasicBlock *ConstExprInsertBB) {
832 if (Slot == Record.
size())
return nullptr;
833 unsigned ValNo = (unsigned)Record[Slot];
836 ValNo = InstNum - ValNo;
837 return getFnValueByID(ValNo, Ty, TyID, ConstExprInsertBB);
841 Value *getValueSigned(
const SmallVectorImpl<uint64_t> &Record,
unsigned Slot,
842 unsigned InstNum,
Type *Ty,
unsigned TyID,
843 BasicBlock *ConstExprInsertBB) {
844 if (Slot == Record.
size())
return nullptr;
848 ValNo = InstNum - ValNo;
849 return getFnValueByID(ValNo, Ty, TyID, ConstExprInsertBB);
852 Expected<ConstantRange> readConstantRange(ArrayRef<uint64_t> Record,
855 if (Record.
size() - OpNum < 2)
856 return error(
"Too few records for range");
858 unsigned LowerActiveWords = Record[OpNum];
859 unsigned UpperActiveWords = Record[OpNum++] >> 32;
860 if (Record.
size() - OpNum < LowerActiveWords + UpperActiveWords)
861 return error(
"Too few records for range");
864 OpNum += LowerActiveWords;
867 OpNum += UpperActiveWords;
870 int64_t
Start = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
871 int64_t End = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
872 return ConstantRange(APInt(
BitWidth, Start,
true),
877 Expected<ConstantRange>
878 readBitWidthAndConstantRange(ArrayRef<uint64_t> Record,
unsigned &OpNum) {
879 if (Record.
size() - OpNum < 1)
880 return error(
"Too few records for range");
881 unsigned BitWidth = Record[OpNum++];
882 return readConstantRange(Record, OpNum,
BitWidth);
888 Error propagateAttributeTypes(CallBase *CB, ArrayRef<unsigned> ArgsTys);
893 Error parseAlignmentValue(uint64_t
Exponent, MaybeAlign &Alignment);
894 Error parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
896 ParserCallbacks Callbacks = {});
898 Error parseComdatRecord(ArrayRef<uint64_t> Record);
899 Error parseGlobalVarRecord(ArrayRef<uint64_t> Record);
900 Error parseFunctionRecord(ArrayRef<uint64_t> Record);
901 Error parseGlobalIndirectSymbolRecord(
unsigned BitCode,
902 ArrayRef<uint64_t> Record);
904 Error parseAttributeBlock();
905 Error parseAttributeGroupBlock();
906 Error parseTypeTable();
907 Error parseTypeTableBody();
908 Error parseOperandBundleTags();
909 Error parseSyncScopeNames();
911 Expected<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
912 unsigned NameIndex, Triple &TT);
913 void setDeferredFunctionInfo(
unsigned FuncBitcodeOffsetDelta, Function *
F,
914 ArrayRef<uint64_t> Record);
916 Error parseGlobalValueSymbolTable();
917 Error parseConstants();
918 Error rememberAndSkipFunctionBodies();
919 Error rememberAndSkipFunctionBody();
921 Error rememberAndSkipMetadata();
923 Error parseFunctionBody(Function *
F);
924 Error globalCleanup();
925 Error resolveGlobalAndIndirectSymbolInits();
926 Error parseUseLists();
927 Error findFunctionInStream(
929 DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
936class ModuleSummaryIndexBitcodeReader :
public BitcodeReaderBase {
938 ModuleSummaryIndex &TheIndex;
942 bool SeenGlobalValSummary =
false;
945 bool SeenValueSymbolTable =
false;
949 uint64_t VSTOffset = 0;
959 DenseMap<unsigned, std::pair<ValueInfo, GlobalValue::GUID>>
960 ValueIdToValueInfoMap;
966 DenseMap<uint64_t, StringRef> ModuleIdMap;
969 std::string SourceFileName;
973 StringRef ModulePath;
981 std::vector<uint64_t> StackIds;
985 std::vector<uint64_t> RadixArray;
988 ModuleSummaryIndexBitcodeReader(
989 BitstreamCursor Stream, StringRef Strtab, ModuleSummaryIndex &TheIndex,
990 StringRef ModulePath,
996 void setValueGUID(uint64_t ValueID, StringRef
ValueName,
998 StringRef SourceFileName);
999 Error parseValueSymbolTable(
1001 DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
1004 makeCallList(ArrayRef<uint64_t> Record,
bool IsOldProfileFormat,
1005 bool HasProfile,
bool HasRelBF);
1006 Error parseEntireSummary(
unsigned ID);
1007 Error parseModuleStringTable();
1008 void parseTypeIdCompatibleVtableSummaryRecord(ArrayRef<uint64_t> Record);
1009 void parseTypeIdCompatibleVtableInfo(ArrayRef<uint64_t> Record,
size_t &Slot,
1011 std::vector<FunctionSummary::ParamAccess>
1012 parseParamAccesses(ArrayRef<uint64_t> Record);
1013 SmallVector<unsigned> parseAllocInfoContext(ArrayRef<uint64_t> Record,
1016 template <
bool AllowNullValueInfo = false>
1017 std::pair<ValueInfo, GlobalValue::GUID>
1018 getValueInfoFromValueId(
unsigned ValueId);
1020 void addThisModule();
1036 return std::error_code();
1042 : BitcodeReaderBase(
std::
move(Stream), Strtab), Context(Context),
1043 ValueList(this->Stream.SizeInBytes(),
1045 return materializeValue(
ValID, InsertBB);
1047 this->ProducerIdentification = std::string(ProducerIdentification);
1050Error BitcodeReader::materializeForwardReferencedFunctions() {
1051 if (WillMaterializeAllForwardRefs)
1055 WillMaterializeAllForwardRefs =
true;
1057 while (!BasicBlockFwdRefQueue.empty()) {
1058 Function *
F = BasicBlockFwdRefQueue.front();
1059 BasicBlockFwdRefQueue.pop_front();
1060 assert(
F &&
"Expected valid function");
1061 if (!BasicBlockFwdRefs.
count(
F))
1069 if (!
F->isMaterializable())
1070 return error(
"Never resolved function from blockaddress");
1073 if (
Error Err = materialize(
F))
1076 assert(BasicBlockFwdRefs.
empty() &&
"Function missing from queue");
1078 for (Function *
F : BackwardRefFunctions)
1079 if (
Error Err = materialize(
F))
1081 BackwardRefFunctions.clear();
1084 WillMaterializeAllForwardRefs =
false;
1149 Flags.ReadOnly = (RawFlags >> 1) & 0x1;
1150 Flags.NoRecurse = (RawFlags >> 2) & 0x1;
1151 Flags.ReturnDoesNotAlias = (RawFlags >> 3) & 0x1;
1152 Flags.NoInline = (RawFlags >> 4) & 0x1;
1153 Flags.AlwaysInline = (RawFlags >> 5) & 0x1;
1154 Flags.NoUnwind = (RawFlags >> 6) & 0x1;
1155 Flags.MayThrow = (RawFlags >> 7) & 0x1;
1156 Flags.HasUnknownCall = (RawFlags >> 8) & 0x1;
1157 Flags.MustBeUnreachable = (RawFlags >> 9) & 0x1;
1173 RawFlags = RawFlags >> 4;
1174 bool NotEligibleToImport = (RawFlags & 0x1) || Version < 3;
1178 bool Live = (RawFlags & 0x2) || Version < 3;
1179 bool Local = (RawFlags & 0x4);
1180 bool AutoHide = (RawFlags & 0x8);
1183 Live,
Local, AutoHide, IK);
1189 (RawFlags & 0x1) ?
true :
false, (RawFlags & 0x2) ?
true :
false,
1190 (RawFlags & 0x4) ?
true :
false,
1194static std::pair<CalleeInfo::HotnessType, bool>
1198 bool HasTailCall = (RawFlags & 0x8);
1199 return {Hotness, HasTailCall};
1203 bool &HasTailCall) {
1204 static constexpr uint64_t RelBlockFreqMask =
1206 RelBF = RawFlags & RelBlockFreqMask;
1232 case 0:
return false;
1233 case 1:
return true;
1295 bool IsFP = Ty->isFPOrFPVectorTy();
1297 if (!IsFP && !Ty->isIntOrIntVectorTy())
1304 return IsFP ? Instruction::FNeg : -1;
1309 bool IsFP = Ty->isFPOrFPVectorTy();
1311 if (!IsFP && !Ty->isIntOrIntVectorTy())
1318 return IsFP ? Instruction::FAdd : Instruction::Add;
1320 return IsFP ? Instruction::FSub : Instruction::Sub;
1322 return IsFP ? Instruction::FMul : Instruction::Mul;
1324 return IsFP ? -1 : Instruction::UDiv;
1326 return IsFP ? Instruction::FDiv : Instruction::SDiv;
1328 return IsFP ? -1 : Instruction::URem;
1330 return IsFP ? Instruction::FRem : Instruction::SRem;
1332 return IsFP ? -1 : Instruction::Shl;
1334 return IsFP ? -1 : Instruction::LShr;
1336 return IsFP ? -1 : Instruction::AShr;
1338 return IsFP ? -1 : Instruction::And;
1340 return IsFP ? -1 : Instruction::Or;
1342 return IsFP ? -1 : Instruction::Xor;
1439Type *BitcodeReader::getTypeByID(
unsigned ID) {
1441 if (
ID >= TypeList.size())
1444 if (
Type *Ty = TypeList[
ID])
1449 return TypeList[
ID] = createIdentifiedStructType(
Context);
1452unsigned BitcodeReader::getContainedTypeID(
unsigned ID,
unsigned Idx) {
1453 auto It = ContainedTypeIDs.
find(
ID);
1454 if (It == ContainedTypeIDs.
end())
1455 return InvalidTypeID;
1457 if (Idx >= It->second.size())
1458 return InvalidTypeID;
1460 return It->second[Idx];
1463Type *BitcodeReader::getPtrElementTypeByID(
unsigned ID) {
1464 if (
ID >= TypeList.size())
1471 return getTypeByID(getContainedTypeID(
ID, 0));
1474unsigned BitcodeReader::getVirtualTypeID(
Type *Ty,
1475 ArrayRef<unsigned> ChildTypeIDs) {
1476 unsigned ChildTypeID = ChildTypeIDs.
empty() ? InvalidTypeID : ChildTypeIDs[0];
1477 auto CacheKey = std::make_pair(Ty, ChildTypeID);
1478 auto It = VirtualTypeIDs.
find(CacheKey);
1479 if (It != VirtualTypeIDs.
end()) {
1485 ContainedTypeIDs[It->second] == ChildTypeIDs) &&
1486 "Incorrect cached contained type IDs");
1490 unsigned TypeID = TypeList.size();
1491 TypeList.push_back(Ty);
1492 if (!ChildTypeIDs.
empty())
1513 if (Opcode >= BitcodeConstant::FirstSpecialOpcode)
1527 if (Opcode == Instruction::GetElementPtr)
1531 case Instruction::FNeg:
1532 case Instruction::Select:
1533 case Instruction::ICmp:
1534 case Instruction::FCmp:
1541Expected<Value *> BitcodeReader::materializeValue(
unsigned StartValID,
1542 BasicBlock *InsertBB) {
1544 if (StartValID < ValueList.
size() && ValueList[StartValID] &&
1546 return ValueList[StartValID];
1548 SmallDenseMap<unsigned, Value *> MaterializedValues;
1549 SmallVector<unsigned> Worklist;
1551 while (!Worklist.
empty()) {
1552 unsigned ValID = Worklist.
back();
1553 if (MaterializedValues.
count(ValID)) {
1559 if (ValID >= ValueList.
size() || !ValueList[ValID])
1560 return error(
"Invalid value ID");
1562 Value *
V = ValueList[ValID];
1565 MaterializedValues.
insert({ValID,
V});
1573 for (
unsigned OpID :
reverse(BC->getOperandIDs())) {
1574 auto It = MaterializedValues.
find(OpID);
1575 if (It != MaterializedValues.
end())
1576 Ops.push_back(It->second);
1583 if (
Ops.size() != BC->getOperandIDs().size())
1585 std::reverse(
Ops.begin(),
Ops.end());
1602 switch (BC->Opcode) {
1603 case BitcodeConstant::ConstantPtrAuthOpcode: {
1606 return error(
"ptrauth key operand must be ConstantInt");
1610 return error(
"ptrauth disc operand must be ConstantInt");
1615 case BitcodeConstant::NoCFIOpcode: {
1618 return error(
"no_cfi operand must be GlobalValue");
1622 case BitcodeConstant::DSOLocalEquivalentOpcode: {
1625 return error(
"dso_local operand must be GlobalValue");
1629 case BitcodeConstant::BlockAddressOpcode: {
1632 return error(
"blockaddress operand must be a function");
1637 unsigned BBID = BC->BlockAddressBB;
1640 return error(
"Invalid ID");
1643 for (
size_t I = 0,
E = BBID;
I !=
E; ++
I) {
1645 return error(
"Invalid ID");
1652 auto &FwdBBs = BasicBlockFwdRefs[Fn];
1654 BasicBlockFwdRefQueue.push_back(Fn);
1655 if (FwdBBs.size() < BBID + 1)
1656 FwdBBs.resize(BBID + 1);
1664 case BitcodeConstant::ConstantStructOpcode: {
1666 if (
ST->getNumElements() != ConstOps.
size())
1667 return error(
"Invalid number of elements in struct initializer");
1669 for (
const auto [Ty,
Op] :
zip(
ST->elements(), ConstOps))
1670 if (
Op->getType() != Ty)
1671 return error(
"Incorrect type in struct initializer");
1676 case BitcodeConstant::ConstantArrayOpcode: {
1678 if (AT->getNumElements() != ConstOps.
size())
1679 return error(
"Invalid number of elements in array initializer");
1681 for (Constant *
Op : ConstOps)
1682 if (
Op->getType() != AT->getElementType())
1683 return error(
"Incorrect type in array initializer");
1688 case BitcodeConstant::ConstantVectorOpcode: {
1690 if (VT->getNumElements() != ConstOps.size())
1691 return error(
"Invalid number of elements in vector initializer");
1693 for (Constant *
Op : ConstOps)
1694 if (
Op->getType() != VT->getElementType())
1695 return error(
"Incorrect type in vector initializer");
1700 case Instruction::GetElementPtr:
1702 BC->SrcElemTy, ConstOps[0],
ArrayRef(ConstOps).drop_front(),
1705 case Instruction::ExtractElement:
1708 case Instruction::InsertElement:
1712 case Instruction::ShuffleVector: {
1713 SmallVector<int, 16>
Mask;
1725 MaterializedValues.
insert({ValID,
C});
1731 return error(Twine(
"Value referenced by initializer is an unsupported "
1732 "constant expression of type ") +
1733 BC->getOpcodeName());
1739 BC->getType(),
"constexpr", InsertBB);
1742 "constexpr", InsertBB);
1745 Ops[1],
"constexpr", InsertBB);
1748 I->setHasNoSignedWrap();
1750 I->setHasNoUnsignedWrap();
1756 switch (BC->Opcode) {
1757 case BitcodeConstant::ConstantVectorOpcode: {
1758 Type *IdxTy = Type::getInt32Ty(BC->getContext());
1761 Value *Idx = ConstantInt::get(IdxTy, Pair.index());
1768 case BitcodeConstant::ConstantStructOpcode:
1769 case BitcodeConstant::ConstantArrayOpcode: {
1773 "constexpr.ins", InsertBB);
1777 case Instruction::ICmp:
1778 case Instruction::FCmp:
1781 "constexpr", InsertBB);
1783 case Instruction::GetElementPtr:
1789 case Instruction::Select:
1792 case Instruction::ExtractElement:
1795 case Instruction::InsertElement:
1799 case Instruction::ShuffleVector:
1800 I =
new ShuffleVectorInst(
Ops[0],
Ops[1],
Ops[2],
"constexpr",
1808 MaterializedValues.
insert({ValID,
I});
1812 return MaterializedValues[StartValID];
1815Expected<Constant *> BitcodeReader::getValueForInitializer(
unsigned ID) {
1816 Expected<Value *> MaybeV = materializeValue(
ID,
nullptr);
1824StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &
Context,
1827 IdentifiedStructTypes.push_back(Ret);
1831StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &
Context) {
1833 IdentifiedStructTypes.push_back(Ret);
1849 case Attribute::ZExt:
return 1 << 0;
1850 case Attribute::SExt:
return 1 << 1;
1851 case Attribute::NoReturn:
return 1 << 2;
1852 case Attribute::InReg:
return 1 << 3;
1853 case Attribute::StructRet:
return 1 << 4;
1854 case Attribute::NoUnwind:
return 1 << 5;
1855 case Attribute::NoAlias:
return 1 << 6;
1856 case Attribute::ByVal:
return 1 << 7;
1857 case Attribute::Nest:
return 1 << 8;
1858 case Attribute::ReadNone:
return 1 << 9;
1859 case Attribute::ReadOnly:
return 1 << 10;
1860 case Attribute::NoInline:
return 1 << 11;
1861 case Attribute::AlwaysInline:
return 1 << 12;
1862 case Attribute::OptimizeForSize:
return 1 << 13;
1863 case Attribute::StackProtect:
return 1 << 14;
1864 case Attribute::StackProtectReq:
return 1 << 15;
1865 case Attribute::Alignment:
return 31 << 16;
1867 case Attribute::NoRedZone:
return 1 << 22;
1868 case Attribute::NoImplicitFloat:
return 1 << 23;
1869 case Attribute::Naked:
return 1 << 24;
1870 case Attribute::InlineHint:
return 1 << 25;
1871 case Attribute::StackAlignment:
return 7 << 26;
1872 case Attribute::ReturnsTwice:
return 1 << 29;
1873 case Attribute::UWTable:
return 1 << 30;
1874 case Attribute::NonLazyBind:
return 1U << 31;
1875 case Attribute::SanitizeAddress:
return 1ULL << 32;
1876 case Attribute::MinSize:
return 1ULL << 33;
1877 case Attribute::NoDuplicate:
return 1ULL << 34;
1878 case Attribute::StackProtectStrong:
return 1ULL << 35;
1879 case Attribute::SanitizeThread:
return 1ULL << 36;
1880 case Attribute::SanitizeMemory:
return 1ULL << 37;
1881 case Attribute::NoBuiltin:
return 1ULL << 38;
1882 case Attribute::Returned:
return 1ULL << 39;
1883 case Attribute::Cold:
return 1ULL << 40;
1884 case Attribute::Builtin:
return 1ULL << 41;
1885 case Attribute::OptimizeNone:
return 1ULL << 42;
1886 case Attribute::InAlloca:
return 1ULL << 43;
1887 case Attribute::NonNull:
return 1ULL << 44;
1888 case Attribute::JumpTable:
return 1ULL << 45;
1889 case Attribute::Convergent:
return 1ULL << 46;
1890 case Attribute::SafeStack:
return 1ULL << 47;
1891 case Attribute::NoRecurse:
return 1ULL << 48;
1894 case Attribute::SwiftSelf:
return 1ULL << 51;
1895 case Attribute::SwiftError:
return 1ULL << 52;
1896 case Attribute::WriteOnly:
return 1ULL << 53;
1897 case Attribute::Speculatable:
return 1ULL << 54;
1898 case Attribute::StrictFP:
return 1ULL << 55;
1899 case Attribute::SanitizeHWAddress:
return 1ULL << 56;
1900 case Attribute::NoCfCheck:
return 1ULL << 57;
1901 case Attribute::OptForFuzzing:
return 1ULL << 58;
1902 case Attribute::ShadowCallStack:
return 1ULL << 59;
1903 case Attribute::SpeculativeLoadHardening:
1905 case Attribute::ImmArg:
1907 case Attribute::WillReturn:
1909 case Attribute::NoFree:
1925 if (
I == Attribute::Alignment)
1926 B.addAlignmentAttr(1ULL << ((
A >> 16) - 1));
1927 else if (
I == Attribute::StackAlignment)
1928 B.addStackAlignmentAttr(1ULL << ((
A >> 26)-1));
1930 B.addTypeAttr(
I,
nullptr);
1944 unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
1946 "Alignment must be a power of two.");
1949 B.addAlignmentAttr(Alignment);
1951 uint64_t Attrs = ((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
1952 (EncodedAttrs & 0xffff);
1954 if (AttrIdx == AttributeList::FunctionIndex) {
1957 if (Attrs & (1ULL << 9)) {
1959 Attrs &= ~(1ULL << 9);
1962 if (Attrs & (1ULL << 10)) {
1964 Attrs &= ~(1ULL << 10);
1967 if (Attrs & (1ULL << 49)) {
1969 Attrs &= ~(1ULL << 49);
1972 if (Attrs & (1ULL << 50)) {
1974 Attrs &= ~(1ULL << 50);
1977 if (Attrs & (1ULL << 53)) {
1979 Attrs &= ~(1ULL << 53);
1983 B.addMemoryAttr(ME);
1987 if (Attrs & (1ULL << 21)) {
1988 Attrs &= ~(1ULL << 21);
1995Error BitcodeReader::parseAttributeBlock() {
1999 if (!MAttributes.empty())
2000 return error(
"Invalid multiple blocks");
2002 SmallVector<uint64_t, 64> Record;
2008 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2011 BitstreamEntry
Entry = MaybeEntry.
get();
2013 switch (
Entry.Kind) {
2016 return error(
"Malformed block");
2026 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2029 switch (MaybeRecord.
get()) {
2034 if (Record.
size() & 1)
2035 return error(
"Invalid parameter attribute record");
2037 for (
unsigned i = 0, e = Record.
size(); i != e; i += 2) {
2043 MAttributes.push_back(AttributeList::get(
Context, Attrs));
2047 for (uint64_t Val : Record)
2048 Attrs.push_back(MAttributeGroups[Val]);
2050 MAttributes.push_back(AttributeList::get(
Context, Attrs));
2063 return Attribute::Alignment;
2065 return Attribute::AlwaysInline;
2067 return Attribute::Builtin;
2069 return Attribute::ByVal;
2071 return Attribute::InAlloca;
2073 return Attribute::Cold;
2075 return Attribute::Convergent;
2077 return Attribute::DisableSanitizerInstrumentation;
2079 return Attribute::ElementType;
2081 return Attribute::FnRetThunkExtern;
2083 return Attribute::InlineHint;
2085 return Attribute::InReg;
2087 return Attribute::JumpTable;
2089 return Attribute::Memory;
2091 return Attribute::NoFPClass;
2093 return Attribute::MinSize;
2095 return Attribute::Naked;
2097 return Attribute::Nest;
2099 return Attribute::NoAlias;
2101 return Attribute::NoBuiltin;
2103 return Attribute::NoCallback;
2105 return Attribute::NoDivergenceSource;
2107 return Attribute::NoDuplicate;
2109 return Attribute::NoFree;
2111 return Attribute::NoImplicitFloat;
2113 return Attribute::NoInline;
2115 return Attribute::NoRecurse;
2117 return Attribute::NoMerge;
2119 return Attribute::NonLazyBind;
2121 return Attribute::NonNull;
2123 return Attribute::Dereferenceable;
2125 return Attribute::DereferenceableOrNull;
2127 return Attribute::AllocAlign;
2129 return Attribute::AllocKind;
2131 return Attribute::AllocSize;
2133 return Attribute::AllocatedPointer;
2135 return Attribute::NoRedZone;
2137 return Attribute::NoReturn;
2139 return Attribute::NoSync;
2141 return Attribute::NoCfCheck;
2143 return Attribute::NoProfile;
2145 return Attribute::SkipProfile;
2147 return Attribute::NoUnwind;
2149 return Attribute::NoSanitizeBounds;
2151 return Attribute::NoSanitizeCoverage;
2153 return Attribute::NullPointerIsValid;
2155 return Attribute::OptimizeForDebugging;
2157 return Attribute::OptForFuzzing;
2159 return Attribute::OptimizeForSize;
2161 return Attribute::OptimizeNone;
2163 return Attribute::ReadNone;
2165 return Attribute::ReadOnly;
2167 return Attribute::Returned;
2169 return Attribute::ReturnsTwice;
2171 return Attribute::SExt;
2173 return Attribute::Speculatable;
2175 return Attribute::StackAlignment;
2177 return Attribute::StackProtect;
2179 return Attribute::StackProtectReq;
2181 return Attribute::StackProtectStrong;
2183 return Attribute::SafeStack;
2185 return Attribute::ShadowCallStack;
2187 return Attribute::StrictFP;
2189 return Attribute::StructRet;
2191 return Attribute::SanitizeAddress;
2193 return Attribute::SanitizeHWAddress;
2195 return Attribute::SanitizeThread;
2197 return Attribute::SanitizeType;
2199 return Attribute::SanitizeMemory;
2201 return Attribute::SanitizeNumericalStability;
2203 return Attribute::SanitizeRealtime;
2205 return Attribute::SanitizeRealtimeBlocking;
2207 return Attribute::SanitizeAllocToken;
2209 return Attribute::SpeculativeLoadHardening;
2211 return Attribute::SwiftError;
2213 return Attribute::SwiftSelf;
2215 return Attribute::SwiftAsync;
2217 return Attribute::UWTable;
2219 return Attribute::VScaleRange;
2221 return Attribute::WillReturn;
2223 return Attribute::WriteOnly;
2225 return Attribute::ZExt;
2227 return Attribute::ImmArg;
2229 return Attribute::SanitizeMemTag;
2231 return Attribute::Preallocated;
2233 return Attribute::NoUndef;
2235 return Attribute::ByRef;
2237 return Attribute::MustProgress;
2239 return Attribute::Hot;
2241 return Attribute::PresplitCoroutine;
2243 return Attribute::Writable;
2245 return Attribute::CoroDestroyOnlyWhenComplete;
2247 return Attribute::DeadOnUnwind;
2249 return Attribute::Range;
2251 return Attribute::Initializes;
2253 return Attribute::CoroElideSafe;
2255 return Attribute::NoExt;
2257 return Attribute::Captures;
2259 return Attribute::DeadOnReturn;
2264 MaybeAlign &Alignment) {
2267 if (
Exponent > Value::MaxAlignmentExponent + 1)
2268 return error(
"Invalid alignment value");
2273Error BitcodeReader::parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) {
2275 if (*Kind == Attribute::None)
2276 return error(
"Unknown attribute kind (" + Twine(Code) +
")");
2281 switch (EncodedKind) {
2305Error BitcodeReader::parseAttributeGroupBlock() {
2309 if (!MAttributeGroups.empty())
2310 return error(
"Invalid multiple blocks");
2312 SmallVector<uint64_t, 64> Record;
2316 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2319 BitstreamEntry
Entry = MaybeEntry.
get();
2321 switch (
Entry.Kind) {
2324 return error(
"Malformed block");
2334 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2337 switch (MaybeRecord.
get()) {
2341 if (Record.
size() < 3)
2342 return error(
"Invalid grp record");
2344 uint64_t GrpID = Record[0];
2345 uint64_t Idx = Record[1];
2349 for (
unsigned i = 2, e = Record.
size(); i != e; ++i) {
2350 if (Record[i] == 0) {
2351 Attribute::AttrKind
Kind;
2352 uint64_t EncodedKind = Record[++i];
2353 if (Idx == AttributeList::FunctionIndex &&
2362 if (
Error Err = parseAttrKind(EncodedKind, &Kind))
2368 if (Kind == Attribute::ByVal)
2369 B.addByValAttr(
nullptr);
2370 else if (Kind == Attribute::StructRet)
2371 B.addStructRetAttr(
nullptr);
2372 else if (Kind == Attribute::InAlloca)
2373 B.addInAllocaAttr(
nullptr);
2374 else if (Kind == Attribute::UWTable)
2375 B.addUWTableAttr(UWTableKind::Default);
2376 else if (Attribute::isEnumAttrKind(Kind))
2377 B.addAttribute(Kind);
2379 return error(
"Not an enum attribute");
2380 }
else if (Record[i] == 1) {
2381 Attribute::AttrKind
Kind;
2382 if (
Error Err = parseAttrKind(Record[++i], &Kind))
2384 if (!Attribute::isIntAttrKind(Kind))
2385 return error(
"Not an int attribute");
2386 if (Kind == Attribute::Alignment)
2387 B.addAlignmentAttr(Record[++i]);
2388 else if (Kind == Attribute::StackAlignment)
2389 B.addStackAlignmentAttr(Record[++i]);
2390 else if (Kind == Attribute::Dereferenceable)
2391 B.addDereferenceableAttr(Record[++i]);
2392 else if (Kind == Attribute::DereferenceableOrNull)
2393 B.addDereferenceableOrNullAttr(Record[++i]);
2394 else if (Kind == Attribute::AllocSize)
2395 B.addAllocSizeAttrFromRawRepr(Record[++i]);
2396 else if (Kind == Attribute::VScaleRange)
2397 B.addVScaleRangeAttrFromRawRepr(Record[++i]);
2398 else if (Kind == Attribute::UWTable)
2400 else if (Kind == Attribute::AllocKind)
2401 B.addAllocKindAttr(
static_cast<AllocFnKind>(Record[++i]));
2402 else if (Kind == Attribute::Memory) {
2403 uint64_t EncodedME = Record[++i];
2404 const uint8_t
Version = (EncodedME >> 56);
2416 B.addMemoryAttr(ME);
2421 EncodedME & 0x00FFFFFFFFFFFFFFULL));
2423 }
else if (Kind == Attribute::Captures)
2425 else if (Kind == Attribute::NoFPClass)
2428 }
else if (Record[i] == 3 || Record[i] == 4) {
2429 bool HasValue = (Record[i++] == 4);
2430 SmallString<64> KindStr;
2431 SmallString<64> ValStr;
2433 while (Record[i] != 0 && i != e)
2434 KindStr += Record[i++];
2435 assert(Record[i] == 0 &&
"Kind string not null terminated");
2440 while (Record[i] != 0 && i != e)
2441 ValStr += Record[i++];
2442 assert(Record[i] == 0 &&
"Value string not null terminated");
2445 B.addAttribute(KindStr.
str(), ValStr.
str());
2446 }
else if (Record[i] == 5 || Record[i] == 6) {
2447 bool HasType = Record[i] == 6;
2448 Attribute::AttrKind
Kind;
2449 if (
Error Err = parseAttrKind(Record[++i], &Kind))
2451 if (!Attribute::isTypeAttrKind(Kind))
2452 return error(
"Not a type attribute");
2454 B.addTypeAttr(Kind, HasType ? getTypeByID(Record[++i]) :
nullptr);
2455 }
else if (Record[i] == 7) {
2456 Attribute::AttrKind
Kind;
2459 if (
Error Err = parseAttrKind(Record[i++], &Kind))
2461 if (!Attribute::isConstantRangeAttrKind(Kind))
2462 return error(
"Not a ConstantRange attribute");
2464 Expected<ConstantRange> MaybeCR =
2465 readBitWidthAndConstantRange(Record, i);
2470 B.addConstantRangeAttr(Kind, MaybeCR.
get());
2471 }
else if (Record[i] == 8) {
2472 Attribute::AttrKind
Kind;
2475 if (
Error Err = parseAttrKind(Record[i++], &Kind))
2477 if (!Attribute::isConstantRangeListAttrKind(Kind))
2478 return error(
"Not a constant range list attribute");
2482 return error(
"Too few records for constant range list");
2483 unsigned RangeSize = Record[i++];
2485 for (
unsigned Idx = 0; Idx < RangeSize; ++Idx) {
2486 Expected<ConstantRange> MaybeCR =
2487 readConstantRange(Record, i,
BitWidth);
2495 return error(
"Invalid (unordered or overlapping) range list");
2496 B.addConstantRangeListAttr(Kind, Val);
2498 return error(
"Invalid attribute group entry");
2503 B.addMemoryAttr(ME);
2506 MAttributeGroups[GrpID] = AttributeList::get(
Context, Idx,
B);
2513Error BitcodeReader::parseTypeTable() {
2517 return parseTypeTableBody();
2520Error BitcodeReader::parseTypeTableBody() {
2521 if (!TypeList.empty())
2522 return error(
"Invalid multiple blocks");
2524 SmallVector<uint64_t, 64> Record;
2525 unsigned NumRecords = 0;
2531 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2534 BitstreamEntry
Entry = MaybeEntry.
get();
2536 switch (
Entry.Kind) {
2539 return error(
"Malformed block");
2541 if (NumRecords != TypeList.size())
2542 return error(
"Malformed block");
2551 Type *ResultTy =
nullptr;
2552 SmallVector<unsigned> ContainedIDs;
2553 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2556 switch (MaybeRecord.
get()) {
2558 return error(
"Invalid value");
2563 return error(
"Invalid numentry record");
2564 TypeList.resize(Record[0]);
2567 ResultTy = Type::getVoidTy(
Context);
2570 ResultTy = Type::getHalfTy(
Context);
2573 ResultTy = Type::getBFloatTy(
Context);
2576 ResultTy = Type::getFloatTy(
Context);
2579 ResultTy = Type::getDoubleTy(
Context);
2582 ResultTy = Type::getX86_FP80Ty(
Context);
2585 ResultTy = Type::getFP128Ty(
Context);
2588 ResultTy = Type::getPPC_FP128Ty(
Context);
2591 ResultTy = Type::getLabelTy(
Context);
2594 ResultTy = Type::getMetadataTy(
Context);
2602 ResultTy = Type::getX86_AMXTy(
Context);
2605 ResultTy = Type::getTokenTy(
Context);
2609 return error(
"Invalid integer record");
2611 uint64_t NumBits = Record[0];
2614 return error(
"Bitwidth for integer type out of range");
2621 return error(
"Invalid pointer record");
2623 if (Record.
size() == 2)
2625 ResultTy = getTypeByID(Record[0]);
2627 !PointerType::isValidElementType(ResultTy))
2628 return error(
"Invalid type");
2634 if (Record.
size() != 1)
2635 return error(
"Invalid opaque pointer record");
2643 if (Record.
size() < 3)
2644 return error(
"Invalid function record");
2646 for (
unsigned i = 3, e = Record.
size(); i != e; ++i) {
2647 if (
Type *
T = getTypeByID(Record[i]))
2653 ResultTy = getTypeByID(Record[2]);
2654 if (!ResultTy || ArgTys.
size() < Record.
size()-3)
2655 return error(
"Invalid type");
2658 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
2663 if (Record.
size() < 2)
2664 return error(
"Invalid function record");
2666 for (
unsigned i = 2, e = Record.
size(); i != e; ++i) {
2667 if (
Type *
T = getTypeByID(Record[i])) {
2668 if (!FunctionType::isValidArgumentType(
T))
2669 return error(
"Invalid function argument type");
2676 ResultTy = getTypeByID(Record[1]);
2677 if (!ResultTy || ArgTys.
size() < Record.
size()-2)
2678 return error(
"Invalid type");
2681 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
2686 return error(
"Invalid anon struct record");
2688 for (
unsigned i = 1, e = Record.
size(); i != e; ++i) {
2689 if (
Type *
T = getTypeByID(Record[i]))
2694 if (EltTys.
size() != Record.
size()-1)
2695 return error(
"Invalid type");
2702 return error(
"Invalid struct name record");
2707 return error(
"Invalid named struct record");
2709 if (NumRecords >= TypeList.size())
2710 return error(
"Invalid TYPE table");
2716 TypeList[NumRecords] =
nullptr;
2718 Res = createIdentifiedStructType(
Context, TypeName);
2722 for (
unsigned i = 1, e = Record.
size(); i != e; ++i) {
2723 if (
Type *
T = getTypeByID(Record[i]))
2728 if (EltTys.
size() != Record.
size()-1)
2729 return error(
"Invalid named struct record");
2737 if (Record.
size() != 1)
2738 return error(
"Invalid opaque type record");
2740 if (NumRecords >= TypeList.size())
2741 return error(
"Invalid TYPE table");
2747 TypeList[NumRecords] =
nullptr;
2749 Res = createIdentifiedStructType(
Context, TypeName);
2755 if (Record.
size() < 1)
2756 return error(
"Invalid target extension type record");
2758 if (NumRecords >= TypeList.size())
2759 return error(
"Invalid TYPE table");
2761 if (Record[0] >= Record.
size())
2762 return error(
"Too many type parameters");
2764 unsigned NumTys = Record[0];
2766 SmallVector<unsigned, 8> IntParams;
2767 for (
unsigned i = 0; i < NumTys; i++) {
2768 if (
Type *
T = getTypeByID(Record[i + 1]))
2771 return error(
"Invalid type");
2774 for (
unsigned i = NumTys + 1, e = Record.
size(); i < e; i++) {
2775 if (Record[i] > UINT_MAX)
2776 return error(
"Integer parameter too large");
2781 if (
auto E = TTy.takeError())
2788 if (Record.
size() < 2)
2789 return error(
"Invalid array type record");
2790 ResultTy = getTypeByID(Record[1]);
2791 if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
2792 return error(
"Invalid type");
2794 ResultTy = ArrayType::get(ResultTy, Record[0]);
2798 if (Record.
size() < 2)
2799 return error(
"Invalid vector type record");
2801 return error(
"Invalid vector length");
2802 ResultTy = getTypeByID(Record[1]);
2803 if (!ResultTy || !VectorType::isValidElementType(ResultTy))
2804 return error(
"Invalid type");
2805 bool Scalable = Record.
size() > 2 ? Record[2] :
false;
2807 ResultTy = VectorType::get(ResultTy, Record[0], Scalable);
2811 if (NumRecords >= TypeList.size())
2812 return error(
"Invalid TYPE table");
2813 if (TypeList[NumRecords])
2815 "Invalid TYPE table: Only named structs can be forward referenced");
2816 assert(ResultTy &&
"Didn't read a type?");
2817 TypeList[NumRecords] = ResultTy;
2818 if (!ContainedIDs.
empty())
2819 ContainedTypeIDs[NumRecords] = std::move(ContainedIDs);
2824Error BitcodeReader::parseOperandBundleTags() {
2828 if (!BundleTags.empty())
2829 return error(
"Invalid multiple blocks");
2831 SmallVector<uint64_t, 64> Record;
2834 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2837 BitstreamEntry
Entry = MaybeEntry.
get();
2839 switch (
Entry.Kind) {
2842 return error(
"Malformed block");
2852 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2856 return error(
"Invalid operand bundle record");
2859 BundleTags.emplace_back();
2861 return error(
"Invalid operand bundle record");
2866Error BitcodeReader::parseSyncScopeNames() {
2871 return error(
"Invalid multiple synchronization scope names blocks");
2873 SmallVector<uint64_t, 64> Record;
2875 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2878 BitstreamEntry
Entry = MaybeEntry.
get();
2880 switch (
Entry.Kind) {
2883 return error(
"Malformed block");
2886 return error(
"Invalid empty synchronization scope names block");
2896 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2900 return error(
"Invalid sync scope record");
2902 SmallString<16> SSN;
2904 return error(
"Invalid sync scope record");
2912Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,
2913 unsigned NameIndex, Triple &TT) {
2916 return error(
"Invalid record");
2917 unsigned ValueID = Record[0];
2918 if (ValueID >= ValueList.
size() || !ValueList[ValueID])
2919 return error(
"Invalid record");
2920 Value *
V = ValueList[ValueID];
2923 if (NameStr.contains(0))
2924 return error(
"Invalid value name");
2925 V->setName(NameStr);
2927 if (GO && ImplicitComdatObjects.
contains(GO) &&
TT.supportsCOMDAT())
2940 return std::move(JumpFailed);
2946 return error(
"Expected value symbol table subblock");
2950void BitcodeReader::setDeferredFunctionInfo(
unsigned FuncBitcodeOffsetDelta,
2952 ArrayRef<uint64_t> Record) {
2956 uint64_t FuncWordOffset = Record[1] - 1;
2957 uint64_t FuncBitOffset = FuncWordOffset * 32;
2958 DeferredFunctionInfo[
F] = FuncBitOffset + FuncBitcodeOffsetDelta;
2962 if (FuncBitOffset > LastFunctionBlockBit)
2963 LastFunctionBlockBit = FuncBitOffset;
2967Error BitcodeReader::parseGlobalValueSymbolTable() {
2968 unsigned FuncBitcodeOffsetDelta =
2974 SmallVector<uint64_t, 64> Record;
2976 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2979 BitstreamEntry
Entry = MaybeEntry.
get();
2981 switch (
Entry.Kind) {
2984 return error(
"Malformed block");
2992 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
2995 switch (MaybeRecord.
get()) {
2997 unsigned ValueID = Record[0];
2998 if (ValueID >= ValueList.
size() || !ValueList[ValueID])
2999 return error(
"Invalid value reference in symbol table");
3000 setDeferredFunctionInfo(FuncBitcodeOffsetDelta,
3010Error BitcodeReader::parseValueSymbolTable(uint64_t
Offset) {
3011 uint64_t CurrentBit;
3017 if (!MaybeCurrentBit)
3019 CurrentBit = MaybeCurrentBit.
get();
3022 if (
Error Err = parseGlobalValueSymbolTable())
3024 if (
Error JumpFailed = Stream.JumpToBit(CurrentBit))
3043 unsigned FuncBitcodeOffsetDelta =
3049 SmallVector<uint64_t, 64> Record;
3057 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
3060 BitstreamEntry
Entry = MaybeEntry.
get();
3062 switch (
Entry.Kind) {
3065 return error(
"Malformed block");
3068 if (
Error JumpFailed = Stream.JumpToBit(CurrentBit))
3078 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
3081 switch (MaybeRecord.
get()) {
3085 Expected<Value *> ValOrErr = recordValue(Record, 1, TT);
3093 Expected<Value *> ValOrErr = recordValue(Record, 2, TT);
3101 setDeferredFunctionInfo(FuncBitcodeOffsetDelta,
F, Record);
3106 return error(
"Invalid bbentry record");
3109 return error(
"Invalid bbentry record");
3121uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
3131Error BitcodeReader::resolveGlobalAndIndirectSymbolInits() {
3132 std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInitWorklist;
3133 std::vector<std::pair<GlobalValue *, unsigned>> IndirectSymbolInitWorklist;
3134 std::vector<FunctionOperandInfo> FunctionOperandWorklist;
3136 GlobalInitWorklist.swap(GlobalInits);
3137 IndirectSymbolInitWorklist.swap(IndirectSymbolInits);
3138 FunctionOperandWorklist.swap(FunctionOperands);
3140 while (!GlobalInitWorklist.empty()) {
3141 unsigned ValID = GlobalInitWorklist.back().second;
3142 if (ValID >= ValueList.
size()) {
3144 GlobalInits.push_back(GlobalInitWorklist.back());
3146 Expected<Constant *> MaybeC = getValueForInitializer(ValID);
3149 GlobalInitWorklist.back().first->setInitializer(MaybeC.
get());
3151 GlobalInitWorklist.pop_back();
3154 while (!IndirectSymbolInitWorklist.empty()) {
3155 unsigned ValID = IndirectSymbolInitWorklist.back().second;
3156 if (ValID >= ValueList.
size()) {
3157 IndirectSymbolInits.push_back(IndirectSymbolInitWorklist.back());
3159 Expected<Constant *> MaybeC = getValueForInitializer(ValID);
3163 GlobalValue *GV = IndirectSymbolInitWorklist.back().first;
3166 return error(
"Alias and aliasee types don't match");
3171 return error(
"Expected an alias or an ifunc");
3174 IndirectSymbolInitWorklist.pop_back();
3177 while (!FunctionOperandWorklist.empty()) {
3178 FunctionOperandInfo &
Info = FunctionOperandWorklist.back();
3179 if (
Info.PersonalityFn) {
3180 unsigned ValID =
Info.PersonalityFn - 1;
3181 if (ValID < ValueList.
size()) {
3182 Expected<Constant *> MaybeC = getValueForInitializer(ValID);
3185 Info.F->setPersonalityFn(MaybeC.
get());
3186 Info.PersonalityFn = 0;
3190 unsigned ValID =
Info.Prefix - 1;
3191 if (ValID < ValueList.
size()) {
3192 Expected<Constant *> MaybeC = getValueForInitializer(ValID);
3195 Info.F->setPrefixData(MaybeC.
get());
3199 if (
Info.Prologue) {
3200 unsigned ValID =
Info.Prologue - 1;
3201 if (ValID < ValueList.
size()) {
3202 Expected<Constant *> MaybeC = getValueForInitializer(ValID);
3205 Info.F->setPrologueData(MaybeC.
get());
3209 if (
Info.PersonalityFn ||
Info.Prefix ||
Info.Prologue)
3210 FunctionOperands.push_back(
Info);
3211 FunctionOperandWorklist.pop_back();
3220 BitcodeReader::decodeSignRotatedValue);
3222 return APInt(TypeBits, Words);
3225Error BitcodeReader::parseConstants() {
3233 unsigned Int32TyID = getVirtualTypeID(CurTy);
3234 unsigned CurTyID = Int32TyID;
3235 Type *CurElemTy =
nullptr;
3236 unsigned NextCstNo = ValueList.
size();
3244 switch (Entry.Kind) {
3247 return error(
"Malformed block");
3249 if (NextCstNo != ValueList.
size())
3250 return error(
"Invalid constant reference");
3261 Expected<unsigned> MaybeBitCode = Stream.readRecord(
Entry.ID, Record);
3264 switch (
unsigned BitCode = MaybeBitCode.
get()) {
3274 return error(
"Invalid settype record");
3275 if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
3276 return error(
"Invalid settype record");
3277 if (TypeList[Record[0]] == VoidType)
3278 return error(
"Invalid constant type");
3279 CurTyID = Record[0];
3280 CurTy = TypeList[CurTyID];
3281 CurElemTy = getPtrElementTypeByID(CurTyID);
3285 return error(
"Invalid type for a constant null value");
3288 return error(
"Invalid type for a constant null value");
3293 return error(
"Invalid integer const record");
3298 return error(
"Invalid wide integer const record");
3301 APInt VInt =
readWideAPInt(Record, ScalarTy->getBitWidth());
3302 V = ConstantInt::get(CurTy, VInt);
3307 return error(
"Invalid float const record");
3310 if (ScalarTy->isHalfTy())
3311 V = ConstantFP::get(CurTy,
APFloat(APFloat::IEEEhalf(),
3312 APInt(16, (uint16_t)Record[0])));
3313 else if (ScalarTy->isBFloatTy())
3314 V = ConstantFP::get(
3315 CurTy,
APFloat(APFloat::BFloat(), APInt(16, (uint32_t)Record[0])));
3316 else if (ScalarTy->isFloatTy())
3317 V = ConstantFP::get(CurTy,
APFloat(APFloat::IEEEsingle(),
3318 APInt(32, (uint32_t)Record[0])));
3319 else if (ScalarTy->isDoubleTy())
3320 V = ConstantFP::get(
3321 CurTy,
APFloat(APFloat::IEEEdouble(), APInt(64, Record[0])));
3322 else if (ScalarTy->isX86_FP80Ty()) {
3324 uint64_t Rearrange[2];
3325 Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
3326 Rearrange[1] = Record[0] >> 48;
3327 V = ConstantFP::get(
3328 CurTy,
APFloat(APFloat::x87DoubleExtended(), APInt(80, Rearrange)));
3329 }
else if (ScalarTy->isFP128Ty())
3330 V = ConstantFP::get(CurTy,
3331 APFloat(APFloat::IEEEquad(), APInt(128, Record)));
3332 else if (ScalarTy->isPPC_FP128Ty())
3333 V = ConstantFP::get(
3334 CurTy,
APFloat(APFloat::PPCDoubleDouble(), APInt(128, Record)));
3342 return error(
"Invalid aggregate record");
3344 SmallVector<unsigned, 16> Elts;
3348 V = BitcodeConstant::create(
3349 Alloc, CurTy, BitcodeConstant::ConstantStructOpcode, Elts);
3351 V = BitcodeConstant::create(
Alloc, CurTy,
3352 BitcodeConstant::ConstantArrayOpcode, Elts);
3354 V = BitcodeConstant::create(
3355 Alloc, CurTy, BitcodeConstant::ConstantVectorOpcode, Elts);
3364 return error(
"Invalid string record");
3366 SmallString<16> Elts(Record.begin(), Record.end());
3373 return error(
"Invalid data record");
3377 EltTy =
Array->getElementType();
3387 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3393 SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
3399 SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
3405 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3411 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3417 SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
3423 SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
3429 return error(
"Invalid type for value");
3434 if (Record.size() < 2)
3435 return error(
"Invalid unary op constexpr record");
3440 V = BitcodeConstant::create(
Alloc, CurTy,
Opc, (
unsigned)Record[1]);
3445 if (Record.size() < 3)
3446 return error(
"Invalid binary op constexpr record");
3452 if (Record.size() >= 4) {
3453 if (
Opc == Instruction::Add ||
3454 Opc == Instruction::Sub ||
3455 Opc == Instruction::Mul ||
3456 Opc == Instruction::Shl) {
3461 }
else if (
Opc == Instruction::SDiv ||
3462 Opc == Instruction::UDiv ||
3463 Opc == Instruction::LShr ||
3464 Opc == Instruction::AShr) {
3469 V = BitcodeConstant::create(
Alloc, CurTy, {(uint8_t)
Opc, Flags},
3470 {(unsigned)Record[1], (
unsigned)Record[2]});
3475 if (Record.size() < 3)
3476 return error(
"Invalid cast constexpr record");
3481 unsigned OpTyID = Record[1];
3482 Type *OpTy = getTypeByID(OpTyID);
3484 return error(
"Invalid cast constexpr record");
3485 V = BitcodeConstant::create(
Alloc, CurTy,
Opc, (
unsigned)Record[2]);
3496 if (Record.size() < 2)
3497 return error(
"Constant GEP record must have at least two elements");
3499 Type *PointeeType =
nullptr;
3503 PointeeType = getTypeByID(Record[OpNum++]);
3506 std::optional<ConstantRange>
InRange;
3508 uint64_t
Op = Record[OpNum++];
3510 unsigned InRangeIndex =
Op >> 1;
3515 Flags = Record[OpNum++];
3516 Expected<ConstantRange> MaybeInRange =
3517 readBitWidthAndConstantRange(Record, OpNum);
3522 Flags = Record[OpNum++];
3526 SmallVector<unsigned, 16> Elts;
3527 unsigned BaseTypeID = Record[OpNum];
3528 while (OpNum != Record.size()) {
3529 unsigned ElTyID = Record[OpNum++];
3530 Type *ElTy = getTypeByID(ElTyID);
3532 return error(
"Invalid getelementptr constexpr record");
3536 if (Elts.
size() < 1)
3537 return error(
"Invalid gep with no operands");
3541 BaseTypeID = getContainedTypeID(BaseTypeID, 0);
3542 BaseType = getTypeByID(BaseTypeID);
3547 return error(
"GEP base operand must be pointer or vector of pointer");
3550 PointeeType = getPtrElementTypeByID(BaseTypeID);
3552 return error(
"Missing element type for old-style constant GEP");
3555 V = BitcodeConstant::create(
3557 {Instruction::GetElementPtr, uint8_t(Flags), PointeeType,
InRange},
3562 if (Record.size() < 3)
3563 return error(
"Invalid select constexpr record");
3565 V = BitcodeConstant::create(
3566 Alloc, CurTy, Instruction::Select,
3567 {(unsigned)Record[0], (
unsigned)Record[1], (unsigned)Record[2]});
3572 if (Record.size() < 3)
3573 return error(
"Invalid extractelement constexpr record");
3574 unsigned OpTyID = Record[0];
3578 return error(
"Invalid extractelement constexpr record");
3580 if (Record.size() == 4) {
3581 unsigned IdxTyID = Record[2];
3582 Type *IdxTy = getTypeByID(IdxTyID);
3584 return error(
"Invalid extractelement constexpr record");
3585 IdxRecord = Record[3];
3588 IdxRecord = Record[2];
3590 V = BitcodeConstant::create(
Alloc, CurTy, Instruction::ExtractElement,
3591 {(unsigned)Record[1], IdxRecord});
3597 if (Record.size() < 3 || !OpTy)
3598 return error(
"Invalid insertelement constexpr record");
3600 if (Record.size() == 4) {
3601 unsigned IdxTyID = Record[2];
3602 Type *IdxTy = getTypeByID(IdxTyID);
3604 return error(
"Invalid insertelement constexpr record");
3605 IdxRecord = Record[3];
3608 IdxRecord = Record[2];
3610 V = BitcodeConstant::create(
3611 Alloc, CurTy, Instruction::InsertElement,
3612 {(unsigned)Record[0], (
unsigned)Record[1], IdxRecord});
3617 if (Record.size() < 3 || !OpTy)
3618 return error(
"Invalid shufflevector constexpr record");
3619 V = BitcodeConstant::create(
3620 Alloc, CurTy, Instruction::ShuffleVector,
3621 {(unsigned)Record[0], (
unsigned)Record[1], (unsigned)Record[2]});
3628 if (Record.size() < 4 || !RTy || !OpTy)
3629 return error(
"Invalid shufflevector constexpr record");
3630 V = BitcodeConstant::create(
3631 Alloc, CurTy, Instruction::ShuffleVector,
3632 {(unsigned)Record[1], (
unsigned)Record[2], (unsigned)Record[3]});
3636 if (Record.size() < 4)
3637 return error(
"Invalid cmp constexpt record");
3638 unsigned OpTyID = Record[0];
3639 Type *OpTy = getTypeByID(OpTyID);
3641 return error(
"Invalid cmp constexpr record");
3642 V = BitcodeConstant::create(
3645 : Instruction::ICmp),
3646 (uint8_t)Record[3]},
3647 {(unsigned)Record[1], (
unsigned)Record[2]});
3653 if (Record.size() < 2)
3654 return error(
"Invalid inlineasm record");
3655 std::string AsmStr, ConstrStr;
3656 bool HasSideEffects = Record[0] & 1;
3657 bool IsAlignStack = Record[0] >> 1;
3658 unsigned AsmStrSize = Record[1];
3659 if (2+AsmStrSize >= Record.size())
3660 return error(
"Invalid inlineasm record");
3661 unsigned ConstStrSize = Record[2+AsmStrSize];
3662 if (3+AsmStrSize+ConstStrSize > Record.size())
3663 return error(
"Invalid inlineasm record");
3665 for (
unsigned i = 0; i != AsmStrSize; ++i)
3666 AsmStr += (
char)Record[2+i];
3667 for (
unsigned i = 0; i != ConstStrSize; ++i)
3668 ConstrStr += (
char)Record[3+AsmStrSize+i];
3671 return error(
"Missing element type for old-style inlineasm");
3673 HasSideEffects, IsAlignStack);
3679 if (Record.size() < 2)
3680 return error(
"Invalid inlineasm record");
3681 std::string AsmStr, ConstrStr;
3682 bool HasSideEffects = Record[0] & 1;
3683 bool IsAlignStack = (Record[0] >> 1) & 1;
3684 unsigned AsmDialect = Record[0] >> 2;
3685 unsigned AsmStrSize = Record[1];
3686 if (2+AsmStrSize >= Record.size())
3687 return error(
"Invalid inlineasm record");
3688 unsigned ConstStrSize = Record[2+AsmStrSize];
3689 if (3+AsmStrSize+ConstStrSize > Record.size())
3690 return error(
"Invalid inlineasm record");
3692 for (
unsigned i = 0; i != AsmStrSize; ++i)
3693 AsmStr += (
char)Record[2+i];
3694 for (
unsigned i = 0; i != ConstStrSize; ++i)
3695 ConstrStr += (
char)Record[3+AsmStrSize+i];
3698 return error(
"Missing element type for old-style inlineasm");
3700 HasSideEffects, IsAlignStack,
3706 if (Record.size() < 2)
3707 return error(
"Invalid inlineasm record");
3709 std::string AsmStr, ConstrStr;
3710 bool HasSideEffects = Record[OpNum] & 1;
3711 bool IsAlignStack = (Record[OpNum] >> 1) & 1;
3712 unsigned AsmDialect = (Record[OpNum] >> 2) & 1;
3713 bool CanThrow = (Record[OpNum] >> 3) & 1;
3715 unsigned AsmStrSize = Record[OpNum];
3717 if (OpNum + AsmStrSize >= Record.size())
3718 return error(
"Invalid inlineasm record");
3719 unsigned ConstStrSize = Record[OpNum + AsmStrSize];
3720 if (OpNum + 1 + AsmStrSize + ConstStrSize > Record.size())
3721 return error(
"Invalid inlineasm record");
3723 for (
unsigned i = 0; i != AsmStrSize; ++i)
3724 AsmStr += (
char)Record[OpNum + i];
3726 for (
unsigned i = 0; i != ConstStrSize; ++i)
3727 ConstrStr += (
char)Record[OpNum + AsmStrSize + i];
3730 return error(
"Missing element type for old-style inlineasm");
3732 HasSideEffects, IsAlignStack,
3738 if (Record.size() < 3)
3739 return error(
"Invalid inlineasm record");
3744 return error(
"Invalid inlineasm record");
3745 std::string AsmStr, ConstrStr;
3746 bool HasSideEffects = Record[OpNum] & 1;
3747 bool IsAlignStack = (Record[OpNum] >> 1) & 1;
3748 unsigned AsmDialect = (Record[OpNum] >> 2) & 1;
3749 bool CanThrow = (Record[OpNum] >> 3) & 1;
3751 unsigned AsmStrSize = Record[OpNum];
3753 if (OpNum + AsmStrSize >= Record.size())
3754 return error(
"Invalid inlineasm record");
3755 unsigned ConstStrSize = Record[OpNum + AsmStrSize];
3756 if (OpNum + 1 + AsmStrSize + ConstStrSize > Record.size())
3757 return error(
"Invalid inlineasm record");
3759 for (
unsigned i = 0; i != AsmStrSize; ++i)
3760 AsmStr += (
char)Record[OpNum + i];
3762 for (
unsigned i = 0; i != ConstStrSize; ++i)
3763 ConstrStr += (
char)Record[OpNum + AsmStrSize + i];
3765 V =
InlineAsm::get(FnTy, AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
3770 if (Record.size() < 3)
3771 return error(
"Invalid blockaddress record");
3772 unsigned FnTyID = Record[0];
3773 Type *FnTy = getTypeByID(FnTyID);
3775 return error(
"Invalid blockaddress record");
3776 V = BitcodeConstant::create(
3778 {BitcodeConstant::BlockAddressOpcode, 0, (unsigned)Record[2]},
3783 if (Record.size() < 2)
3784 return error(
"Invalid dso_local record");
3785 unsigned GVTyID = Record[0];
3786 Type *GVTy = getTypeByID(GVTyID);
3788 return error(
"Invalid dso_local record");
3789 V = BitcodeConstant::create(
3790 Alloc, CurTy, BitcodeConstant::DSOLocalEquivalentOpcode, Record[1]);
3794 if (Record.size() < 2)
3795 return error(
"Invalid no_cfi record");
3796 unsigned GVTyID = Record[0];
3797 Type *GVTy = getTypeByID(GVTyID);
3799 return error(
"Invalid no_cfi record");
3800 V = BitcodeConstant::create(
Alloc, CurTy, BitcodeConstant::NoCFIOpcode,
3805 if (Record.size() < 4)
3806 return error(
"Invalid ptrauth record");
3808 V = BitcodeConstant::create(
Alloc, CurTy,
3809 BitcodeConstant::ConstantPtrAuthOpcode,
3810 {(unsigned)Record[0], (
unsigned)Record[1],
3811 (unsigned)Record[2], (
unsigned)Record[3]});
3816 assert(
V->getType() == getTypeByID(CurTyID) &&
"Incorrect result type ID");
3823Error BitcodeReader::parseUseLists() {
3828 SmallVector<uint64_t, 64> Record;
3831 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
3834 BitstreamEntry
Entry = MaybeEntry.
get();
3836 switch (
Entry.Kind) {
3839 return error(
"Malformed block");
3850 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
3853 switch (MaybeRecord.
get()) {
3861 if (RecordLength < 3)
3863 return error(
"Invalid record");
3868 assert(
ID < FunctionBBs.size() &&
"Basic block not found");
3869 V = FunctionBBs[
ID];
3873 if (!
V->hasUseList())
3876 unsigned NumUses = 0;
3877 SmallDenseMap<const Use *, unsigned, 16> Order;
3878 for (
const Use &U :
V->materialized_uses()) {
3879 if (++NumUses > Record.
size())
3881 Order[&
U] = Record[NumUses - 1];
3883 if (Order.
size() != Record.
size() || NumUses > Record.
size())
3888 V->sortUseList([&](
const Use &L,
const Use &R) {
3899Error BitcodeReader::rememberAndSkipMetadata() {
3901 uint64_t CurBit = Stream.GetCurrentBitNo();
3902 DeferredMetadataInfo.push_back(CurBit);
3905 if (
Error Err = Stream.SkipBlock())
3910Error BitcodeReader::materializeMetadata() {
3911 for (uint64_t BitPos : DeferredMetadataInfo) {
3913 if (
Error JumpFailed = Stream.JumpToBit(BitPos))
3915 if (
Error Err = MDLoader->parseModuleMetadata())
3924 NamedMDNode *LinkerOpts =
3926 for (
const MDOperand &MDOptions :
cast<MDNode>(Val)->operands())
3931 DeferredMetadataInfo.clear();
3935void BitcodeReader::setStripDebugInfo() {
StripDebugInfo =
true; }
3939Error BitcodeReader::rememberAndSkipFunctionBody() {
3941 if (FunctionsWithBodies.empty())
3942 return error(
"Insufficient function protos");
3944 Function *Fn = FunctionsWithBodies.back();
3945 FunctionsWithBodies.pop_back();
3948 uint64_t CurBit = Stream.GetCurrentBitNo();
3950 (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&
3951 "Mismatch between VST and scanned function offsets");
3952 DeferredFunctionInfo[Fn] = CurBit;
3955 if (
Error Err = Stream.SkipBlock())
3960Error BitcodeReader::globalCleanup() {
3962 if (
Error Err = resolveGlobalAndIndirectSymbolInits())
3964 if (!GlobalInits.empty() || !IndirectSymbolInits.empty())
3965 return error(
"Malformed global initializer set");
3969 for (Function &
F : *TheModule) {
3970 MDLoader->upgradeDebugIntrinsics(
F);
3973 UpgradedIntrinsics[&
F] = NewFn;
3979 std::vector<std::pair<GlobalVariable *, GlobalVariable *>> UpgradedVariables;
3980 for (GlobalVariable &GV : TheModule->globals())
3982 UpgradedVariables.emplace_back(&GV, Upgraded);
3983 for (
auto &Pair : UpgradedVariables) {
3984 Pair.first->eraseFromParent();
3985 TheModule->insertGlobalVariable(Pair.second);
3990 std::vector<std::pair<GlobalVariable *, unsigned>>().
swap(GlobalInits);
3991 std::vector<std::pair<GlobalValue *, unsigned>>().
swap(IndirectSymbolInits);
3999Error BitcodeReader::rememberAndSkipFunctionBodies() {
4000 if (
Error JumpFailed = Stream.JumpToBit(NextUnreadBit))
4003 if (Stream.AtEndOfStream())
4004 return error(
"Could not find function in stream");
4006 if (!SeenFirstFunctionBody)
4007 return error(
"Trying to materialize functions before seeing function blocks");
4011 assert(SeenValueSymbolTable);
4014 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4017 llvm::BitstreamEntry
Entry = MaybeEntry.
get();
4019 switch (
Entry.Kind) {
4021 return error(
"Expect SubBlock");
4025 return error(
"Expect function block");
4027 if (
Error Err = rememberAndSkipFunctionBody())
4029 NextUnreadBit = Stream.GetCurrentBitNo();
4036Error BitcodeReaderBase::readBlockInfo() {
4037 Expected<std::optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
4039 if (!MaybeNewBlockInfo)
4041 std::optional<BitstreamBlockInfo> NewBlockInfo =
4042 std::move(MaybeNewBlockInfo.
get());
4044 return error(
"Malformed block");
4045 BlockInfo = std::move(*NewBlockInfo);
4049Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) {
4053 std::tie(Name, Record) = readNameFromStrtab(Record);
4056 return error(
"Invalid record");
4058 std::string OldFormatName;
4060 if (Record.
size() < 2)
4061 return error(
"Invalid record");
4062 unsigned ComdatNameSize = Record[1];
4063 if (ComdatNameSize > Record.
size() - 2)
4064 return error(
"Comdat name size too large");
4065 OldFormatName.reserve(ComdatNameSize);
4066 for (
unsigned i = 0; i != ComdatNameSize; ++i)
4067 OldFormatName += (
char)Record[2 + i];
4068 Name = OldFormatName;
4070 Comdat *
C = TheModule->getOrInsertComdat(Name);
4071 C->setSelectionKind(SK);
4072 ComdatList.push_back(
C);
4086 Meta.NoAddress =
true;
4088 Meta.NoHWAddress =
true;
4092 Meta.IsDynInit =
true;
4096Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
4104 std::tie(Name, Record) = readNameFromStrtab(Record);
4106 if (Record.
size() < 6)
4107 return error(
"Invalid record");
4108 unsigned TyID = Record[0];
4109 Type *Ty = getTypeByID(TyID);
4111 return error(
"Invalid record");
4113 bool explicitType = Record[1] & 2;
4119 return error(
"Invalid type for value");
4121 TyID = getContainedTypeID(TyID);
4122 Ty = getTypeByID(TyID);
4124 return error(
"Missing element type for old-style global");
4127 uint64_t RawLinkage = Record[3];
4129 MaybeAlign Alignment;
4130 if (
Error Err = parseAlignmentValue(Record[4], Alignment))
4134 if (Record[5] - 1 >= SectionTable.size())
4135 return error(
"Invalid ID");
4136 Section = SectionTable[Record[5] - 1];
4144 GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;
4145 if (Record.
size() > 7)
4149 if (Record.
size() > 8)
4152 bool ExternallyInitialized =
false;
4153 if (Record.
size() > 9)
4154 ExternallyInitialized = Record[9];
4156 GlobalVariable *NewGV =
4166 if (Record.
size() > 10) {
4178 if (
unsigned InitID = Record[2])
4179 GlobalInits.push_back(std::make_pair(NewGV, InitID - 1));
4181 if (Record.
size() > 11) {
4182 if (
unsigned ComdatID = Record[11]) {
4183 if (ComdatID > ComdatList.size())
4184 return error(
"Invalid global variable comdat ID");
4185 NewGV->
setComdat(ComdatList[ComdatID - 1]);
4188 ImplicitComdatObjects.
insert(NewGV);
4191 if (Record.
size() > 12) {
4196 if (Record.
size() > 13) {
4202 if (Record.
size() > 15)
4203 NewGV->
setPartition(StringRef(Strtab.data() + Record[14], Record[15]));
4205 if (Record.
size() > 16 && Record[16]) {
4206 llvm::GlobalValue::SanitizerMetadata
Meta =
4211 if (Record.
size() > 17 && Record[17]) {
4215 return error(
"Invalid global variable code model");
4221void BitcodeReader::callValueTypeCallback(
Value *
F,
unsigned TypeID) {
4222 if (ValueTypeCallback) {
4223 (*ValueTypeCallback)(
4224 F,
TypeID, [
this](
unsigned I) {
return getTypeByID(
I); },
4225 [
this](
unsigned I,
unsigned J) {
return getContainedTypeID(
I, J); });
4229Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
4235 std::tie(Name, Record) = readNameFromStrtab(Record);
4237 if (Record.
size() < 8)
4238 return error(
"Invalid record");
4239 unsigned FTyID = Record[0];
4240 Type *FTy = getTypeByID(FTyID);
4242 return error(
"Invalid record");
4244 FTyID = getContainedTypeID(FTyID, 0);
4245 FTy = getTypeByID(FTyID);
4247 return error(
"Missing element type for old-style function");
4251 return error(
"Invalid type for value");
4252 auto CC =
static_cast<CallingConv::ID
>(Record[1]);
4253 if (CC & ~CallingConv::MaxID)
4254 return error(
"Invalid calling convention ID");
4256 unsigned AddrSpace = TheModule->getDataLayout().getProgramAddressSpace();
4257 if (Record.
size() > 16)
4258 AddrSpace = Record[16];
4262 AddrSpace, Name, TheModule);
4265 "Incorrect fully specified type provided for function");
4266 FunctionTypeIDs[
Func] = FTyID;
4268 Func->setCallingConv(CC);
4269 bool isProto = Record[2];
4270 uint64_t RawLinkage = Record[3];
4273 callValueTypeCallback(Func, FTyID);
4278 for (
unsigned i = 0; i !=
Func->arg_size(); ++i) {
4279 for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
4280 Attribute::InAlloca}) {
4281 if (!
Func->hasParamAttribute(i, Kind))
4284 if (
Func->getParamAttribute(i, Kind).getValueAsType())
4287 Func->removeParamAttr(i, Kind);
4289 unsigned ParamTypeID = getContainedTypeID(FTyID, i + 1);
4290 Type *PtrEltTy = getPtrElementTypeByID(ParamTypeID);
4292 return error(
"Missing param element type for attribute upgrade");
4296 case Attribute::ByVal:
4297 NewAttr = Attribute::getWithByValType(
Context, PtrEltTy);
4299 case Attribute::StructRet:
4300 NewAttr = Attribute::getWithStructRetType(
Context, PtrEltTy);
4302 case Attribute::InAlloca:
4303 NewAttr = Attribute::getWithInAllocaType(
Context, PtrEltTy);
4309 Func->addParamAttr(i, NewAttr);
4313 if (
Func->getCallingConv() == CallingConv::X86_INTR &&
4314 !
Func->arg_empty() && !
Func->hasParamAttribute(0, Attribute::ByVal)) {
4315 unsigned ParamTypeID = getContainedTypeID(FTyID, 1);
4316 Type *ByValTy = getPtrElementTypeByID(ParamTypeID);
4318 return error(
"Missing param element type for x86_intrcc upgrade");
4320 Func->addParamAttr(0, NewAttr);
4323 MaybeAlign Alignment;
4324 if (
Error Err = parseAlignmentValue(Record[5], Alignment))
4327 Func->setAlignment(*Alignment);
4329 if (Record[6] - 1 >= SectionTable.size())
4330 return error(
"Invalid ID");
4331 Func->setSection(SectionTable[Record[6] - 1]);
4335 if (!
Func->hasLocalLinkage())
4337 if (Record.
size() > 8 && Record[8]) {
4338 if (Record[8] - 1 >= GCTable.size())
4339 return error(
"Invalid ID");
4340 Func->setGC(GCTable[Record[8] - 1]);
4343 if (Record.
size() > 9)
4345 Func->setUnnamedAddr(UnnamedAddr);
4347 FunctionOperandInfo OperandInfo = {
Func, 0, 0, 0};
4348 if (Record.
size() > 10)
4349 OperandInfo.Prologue = Record[10];
4351 if (Record.
size() > 11) {
4353 if (!
Func->hasLocalLinkage()) {
4360 if (Record.
size() > 12) {
4361 if (
unsigned ComdatID = Record[12]) {
4362 if (ComdatID > ComdatList.size())
4363 return error(
"Invalid function comdat ID");
4364 Func->setComdat(ComdatList[ComdatID - 1]);
4367 ImplicitComdatObjects.
insert(Func);
4370 if (Record.
size() > 13)
4371 OperandInfo.Prefix = Record[13];
4373 if (Record.
size() > 14)
4374 OperandInfo.PersonalityFn = Record[14];
4376 if (Record.
size() > 15) {
4385 if (Record.
size() > 18 && Strtab.data() &&
4386 Record[17] + Record[18] <= Strtab.size()) {
4387 Func->setPartition(StringRef(Strtab.data() + Record[17], Record[18]));
4390 ValueList.
push_back(Func, getVirtualTypeID(
Func->getType(), FTyID));
4392 if (OperandInfo.PersonalityFn || OperandInfo.Prefix || OperandInfo.Prologue)
4393 FunctionOperands.push_back(OperandInfo);
4398 Func->setIsMaterializable(
true);
4399 FunctionsWithBodies.push_back(Func);
4400 DeferredFunctionInfo[
Func] = 0;
4405Error BitcodeReader::parseGlobalIndirectSymbolRecord(
4406 unsigned BitCode, ArrayRef<uint64_t> Record) {
4416 std::tie(Name, Record) = readNameFromStrtab(Record);
4419 if (Record.
size() < (3 + (
unsigned)NewRecord))
4420 return error(
"Invalid record");
4422 unsigned TypeID = Record[OpNum++];
4425 return error(
"Invalid record");
4431 return error(
"Invalid type for value");
4432 AddrSpace = PTy->getAddressSpace();
4434 Ty = getTypeByID(
TypeID);
4436 return error(
"Missing element type for old-style indirect symbol");
4438 AddrSpace = Record[OpNum++];
4441 auto Val = Record[OpNum++];
4442 auto Linkage = Record[OpNum++];
4450 nullptr, TheModule);
4454 if (OpNum != Record.
size()) {
4455 auto VisInd = OpNum++;
4461 if (OpNum != Record.
size()) {
4462 auto S = Record[OpNum++];
4469 if (OpNum != Record.
size())
4471 if (OpNum != Record.
size())
4474 if (OpNum != Record.
size())
4479 if (OpNum + 1 < Record.
size()) {
4481 if (Record[OpNum] + Record[OpNum + 1] > Strtab.size())
4482 return error(
"Malformed partition, too large.");
4484 StringRef(Strtab.data() + Record[OpNum], Record[OpNum + 1]));
4488 IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
4492Error BitcodeReader::parseModule(uint64_t ResumeBit,
4493 bool ShouldLazyLoadMetadata,
4494 ParserCallbacks Callbacks) {
4495 this->ValueTypeCallback = std::move(Callbacks.
ValueType);
4497 if (
Error JumpFailed = Stream.JumpToBit(ResumeBit))
4502 SmallVector<uint64_t, 64> Record;
4506 bool ResolvedDataLayout =
false;
4511 std::string TentativeDataLayoutStr = TheModule->getDataLayoutStr();
4513 auto ResolveDataLayout = [&]() ->
Error {
4514 if (ResolvedDataLayout)
4518 ResolvedDataLayout =
true;
4522 TentativeDataLayoutStr, TheModule->getTargetTriple().str());
4526 if (
auto LayoutOverride = (*Callbacks.
DataLayout)(
4527 TheModule->getTargetTriple().str(), TentativeDataLayoutStr))
4528 TentativeDataLayoutStr = *LayoutOverride;
4536 TheModule->setDataLayout(MaybeDL.
get());
4542 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4545 llvm::BitstreamEntry
Entry = MaybeEntry.
get();
4547 switch (
Entry.Kind) {
4549 return error(
"Malformed block");
4551 if (
Error Err = ResolveDataLayout())
4553 return globalCleanup();
4558 if (
Error Err = Stream.SkipBlock())
4562 if (
Error Err = readBlockInfo())
4566 if (
Error Err = parseAttributeBlock())
4570 if (
Error Err = parseAttributeGroupBlock())
4574 if (
Error Err = parseTypeTable())
4578 if (!SeenValueSymbolTable) {
4584 assert(VSTOffset == 0 || FunctionsWithBodies.empty());
4585 if (
Error Err = parseValueSymbolTable())
4587 SeenValueSymbolTable =
true;
4592 if (
Error Err = Stream.SkipBlock())
4597 if (
Error Err = parseConstants())
4599 if (
Error Err = resolveGlobalAndIndirectSymbolInits())
4603 if (ShouldLazyLoadMetadata) {
4604 if (
Error Err = rememberAndSkipMetadata())
4608 assert(DeferredMetadataInfo.empty() &&
"Unexpected deferred metadata");
4609 if (
Error Err = MDLoader->parseModuleMetadata())
4613 if (
Error Err = MDLoader->parseMetadataKinds())
4617 if (
Error Err = ResolveDataLayout())
4622 if (!SeenFirstFunctionBody) {
4623 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
4624 if (
Error Err = globalCleanup())
4626 SeenFirstFunctionBody =
true;
4629 if (VSTOffset > 0) {
4633 if (!SeenValueSymbolTable) {
4634 if (
Error Err = BitcodeReader::parseValueSymbolTable(VSTOffset))
4636 SeenValueSymbolTable =
true;
4648 if (
Error Err = Stream.SkipBlock())
4658 if (
Error Err = rememberAndSkipFunctionBody())
4665 if (SeenValueSymbolTable) {
4666 NextUnreadBit = Stream.GetCurrentBitNo();
4669 return globalCleanup();
4673 if (
Error Err = parseUseLists())
4677 if (
Error Err = parseOperandBundleTags())
4681 if (
Error Err = parseSyncScopeNames())
4693 Expected<unsigned> MaybeBitCode = Stream.readRecord(
Entry.ID, Record);
4696 switch (
unsigned BitCode = MaybeBitCode.
get()) {
4699 Expected<unsigned> VersionOrErr = parseVersionRecord(Record);
4702 UseRelativeIDs = *VersionOrErr >= 1;
4706 if (ResolvedDataLayout)
4707 return error(
"target triple too late in module");
4710 return error(
"Invalid record");
4711 TheModule->setTargetTriple(Triple(std::move(S)));
4715 if (ResolvedDataLayout)
4716 return error(
"datalayout too late in module");
4718 return error(
"Invalid record");
4724 return error(
"Invalid record");
4725 TheModule->setModuleInlineAsm(S);
4732 return error(
"Invalid record");
4739 return error(
"Invalid record");
4740 SectionTable.push_back(S);
4746 return error(
"Invalid record");
4747 GCTable.push_back(S);
4751 if (
Error Err = parseComdatRecord(Record))
4760 if (
Error Err = parseGlobalVarRecord(Record))
4764 if (
Error Err = ResolveDataLayout())
4766 if (
Error Err = parseFunctionRecord(Record))
4772 if (
Error Err = parseGlobalIndirectSymbolRecord(BitCode, Record))
4778 return error(
"Invalid record");
4782 VSTOffset = Record[0] - 1;
4788 return error(
"Invalid record");
4789 TheModule->setSourceFileName(
ValueName);
4794 this->ValueTypeCallback = std::nullopt;
4798Error BitcodeReader::parseBitcodeInto(
Module *M,
bool ShouldLazyLoadMetadata,
4800 ParserCallbacks Callbacks) {
4802 MetadataLoaderCallbacks MDCallbacks;
4803 MDCallbacks.
GetTypeByID = [&](
unsigned ID) {
return getTypeByID(
ID); };
4805 return getContainedTypeID(
I, J);
4808 MDLoader = MetadataLoader(Stream, *M, ValueList, IsImporting, MDCallbacks);
4809 return parseModule(0, ShouldLazyLoadMetadata, Callbacks);
4812Error BitcodeReader::typeCheckLoadStoreInst(
Type *ValType,
Type *PtrType) {
4814 return error(
"Load/Store operand is not a pointer type");
4815 if (!PointerType::isLoadableOrStorableType(ValType))
4816 return error(
"Cannot load/store from pointer");
4820Error BitcodeReader::propagateAttributeTypes(CallBase *CB,
4821 ArrayRef<unsigned> ArgTyIDs) {
4823 for (
unsigned i = 0; i != CB->
arg_size(); ++i) {
4824 for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
4825 Attribute::InAlloca}) {
4826 if (!
Attrs.hasParamAttr(i, Kind) ||
4827 Attrs.getParamAttr(i, Kind).getValueAsType())
4830 Type *PtrEltTy = getPtrElementTypeByID(ArgTyIDs[i]);
4832 return error(
"Missing element type for typed attribute upgrade");
4836 case Attribute::ByVal:
4837 NewAttr = Attribute::getWithByValType(
Context, PtrEltTy);
4839 case Attribute::StructRet:
4840 NewAttr = Attribute::getWithStructRetType(
Context, PtrEltTy);
4842 case Attribute::InAlloca:
4843 NewAttr = Attribute::getWithInAllocaType(
Context, PtrEltTy);
4856 for (
const InlineAsm::ConstraintInfo &CI :
IA->ParseConstraints()) {
4860 if (CI.isIndirect && !
Attrs.getParamElementType(ArgNo)) {
4861 Type *ElemTy = getPtrElementTypeByID(ArgTyIDs[ArgNo]);
4863 return error(
"Missing element type for inline asm upgrade");
4866 Attribute::get(
Context, Attribute::ElementType, ElemTy));
4874 case Intrinsic::preserve_array_access_index:
4875 case Intrinsic::preserve_struct_access_index:
4876 case Intrinsic::aarch64_ldaxr:
4877 case Intrinsic::aarch64_ldxr:
4878 case Intrinsic::aarch64_stlxr:
4879 case Intrinsic::aarch64_stxr:
4880 case Intrinsic::arm_ldaex:
4881 case Intrinsic::arm_ldrex:
4882 case Intrinsic::arm_stlex:
4883 case Intrinsic::arm_strex: {
4886 case Intrinsic::aarch64_stlxr:
4887 case Intrinsic::aarch64_stxr:
4888 case Intrinsic::arm_stlex:
4889 case Intrinsic::arm_strex:
4896 if (!
Attrs.getParamElementType(ArgNo)) {
4897 Type *ElTy = getPtrElementTypeByID(ArgTyIDs[ArgNo]);
4899 return error(
"Missing element type for elementtype upgrade");
4914Error BitcodeReader::parseFunctionBody(Function *
F) {
4919 if (MDLoader->hasFwdRefs())
4920 return error(
"Invalid function metadata: incoming forward references");
4922 InstructionList.
clear();
4923 unsigned ModuleValueListSize = ValueList.
size();
4924 unsigned ModuleMDLoaderSize = MDLoader->size();
4928 unsigned FTyID = FunctionTypeIDs[
F];
4929 for (Argument &
I :
F->args()) {
4930 unsigned ArgTyID = getContainedTypeID(FTyID, ArgNo + 1);
4931 assert(
I.getType() == getTypeByID(ArgTyID) &&
4932 "Incorrect fully specified type for Function Argument");
4936 unsigned NextValueNo = ValueList.
size();
4938 unsigned CurBBNo = 0;
4943 SmallMapVector<std::pair<BasicBlock *, BasicBlock *>,
BasicBlock *, 4>
4947 auto getLastInstruction = [&]() -> Instruction * {
4948 if (CurBB && !CurBB->
empty())
4949 return &CurBB->
back();
4950 else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
4951 !FunctionBBs[CurBBNo - 1]->
empty())
4952 return &FunctionBBs[CurBBNo - 1]->back();
4956 std::vector<OperandBundleDef> OperandBundles;
4959 SmallVector<uint64_t, 64> Record;
4962 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4965 llvm::BitstreamEntry
Entry = MaybeEntry.
get();
4967 switch (
Entry.Kind) {
4969 return error(
"Malformed block");
4971 goto OutOfRecordLoop;
4976 if (
Error Err = Stream.SkipBlock())
4980 if (
Error Err = parseConstants())
4982 NextValueNo = ValueList.
size();
4985 if (
Error Err = parseValueSymbolTable())
4989 if (
Error Err = MDLoader->parseMetadataAttachment(*
F, InstructionList))
4993 assert(DeferredMetadataInfo.empty() &&
4994 "Must read all module-level metadata before function-level");
4995 if (
Error Err = MDLoader->parseFunctionMetadata())
4999 if (
Error Err = parseUseLists())
5013 unsigned ResTypeID = InvalidTypeID;
5014 Expected<unsigned> MaybeBitCode = Stream.readRecord(
Entry.ID, Record);
5017 switch (
unsigned BitCode = MaybeBitCode.
get()) {
5019 return error(
"Invalid value");
5021 if (Record.
empty() || Record[0] == 0)
5022 return error(
"Invalid record");
5024 FunctionBBs.resize(Record[0]);
5027 auto BBFRI = BasicBlockFwdRefs.
find(
F);
5028 if (BBFRI == BasicBlockFwdRefs.
end()) {
5029 for (BasicBlock *&BB : FunctionBBs)
5032 auto &BBRefs = BBFRI->second;
5034 if (BBRefs.size() > FunctionBBs.size())
5035 return error(
"Invalid ID");
5036 assert(!BBRefs.empty() &&
"Unexpected empty array");
5037 assert(!BBRefs.front() &&
"Invalid reference to entry block");
5038 for (
unsigned I = 0,
E = FunctionBBs.size(), RE = BBRefs.size();
I !=
E;
5040 if (
I < RE && BBRefs[
I]) {
5041 BBRefs[
I]->insertInto(
F);
5042 FunctionBBs[
I] = BBRefs[
I];
5048 BasicBlockFwdRefs.
erase(BBFRI);
5051 CurBB = FunctionBBs[0];
5058 return error(
"Invalid record");
5072 for (uint64_t ValID : Record)
5074 BackwardRefFunctions.push_back(
F);
5076 return error(
"Invalid record");
5083 I = getLastInstruction();
5086 return error(
"Invalid record");
5087 I->setDebugLoc(LastLoc);
5092 I = getLastInstruction();
5093 if (!
I || Record.size() < 4)
5094 return error(
"Invalid record");
5096 unsigned Line = Record[0], Col = Record[1];
5097 unsigned ScopeID = Record[2], IAID = Record[3];
5098 bool isImplicitCode = Record.size() >= 5 && Record[4];
5099 uint64_t AtomGroup = Record.size() == 7 ? Record[5] : 0;
5100 uint8_t AtomRank = Record.size() == 7 ? Record[6] : 0;
5102 MDNode *
Scope =
nullptr, *
IA =
nullptr;
5105 MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));
5107 return error(
"Invalid record");
5111 MDLoader->getMetadataFwdRefOrLoad(IAID - 1));
5113 return error(
"Invalid record");
5116 LastLoc = DILocation::get(
Scope->getContext(), Line, Col, Scope, IA,
5117 isImplicitCode, AtomGroup, AtomRank);
5118 I->setDebugLoc(LastLoc);
5126 if (getValueTypePair(Record, OpNum, NextValueNo,
LHS,
TypeID, CurBB) ||
5127 OpNum+1 > Record.size())
5128 return error(
"Invalid record");
5132 return error(
"Invalid record");
5136 if (OpNum < Record.size()) {
5140 I->setFastMathFlags(FMF);
5149 if (getValueTypePair(Record, OpNum, NextValueNo,
LHS,
TypeID, CurBB) ||
5152 OpNum+1 > Record.size())
5153 return error(
"Invalid record");
5157 return error(
"Invalid record");
5161 if (OpNum < Record.size()) {
5162 if (
Opc == Instruction::Add ||
5163 Opc == Instruction::Sub ||
5164 Opc == Instruction::Mul ||
5165 Opc == Instruction::Shl) {
5170 }
else if (
Opc == Instruction::SDiv ||
5171 Opc == Instruction::UDiv ||
5172 Opc == Instruction::LShr ||
5173 Opc == Instruction::AShr) {
5176 }
else if (
Opc == Instruction::Or) {
5182 I->setFastMathFlags(FMF);
5191 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB) ||
5192 OpNum + 1 > Record.size())
5193 return error(
"Invalid record");
5195 ResTypeID = Record[OpNum++];
5196 Type *ResTy = getTypeByID(ResTypeID);
5199 if (
Opc == -1 || !ResTy)
5200 return error(
"Invalid record");
5205 assert(CurBB &&
"No current BB?");
5211 return error(
"Invalid cast");
5215 if (OpNum < Record.size()) {
5216 if (
Opc == Instruction::ZExt ||
Opc == Instruction::UIToFP) {
5219 }
else if (
Opc == Instruction::Trunc) {
5228 I->setFastMathFlags(FMF);
5246 TyID = Record[OpNum++];
5247 Ty = getTypeByID(TyID);
5251 TyID = InvalidTypeID;
5256 unsigned BasePtrTypeID;
5257 if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, BasePtrTypeID,
5259 return error(
"Invalid record");
5262 TyID = getContainedTypeID(BasePtrTypeID);
5263 if (
BasePtr->getType()->isVectorTy())
5264 TyID = getContainedTypeID(TyID);
5265 Ty = getTypeByID(TyID);
5268 SmallVector<Value*, 16> GEPIdx;
5269 while (OpNum != Record.size()) {
5272 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
5273 return error(
"Invalid record");
5284 unsigned SubType = 0;
5285 if (GTI.isStruct()) {
5287 Idx->getType()->isVectorTy()
5289 :
cast<ConstantInt>(Idx);
5292 ResTypeID = getContainedTypeID(ResTypeID, SubType);
5299 ResTypeID = getVirtualTypeID(
I->getType()->getScalarType(), ResTypeID);
5300 if (
I->getType()->isVectorTy())
5301 ResTypeID = getVirtualTypeID(
I->getType(), ResTypeID);
5304 GEP->setNoWrapFlags(NW);
5313 if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))
5314 return error(
"Invalid record");
5317 unsigned RecSize = Record.size();
5318 if (OpNum == RecSize)
5319 return error(
"EXTRACTVAL: Invalid instruction with 0 indices");
5321 SmallVector<unsigned, 4> EXTRACTVALIdx;
5322 ResTypeID = AggTypeID;
5323 for (; OpNum != RecSize; ++OpNum) {
5326 uint64_t
Index = Record[OpNum];
5328 if (!IsStruct && !IsArray)
5329 return error(
"EXTRACTVAL: Invalid type");
5330 if ((
unsigned)Index != Index)
5331 return error(
"Invalid value");
5333 return error(
"EXTRACTVAL: Invalid struct index");
5335 return error(
"EXTRACTVAL: Invalid array index");
5336 EXTRACTVALIdx.
push_back((
unsigned)Index);
5340 ResTypeID = getContainedTypeID(ResTypeID, Index);
5343 ResTypeID = getContainedTypeID(ResTypeID);
5357 if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))
5358 return error(
"Invalid record");
5361 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
5362 return error(
"Invalid record");
5364 unsigned RecSize = Record.size();
5365 if (OpNum == RecSize)
5366 return error(
"INSERTVAL: Invalid instruction with 0 indices");
5368 SmallVector<unsigned, 4> INSERTVALIdx;
5370 for (; OpNum != RecSize; ++OpNum) {
5373 uint64_t
Index = Record[OpNum];
5375 if (!IsStruct && !IsArray)
5376 return error(
"INSERTVAL: Invalid type");
5377 if ((
unsigned)Index != Index)
5378 return error(
"Invalid value");
5380 return error(
"INSERTVAL: Invalid struct index");
5382 return error(
"INSERTVAL: Invalid array index");
5384 INSERTVALIdx.
push_back((
unsigned)Index);
5392 return error(
"Inserted value type doesn't match aggregate type");
5395 ResTypeID = AggTypeID;
5407 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal,
TypeID,
5409 popValue(Record, OpNum, NextValueNo,
TrueVal->getType(),
TypeID,
5411 popValue(Record, OpNum, NextValueNo, CondType,
5412 getVirtualTypeID(CondType),
Cond, CurBB))
5413 return error(
"Invalid record");
5426 unsigned ValTypeID, CondTypeID;
5427 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, ValTypeID,
5429 popValue(Record, OpNum, NextValueNo,
TrueVal->getType(), ValTypeID,
5431 getValueTypePair(Record, OpNum, NextValueNo,
Cond, CondTypeID, CurBB))
5432 return error(
"Invalid record");
5435 if (VectorType* vector_type =
5438 if (vector_type->getElementType() != Type::getInt1Ty(
Context))
5439 return error(
"Invalid type for value");
5443 return error(
"Invalid type for value");
5447 ResTypeID = ValTypeID;
5452 I->setFastMathFlags(FMF);
5460 unsigned VecTypeID, IdxTypeID;
5461 if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB) ||
5462 getValueTypePair(Record, OpNum, NextValueNo, Idx, IdxTypeID, CurBB))
5463 return error(
"Invalid record");
5465 return error(
"Invalid type for value");
5467 ResTypeID = getContainedTypeID(VecTypeID);
5474 Value *Vec, *Elt, *Idx;
5475 unsigned VecTypeID, IdxTypeID;
5476 if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB))
5477 return error(
"Invalid record");
5479 return error(
"Invalid type for value");
5480 if (popValue(Record, OpNum, NextValueNo,
5482 getContainedTypeID(VecTypeID), Elt, CurBB) ||
5483 getValueTypePair(Record, OpNum, NextValueNo, Idx, IdxTypeID, CurBB))
5484 return error(
"Invalid record");
5486 ResTypeID = VecTypeID;
5494 unsigned Vec1TypeID;
5495 if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, Vec1TypeID,
5497 popValue(Record, OpNum, NextValueNo, Vec1->
getType(), Vec1TypeID,
5499 return error(
"Invalid record");
5501 unsigned MaskTypeID;
5502 if (getValueTypePair(Record, OpNum, NextValueNo, Mask, MaskTypeID, CurBB))
5503 return error(
"Invalid record");
5505 return error(
"Invalid type for value");
5507 I =
new ShuffleVectorInst(Vec1, Vec2, Mask);
5509 getVirtualTypeID(
I->getType(), getContainedTypeID(Vec1TypeID));
5524 if (getValueTypePair(Record, OpNum, NextValueNo,
LHS, LHSTypeID, CurBB) ||
5525 popValue(Record, OpNum, NextValueNo,
LHS->
getType(), LHSTypeID,
RHS,
5527 return error(
"Invalid record");
5529 if (OpNum >= Record.size())
5531 "Invalid record: operand number exceeded available operands");
5536 if (IsFP && Record.size() > OpNum+1)
5541 return error(
"Invalid fcmp predicate");
5542 I =
new FCmpInst(PredVal,
LHS,
RHS);
5545 return error(
"Invalid icmp predicate");
5546 I =
new ICmpInst(PredVal,
LHS,
RHS);
5547 if (Record.size() > OpNum + 1 &&
5552 if (OpNum + 1 != Record.size())
5553 return error(
"Invalid record");
5555 ResTypeID = getVirtualTypeID(
I->getType()->getScalarType());
5557 ResTypeID = getVirtualTypeID(
I->getType(), ResTypeID);
5560 I->setFastMathFlags(FMF);
5567 unsigned Size = Record.size();
5577 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
5578 return error(
"Invalid record");
5579 if (OpNum != Record.size())
5580 return error(
"Invalid record");
5587 if (Record.size() != 1 && Record.size() != 3)
5588 return error(
"Invalid record");
5589 BasicBlock *TrueDest = getBasicBlock(Record[0]);
5591 return error(
"Invalid record");
5593 if (Record.size() == 1) {
5598 BasicBlock *FalseDest = getBasicBlock(Record[1]);
5600 Value *
Cond = getValue(Record, 2, NextValueNo, CondType,
5601 getVirtualTypeID(CondType), CurBB);
5602 if (!FalseDest || !
Cond)
5603 return error(
"Invalid record");
5610 if (Record.size() != 1 && Record.size() != 2)
5611 return error(
"Invalid record");
5614 Value *CleanupPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5615 getVirtualTypeID(TokenTy), CurBB);
5617 return error(
"Invalid record");
5619 if (Record.size() == 2) {
5620 UnwindDest = getBasicBlock(Record[Idx++]);
5622 return error(
"Invalid record");
5630 if (Record.size() != 2)
5631 return error(
"Invalid record");
5634 Value *CatchPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5635 getVirtualTypeID(TokenTy), CurBB);
5637 return error(
"Invalid record");
5638 BasicBlock *BB = getBasicBlock(Record[Idx++]);
5640 return error(
"Invalid record");
5648 if (Record.size() < 2)
5649 return error(
"Invalid record");
5654 Value *ParentPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5655 getVirtualTypeID(TokenTy), CurBB);
5657 return error(
"Invalid record");
5659 unsigned NumHandlers = Record[Idx++];
5662 for (
unsigned Op = 0;
Op != NumHandlers; ++
Op) {
5663 BasicBlock *BB = getBasicBlock(Record[Idx++]);
5665 return error(
"Invalid record");
5670 if (Idx + 1 == Record.size()) {
5671 UnwindDest = getBasicBlock(Record[Idx++]);
5673 return error(
"Invalid record");
5676 if (Record.size() != Idx)
5677 return error(
"Invalid record");
5681 for (BasicBlock *Handler : Handlers)
5682 CatchSwitch->addHandler(Handler);
5684 ResTypeID = getVirtualTypeID(
I->getType());
5691 if (Record.size() < 2)
5692 return error(
"Invalid record");
5697 Value *ParentPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5698 getVirtualTypeID(TokenTy), CurBB);
5700 return error(
"Invald record");
5702 unsigned NumArgOperands = Record[Idx++];
5704 SmallVector<Value *, 2>
Args;
5705 for (
unsigned Op = 0;
Op != NumArgOperands; ++
Op) {
5708 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID,
nullptr))
5709 return error(
"Invalid record");
5710 Args.push_back(Val);
5713 if (Record.size() != Idx)
5714 return error(
"Invalid record");
5720 ResTypeID = getVirtualTypeID(
I->getType());
5726 if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
5732 unsigned OpTyID = Record[1];
5733 Type *OpTy = getTypeByID(OpTyID);
5736 Value *
Cond = getValue(Record, 2, NextValueNo, OpTy, OpTyID, CurBB);
5739 return error(
"Invalid record");
5741 unsigned NumCases = Record[4];
5746 unsigned CurIdx = 5;
5747 for (
unsigned i = 0; i != NumCases; ++i) {
5749 unsigned NumItems = Record[CurIdx++];
5750 for (
unsigned ci = 0; ci != NumItems; ++ci) {
5751 bool isSingleNumber = Record[CurIdx++];
5754 unsigned ActiveWords = 1;
5755 if (ValueBitWidth > 64)
5756 ActiveWords = Record[CurIdx++];
5759 CurIdx += ActiveWords;
5761 if (!isSingleNumber) {
5763 if (ValueBitWidth > 64)
5764 ActiveWords = Record[CurIdx++];
5767 CurIdx += ActiveWords;
5778 BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
5779 for (ConstantInt *Cst : CaseVals)
5780 SI->addCase(Cst, DestBB);
5788 if (Record.size() < 3 || (Record.size() & 1) == 0)
5789 return error(
"Invalid record");
5790 unsigned OpTyID = Record[0];
5791 Type *OpTy = getTypeByID(OpTyID);
5792 Value *
Cond = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
5795 return error(
"Invalid record");
5796 unsigned NumCases = (Record.size()-3)/2;
5799 for (
unsigned i = 0, e = NumCases; i !=
e; ++i) {
5801 getFnValueByID(Record[3+i*2], OpTy, OpTyID,
nullptr));
5802 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
5803 if (!CaseVal || !DestBB) {
5805 return error(
"Invalid record");
5807 SI->addCase(CaseVal, DestBB);
5813 if (Record.size() < 2)
5814 return error(
"Invalid record");
5815 unsigned OpTyID = Record[0];
5816 Type *OpTy = getTypeByID(OpTyID);
5817 Value *
Address = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
5819 return error(
"Invalid record");
5820 unsigned NumDests = Record.size()-2;
5823 for (
unsigned i = 0, e = NumDests; i !=
e; ++i) {
5824 if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
5828 return error(
"Invalid record");
5837 if (Record.size() < 4)
5838 return error(
"Invalid record");
5841 unsigned CCInfo = Record[OpNum++];
5842 BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
5843 BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
5845 unsigned FTyID = InvalidTypeID;
5846 FunctionType *FTy =
nullptr;
5847 if ((CCInfo >> 13) & 1) {
5848 FTyID = Record[OpNum++];
5851 return error(
"Explicit invoke type is not a function type");
5855 unsigned CalleeTypeID;
5856 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
5858 return error(
"Invalid record");
5862 return error(
"Callee is not a pointer");
5864 FTyID = getContainedTypeID(CalleeTypeID);
5867 return error(
"Callee is not of pointer to function type");
5869 if (Record.size() < FTy->getNumParams() + OpNum)
5870 return error(
"Insufficient operands to call");
5872 SmallVector<Value*, 16>
Ops;
5873 SmallVector<unsigned, 16> ArgTyIDs;
5874 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
5875 unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);
5876 Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),
5880 return error(
"Invalid record");
5883 if (!FTy->isVarArg()) {
5884 if (Record.size() != OpNum)
5885 return error(
"Invalid record");
5888 while (OpNum != Record.size()) {
5891 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
5892 return error(
"Invalid record");
5899 if (!OperandBundles.empty())
5904 ResTypeID = getContainedTypeID(FTyID);
5905 OperandBundles.clear();
5908 static_cast<CallingConv::ID
>(CallingConv::MaxID & CCInfo));
5919 Value *Val =
nullptr;
5921 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID, CurBB))
5922 return error(
"Invalid record");
5931 unsigned CCInfo = Record[OpNum++];
5933 BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);
5934 unsigned NumIndirectDests = Record[OpNum++];
5935 SmallVector<BasicBlock *, 16> IndirectDests;
5936 for (
unsigned i = 0, e = NumIndirectDests; i !=
e; ++i)
5937 IndirectDests.
push_back(getBasicBlock(Record[OpNum++]));
5939 unsigned FTyID = InvalidTypeID;
5940 FunctionType *FTy =
nullptr;
5942 FTyID = Record[OpNum++];
5945 return error(
"Explicit call type is not a function type");
5949 unsigned CalleeTypeID;
5950 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
5952 return error(
"Invalid record");
5956 return error(
"Callee is not a pointer type");
5958 FTyID = getContainedTypeID(CalleeTypeID);
5961 return error(
"Callee is not of pointer to function type");
5963 if (Record.size() < FTy->getNumParams() + OpNum)
5964 return error(
"Insufficient operands to call");
5966 SmallVector<Value*, 16>
Args;
5967 SmallVector<unsigned, 16> ArgTyIDs;
5969 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
5971 unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);
5972 if (FTy->getParamType(i)->isLabelTy())
5973 Arg = getBasicBlock(Record[OpNum]);
5975 Arg = getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),
5978 return error(
"Invalid record");
5979 Args.push_back(Arg);
5984 if (!FTy->isVarArg()) {
5985 if (OpNum != Record.size())
5986 return error(
"Invalid record");
5988 while (OpNum != Record.size()) {
5991 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
5992 return error(
"Invalid record");
5999 if (!OperandBundles.empty())
6004 auto IsLabelConstraint = [](
const InlineAsm::ConstraintInfo &CI) {
6007 if (
none_of(ConstraintInfo, IsLabelConstraint)) {
6012 unsigned FirstBlockArg =
Args.size() - IndirectDests.
size();
6013 for (
unsigned ArgNo = FirstBlockArg; ArgNo <
Args.size(); ++ArgNo) {
6014 unsigned LabelNo = ArgNo - FirstBlockArg;
6016 if (!BA || BA->getFunction() !=
F ||
6017 LabelNo > IndirectDests.
size() ||
6018 BA->getBasicBlock() != IndirectDests[LabelNo])
6019 return error(
"callbr argument does not match indirect dest");
6024 ArgTyIDs.
erase(ArgTyIDs.
begin() + FirstBlockArg, ArgTyIDs.
end());
6028 for (
Value *Arg : Args)
6031 FunctionType::get(FTy->getReturnType(), ArgTys, FTy->isVarArg());
6034 std::string Constraints =
IA->getConstraintString().str();
6037 for (
const auto &CI : ConstraintInfo) {
6039 if (ArgNo >= FirstBlockArg)
6040 Constraints.insert(Pos,
"!");
6045 Pos = Constraints.find(
',', Pos);
6046 if (Pos == std::string::npos)
6052 IA->hasSideEffects(),
IA->isAlignStack(),
6053 IA->getDialect(),
IA->canThrow());
6059 ResTypeID = getContainedTypeID(FTyID);
6060 OperandBundles.clear();
6077 return error(
"Invalid phi record");
6079 unsigned TyID = Record[0];
6080 Type *Ty = getTypeByID(TyID);
6082 return error(
"Invalid phi record");
6087 size_t NumArgs = (Record.size() - 1) / 2;
6091 return error(
"Invalid phi record");
6095 SmallDenseMap<BasicBlock *, Value *>
Args;
6096 for (
unsigned i = 0; i != NumArgs; i++) {
6097 BasicBlock *BB = getBasicBlock(Record[i * 2 + 2]);
6100 return error(
"Invalid phi BB");
6107 auto It =
Args.find(BB);
6109 if (It !=
Args.end()) {
6123 if (!PhiConstExprBB)
6125 EdgeBB = PhiConstExprBB;
6133 V = getValueSigned(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);
6135 V = getValue(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);
6139 return error(
"Invalid phi record");
6142 if (EdgeBB == PhiConstExprBB && !EdgeBB->
empty()) {
6143 ConstExprEdgeBBs.
insert({{BB, CurBB}, EdgeBB});
6144 PhiConstExprBB =
nullptr;
6147 Args.insert({BB,
V});
6153 if (Record.size() % 2 == 0) {
6157 I->setFastMathFlags(FMF);
6168 if (Record.size() < 3)
6169 return error(
"Invalid record");
6172 if (Record.size() < 4)
6173 return error(
"Invalid record");
6175 ResTypeID = Record[Idx++];
6176 Type *Ty = getTypeByID(ResTypeID);
6178 return error(
"Invalid record");
6180 Value *PersFn =
nullptr;
6181 unsigned PersFnTypeID;
6182 if (getValueTypePair(Record, Idx, NextValueNo, PersFn, PersFnTypeID,
6184 return error(
"Invalid record");
6186 if (!
F->hasPersonalityFn())
6189 return error(
"Personality function mismatch");
6192 bool IsCleanup = !!Record[Idx++];
6193 unsigned NumClauses = Record[Idx++];
6196 for (
unsigned J = 0; J != NumClauses; ++J) {
6202 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID,
6205 return error(
"Invalid record");
6210 "Catch clause has a invalid type!");
6213 "Filter clause has invalid type!");
6223 if (Record.size() != 4 && Record.size() != 5)
6224 return error(
"Invalid record");
6225 using APV = AllocaPackedValues;
6226 const uint64_t Rec = Record[3];
6229 unsigned TyID = Record[0];
6230 Type *Ty = getTypeByID(TyID);
6232 TyID = getContainedTypeID(TyID);
6233 Ty = getTypeByID(TyID);
6235 return error(
"Missing element type for old-style alloca");
6237 unsigned OpTyID = Record[1];
6238 Type *OpTy = getTypeByID(OpTyID);
6239 Value *
Size = getFnValueByID(Record[2], OpTy, OpTyID, CurBB);
6244 if (
Error Err = parseAlignmentValue(AlignExp, Align)) {
6248 return error(
"Invalid record");
6250 const DataLayout &
DL = TheModule->getDataLayout();
6251 unsigned AS = Record.
size() == 5 ? Record[4] :
DL.getAllocaAddrSpace();
6253 SmallPtrSet<Type *, 4> Visited;
6254 if (!Align && !Ty->
isSized(&Visited))
6255 return error(
"alloca of unsized type");
6257 Align =
DL.getPrefTypeAlign(Ty);
6259 if (!
Size->getType()->isIntegerTy())
6260 return error(
"alloca element count must have integer type");
6262 AllocaInst *AI =
new AllocaInst(Ty, AS,
Size, *Align);
6266 ResTypeID = getVirtualTypeID(AI->
getType(), TyID);
6274 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB) ||
6275 (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
6276 return error(
"Invalid record");
6279 return error(
"Load operand is not a pointer type");
6282 if (OpNum + 3 == Record.size()) {
6283 ResTypeID = Record[OpNum++];
6284 Ty = getTypeByID(ResTypeID);
6286 ResTypeID = getContainedTypeID(OpTypeID);
6287 Ty = getTypeByID(ResTypeID);
6291 return error(
"Missing load type");
6293 if (
Error Err = typeCheckLoadStoreInst(Ty,
Op->getType()))
6297 if (
Error Err = parseAlignmentValue(Record[OpNum], Align))
6299 SmallPtrSet<Type *, 4> Visited;
6300 if (!Align && !Ty->
isSized(&Visited))
6301 return error(
"load of unsized type");
6303 Align = TheModule->getDataLayout().getABITypeAlign(Ty);
6304 I =
new LoadInst(Ty,
Op,
"", Record[OpNum + 1], *Align);
6313 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB) ||
6314 (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
6315 return error(
"Invalid record");
6318 return error(
"Load operand is not a pointer type");
6321 if (OpNum + 5 == Record.size()) {
6322 ResTypeID = Record[OpNum++];
6323 Ty = getTypeByID(ResTypeID);
6325 ResTypeID = getContainedTypeID(OpTypeID);
6326 Ty = getTypeByID(ResTypeID);
6330 return error(
"Missing atomic load type");
6332 if (
Error Err = typeCheckLoadStoreInst(Ty,
Op->getType()))
6336 if (Ordering == AtomicOrdering::NotAtomic ||
6337 Ordering == AtomicOrdering::Release ||
6338 Ordering == AtomicOrdering::AcquireRelease)
6339 return error(
"Invalid record");
6340 if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
6341 return error(
"Invalid record");
6342 SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6345 if (
Error Err = parseAlignmentValue(Record[OpNum], Align))
6348 return error(
"Alignment missing from atomic load");
6349 I =
new LoadInst(Ty,
Op,
"", Record[OpNum + 1], *Align, Ordering, SSID);
6357 unsigned PtrTypeID, ValTypeID;
6358 if (getValueTypePair(Record, OpNum, NextValueNo,
Ptr, PtrTypeID, CurBB))
6359 return error(
"Invalid record");
6362 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6363 return error(
"Invalid record");
6365 ValTypeID = getContainedTypeID(PtrTypeID);
6366 if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),
6367 ValTypeID, Val, CurBB))
6368 return error(
"Invalid record");
6371 if (OpNum + 2 != Record.size())
6372 return error(
"Invalid record");
6374 if (
Error Err = typeCheckLoadStoreInst(Val->
getType(),
Ptr->getType()))
6377 if (
Error Err = parseAlignmentValue(Record[OpNum], Align))
6379 SmallPtrSet<Type *, 4> Visited;
6381 return error(
"store of unsized type");
6383 Align = TheModule->getDataLayout().getABITypeAlign(Val->
getType());
6384 I =
new StoreInst(Val,
Ptr, Record[OpNum + 1], *Align);
6393 unsigned PtrTypeID, ValTypeID;
6394 if (getValueTypePair(Record, OpNum, NextValueNo,
Ptr, PtrTypeID, CurBB) ||
6396 return error(
"Invalid record");
6398 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6399 return error(
"Invalid record");
6401 ValTypeID = getContainedTypeID(PtrTypeID);
6402 if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),
6403 ValTypeID, Val, CurBB))
6404 return error(
"Invalid record");
6407 if (OpNum + 4 != Record.size())
6408 return error(
"Invalid record");
6410 if (
Error Err = typeCheckLoadStoreInst(Val->
getType(),
Ptr->getType()))
6413 if (Ordering == AtomicOrdering::NotAtomic ||
6414 Ordering == AtomicOrdering::Acquire ||
6415 Ordering == AtomicOrdering::AcquireRelease)
6416 return error(
"Invalid record");
6417 SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6418 if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
6419 return error(
"Invalid record");
6422 if (
Error Err = parseAlignmentValue(Record[OpNum], Align))
6425 return error(
"Alignment missing from atomic store");
6426 I =
new StoreInst(Val,
Ptr, Record[OpNum + 1], *Align, Ordering, SSID);
6433 const size_t NumRecords = Record.size();
6437 if (getValueTypePair(Record, OpNum, NextValueNo,
Ptr, PtrTypeID, CurBB))
6438 return error(
"Invalid record");
6441 return error(
"Cmpxchg operand is not a pointer type");
6444 unsigned CmpTypeID = getContainedTypeID(PtrTypeID);
6445 if (popValue(Record, OpNum, NextValueNo, getTypeByID(CmpTypeID),
6446 CmpTypeID, Cmp, CurBB))
6447 return error(
"Invalid record");
6450 if (popValue(Record, OpNum, NextValueNo,
Cmp->getType(), CmpTypeID,
6452 NumRecords < OpNum + 3 || NumRecords > OpNum + 5)
6453 return error(
"Invalid record");
6457 if (SuccessOrdering == AtomicOrdering::NotAtomic ||
6458 SuccessOrdering == AtomicOrdering::Unordered)
6459 return error(
"Invalid record");
6461 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
6463 if (
Error Err = typeCheckLoadStoreInst(
Cmp->getType(),
Ptr->getType()))
6471 if (FailureOrdering == AtomicOrdering::NotAtomic ||
6472 FailureOrdering == AtomicOrdering::Unordered)
6473 return error(
"Invalid record");
6475 const Align Alignment(
6476 TheModule->getDataLayout().getTypeStoreSize(
Cmp->getType()));
6478 I =
new AtomicCmpXchgInst(
Ptr, Cmp, New, Alignment, SuccessOrdering,
6479 FailureOrdering, SSID);
6482 if (NumRecords < 8) {
6486 I->insertInto(CurBB, CurBB->
end());
6488 ResTypeID = CmpTypeID;
6491 unsigned I1TypeID = getVirtualTypeID(Type::getInt1Ty(
Context));
6492 ResTypeID = getVirtualTypeID(
I->getType(), {CmpTypeID, I1TypeID});
6501 const size_t NumRecords = Record.size();
6505 if (getValueTypePair(Record, OpNum, NextValueNo,
Ptr, PtrTypeID, CurBB))
6506 return error(
"Invalid record");
6509 return error(
"Cmpxchg operand is not a pointer type");
6513 if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, CmpTypeID, CurBB))
6514 return error(
"Invalid record");
6516 Value *Val =
nullptr;
6517 if (popValue(Record, OpNum, NextValueNo,
Cmp->getType(), CmpTypeID, Val,
6519 return error(
"Invalid record");
6521 if (NumRecords < OpNum + 3 || NumRecords > OpNum + 6)
6522 return error(
"Invalid record");
6524 const bool IsVol = Record[OpNum];
6529 return error(
"Invalid cmpxchg success ordering");
6531 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
6533 if (
Error Err = typeCheckLoadStoreInst(
Cmp->getType(),
Ptr->getType()))
6539 return error(
"Invalid cmpxchg failure ordering");
6541 const bool IsWeak = Record[OpNum + 4];
6543 MaybeAlign Alignment;
6545 if (NumRecords == (OpNum + 6)) {
6546 if (
Error Err = parseAlignmentValue(Record[OpNum + 5], Alignment))
6551 Align(TheModule->getDataLayout().getTypeStoreSize(
Cmp->getType()));
6553 I =
new AtomicCmpXchgInst(
Ptr, Cmp, Val, *Alignment, SuccessOrdering,
6554 FailureOrdering, SSID);
6558 unsigned I1TypeID = getVirtualTypeID(Type::getInt1Ty(
Context));
6559 ResTypeID = getVirtualTypeID(
I->getType(), {CmpTypeID, I1TypeID});
6568 const size_t NumRecords = Record.size();
6573 if (getValueTypePair(Record, OpNum, NextValueNo,
Ptr, PtrTypeID, CurBB))
6574 return error(
"Invalid record");
6577 return error(
"Invalid record");
6579 Value *Val =
nullptr;
6580 unsigned ValTypeID = InvalidTypeID;
6582 ValTypeID = getContainedTypeID(PtrTypeID);
6583 if (popValue(Record, OpNum, NextValueNo,
6584 getTypeByID(ValTypeID), ValTypeID, Val, CurBB))
6585 return error(
"Invalid record");
6587 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6588 return error(
"Invalid record");
6591 if (!(NumRecords == (OpNum + 4) || NumRecords == (OpNum + 5)))
6592 return error(
"Invalid record");
6598 return error(
"Invalid record");
6600 const bool IsVol = Record[OpNum + 1];
6603 if (Ordering == AtomicOrdering::NotAtomic ||
6604 Ordering == AtomicOrdering::Unordered)
6605 return error(
"Invalid record");
6607 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6609 MaybeAlign Alignment;
6611 if (NumRecords == (OpNum + 5)) {
6612 if (
Error Err = parseAlignmentValue(Record[OpNum + 4], Alignment))
6618 Align(TheModule->getDataLayout().getTypeStoreSize(Val->
getType()));
6620 I =
new AtomicRMWInst(
Operation,
Ptr, Val, *Alignment, Ordering, SSID);
6621 ResTypeID = ValTypeID;
6628 if (2 != Record.size())
6629 return error(
"Invalid record");
6631 if (Ordering == AtomicOrdering::NotAtomic ||
6632 Ordering == AtomicOrdering::Unordered ||
6633 Ordering == AtomicOrdering::Monotonic)
6634 return error(
"Invalid record");
6636 I =
new FenceInst(
Context, Ordering, SSID);
6643 SeenDebugRecord =
true;
6646 return error(
"Invalid dbg record: missing instruction");
6649 Inst->
getParent()->insertDbgRecordBefore(
6659 SeenDebugRecord =
true;
6662 return error(
"Invalid dbg record: missing instruction");
6677 DILocalVariable *Var =
6679 DIExpression *Expr =
6692 unsigned SlotBefore =
Slot;
6693 if (getValueTypePair(Record, Slot, NextValueNo, V, TyID, CurBB))
6694 return error(
"Invalid dbg record: invalid value");
6696 assert((SlotBefore == Slot - 1) &&
"unexpected fwd ref");
6699 RawLocation = getFnMetadataByID(Record[Slot++]);
6702 DbgVariableRecord *DVR =
nullptr;
6706 DVR =
new DbgVariableRecord(RawLocation, Var, Expr, DIL,
6707 DbgVariableRecord::LocationType::Value);
6710 DVR =
new DbgVariableRecord(RawLocation, Var, Expr, DIL,
6711 DbgVariableRecord::LocationType::Declare);
6715 DIExpression *AddrExpr =
6717 Metadata *Addr = getFnMetadataByID(Record[Slot++]);
6718 DVR =
new DbgVariableRecord(RawLocation, Var, Expr,
ID, Addr, AddrExpr,
6730 if (Record.size() < 3)
6731 return error(
"Invalid record");
6735 unsigned CCInfo = Record[OpNum++];
6741 return error(
"Fast math flags indicator set for call with no FMF");
6744 unsigned FTyID = InvalidTypeID;
6745 FunctionType *FTy =
nullptr;
6747 FTyID = Record[OpNum++];
6750 return error(
"Explicit call type is not a function type");
6754 unsigned CalleeTypeID;
6755 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
6757 return error(
"Invalid record");
6761 return error(
"Callee is not a pointer type");
6763 FTyID = getContainedTypeID(CalleeTypeID);
6766 return error(
"Callee is not of pointer to function type");
6768 if (Record.size() < FTy->getNumParams() + OpNum)
6769 return error(
"Insufficient operands to call");
6771 SmallVector<Value*, 16>
Args;
6772 SmallVector<unsigned, 16> ArgTyIDs;
6774 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
6775 unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);
6776 if (FTy->getParamType(i)->isLabelTy())
6777 Args.push_back(getBasicBlock(Record[OpNum]));
6779 Args.push_back(getValue(Record, OpNum, NextValueNo,
6780 FTy->getParamType(i), ArgTyID, CurBB));
6783 return error(
"Invalid record");
6787 if (!FTy->isVarArg()) {
6788 if (OpNum != Record.size())
6789 return error(
"Invalid record");
6791 while (OpNum != Record.size()) {
6794 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
6795 return error(
"Invalid record");
6802 if (!OperandBundles.empty())
6806 ResTypeID = getContainedTypeID(FTyID);
6807 OperandBundles.clear();
6821 SeenDebugIntrinsic =
true;
6828 return error(
"Fast-math-flags specified for call without "
6829 "floating-point scalar or vector return type");
6830 I->setFastMathFlags(FMF);
6835 if (Record.size() < 3)
6836 return error(
"Invalid record");
6837 unsigned OpTyID = Record[0];
6838 Type *OpTy = getTypeByID(OpTyID);
6839 Value *
Op = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
6840 ResTypeID = Record[2];
6841 Type *ResTy = getTypeByID(ResTypeID);
6842 if (!OpTy || !
Op || !ResTy)
6843 return error(
"Invalid record");
6844 I =
new VAArgInst(
Op, ResTy);
6854 if (Record.empty() || Record[0] >= BundleTags.size())
6855 return error(
"Invalid record");
6857 std::vector<Value *> Inputs;
6860 while (OpNum != Record.size()) {
6862 if (getValueOrMetadata(Record, OpNum, NextValueNo,
Op, CurBB))
6863 return error(
"Invalid record");
6864 Inputs.push_back(
Op);
6867 OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
6875 if (getValueTypePair(Record, OpNum, NextValueNo,
Op, OpTypeID, CurBB))
6876 return error(
"Invalid record");
6877 if (OpNum != Record.size())
6878 return error(
"Invalid record");
6880 I =
new FreezeInst(
Op);
6881 ResTypeID = OpTypeID;
6891 return error(
"Invalid instruction with no BB");
6893 if (!OperandBundles.empty()) {
6895 return error(
"Operand bundles found with no consumer");
6897 I->insertInto(CurBB, CurBB->
end());
6900 if (
I->isTerminator()) {
6902 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] :
nullptr;
6906 if (!
I->getType()->isVoidTy()) {
6907 assert(
I->getType() == getTypeByID(ResTypeID) &&
6908 "Incorrect result type ID");
6916 if (!OperandBundles.empty())
6917 return error(
"Operand bundles found with no consumer");
6921 if (!
A->getParent()) {
6923 for (
unsigned i = ModuleValueListSize, e = ValueList.
size(); i != e; ++i){
6929 return error(
"Never resolved value found in function");
6934 if (MDLoader->hasFwdRefs())
6935 return error(
"Invalid function metadata: outgoing forward refs");
6940 for (
const auto &Pair : ConstExprEdgeBBs) {
6951 ValueList.
shrinkTo(ModuleValueListSize);
6952 MDLoader->shrinkTo(ModuleMDLoaderSize);
6953 std::vector<BasicBlock*>().swap(FunctionBBs);
6958Error BitcodeReader::findFunctionInStream(
6960 DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
6961 while (DeferredFunctionInfoIterator->second == 0) {
6966 assert(VSTOffset == 0 || !
F->hasName());
6969 if (
Error Err = rememberAndSkipFunctionBodies())
6975SyncScope::ID BitcodeReader::getDecodedSyncScopeID(
unsigned Val) {
6978 if (Val >= SSIDs.
size())
6987Error BitcodeReader::materialize(GlobalValue *GV) {
6990 if (!
F || !
F->isMaterializable())
6993 DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.
find(
F);
6994 assert(DFII != DeferredFunctionInfo.
end() &&
"Deferred function not found!");
6997 if (DFII->second == 0)
6998 if (
Error Err = findFunctionInStream(
F, DFII))
7002 if (
Error Err = materializeMetadata())
7006 if (
Error JumpFailed = Stream.JumpToBit(DFII->second))
7009 if (
Error Err = parseFunctionBody(
F))
7011 F->setIsMaterializable(
false);
7015 if (SeenDebugIntrinsic && SeenDebugRecord)
7016 return error(
"Mixed debug intrinsics and debug records in bitcode module!");
7022 if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(
F))
7023 F->setSubprogram(SP);
7026 if (!MDLoader->isStrippingTBAA()) {
7028 MDNode *TBAA =
I.getMetadata(LLVMContext::MD_tbaa);
7031 MDLoader->setStripTBAA(
true);
7038 if (
auto *MD =
I.getMetadata(LLVMContext::MD_prof)) {
7039 if (MD->getOperand(0) !=
nullptr &&
isa<MDString>(MD->getOperand(0))) {
7045 unsigned ExpectedNumOperands = 0;
7047 ExpectedNumOperands = BI->getNumSuccessors();
7049 ExpectedNumOperands =
SI->getNumSuccessors();
7051 ExpectedNumOperands = 1;
7055 ExpectedNumOperands = 2;
7062 if (MD->getNumOperands() !=
Offset + ExpectedNumOperands)
7063 I.setMetadata(LLVMContext::MD_prof,
nullptr);
7069 CI->removeRetAttrs(AttributeFuncs::typeIncompatible(
7070 CI->getFunctionType()->getReturnType(), CI->getRetAttributes()));
7072 for (
unsigned ArgNo = 0; ArgNo < CI->arg_size(); ++ArgNo)
7073 CI->removeParamAttrs(ArgNo, AttributeFuncs::typeIncompatible(
7074 CI->getArgOperand(ArgNo)->getType(),
7075 CI->getParamAttributes(ArgNo)));
7078 if (Function *OldFn = CI->getCalledFunction()) {
7079 auto It = UpgradedIntrinsics.find(OldFn);
7080 if (It != UpgradedIntrinsics.end())
7091 return materializeForwardReferencedFunctions();
7094Error BitcodeReader::materializeModule() {
7095 if (
Error Err = materializeMetadata())
7099 WillMaterializeAllForwardRefs =
true;
7103 for (Function &
F : *TheModule) {
7104 if (
Error Err = materialize(&
F))
7110 if (LastFunctionBlockBit || NextUnreadBit)
7112 ? LastFunctionBlockBit
7118 if (!BasicBlockFwdRefs.
empty())
7119 return error(
"Never resolved function from blockaddress");
7125 for (
auto &
I : UpgradedIntrinsics) {
7126 for (
auto *U :
I.first->users()) {
7130 if (
I.first !=
I.second) {
7131 if (!
I.first->use_empty())
7132 I.first->replaceAllUsesWith(
I.second);
7133 I.first->eraseFromParent();
7136 UpgradedIntrinsics.clear();
7149std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes()
const {
7150 return IdentifiedStructTypes;
7153ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
7154 BitstreamCursor Cursor, StringRef Strtab, ModuleSummaryIndex &TheIndex,
7156 : BitcodeReaderBase(std::
move(Cursor), Strtab), TheIndex(TheIndex),
7157 ModulePath(ModulePath), IsPrevailing(IsPrevailing) {}
7159void ModuleSummaryIndexBitcodeReader::addThisModule() {
7164ModuleSummaryIndexBitcodeReader::getThisModule() {
7168template <
bool AllowNullValueInfo>
7169std::pair<ValueInfo, GlobalValue::GUID>
7170ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(
unsigned ValueId) {
7171 auto VGI = ValueIdToValueInfoMap[ValueId];
7176 assert(AllowNullValueInfo || std::get<0>(VGI));
7180void ModuleSummaryIndexBitcodeReader::setValueGUID(
7182 StringRef SourceFileName) {
7183 std::string GlobalId =
7186 auto OriginalNameID = ValueGUID;
7190 dbgs() <<
"GUID " << ValueGUID <<
"(" << OriginalNameID <<
") is "
7196 ValueIdToValueInfoMap[ValueID] = std::make_pair(
7205Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(
7207 DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {
7214 if (!MaybeCurrentBit)
7216 uint64_t CurrentBit = MaybeCurrentBit.
get();
7221 SmallVector<uint64_t, 64> Record;
7227 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
7230 BitstreamEntry
Entry = MaybeEntry.
get();
7232 switch (
Entry.Kind) {
7235 return error(
"Malformed block");
7238 if (
Error JumpFailed = Stream.JumpToBit(CurrentBit))
7248 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
7251 switch (MaybeRecord.
get()) {
7256 return error(
"Invalid record");
7257 unsigned ValueID = Record[0];
7259 auto VLI = ValueIdToLinkageMap.
find(ValueID);
7260 assert(VLI != ValueIdToLinkageMap.
end() &&
7261 "No linkage found for VST entry?");
7270 return error(
"Invalid record");
7271 unsigned ValueID = Record[0];
7273 auto VLI = ValueIdToLinkageMap.
find(ValueID);
7274 assert(VLI != ValueIdToLinkageMap.
end() &&
7275 "No linkage found for VST entry?");
7283 unsigned ValueID = Record[0];
7287 ValueIdToValueInfoMap[ValueID] =
7298Error ModuleSummaryIndexBitcodeReader::parseModule() {
7302 SmallVector<uint64_t, 64> Record;
7303 DenseMap<unsigned, GlobalValue::LinkageTypes> ValueIdToLinkageMap;
7304 unsigned ValueId = 0;
7308 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
7311 llvm::BitstreamEntry
Entry = MaybeEntry.
get();
7313 switch (
Entry.Kind) {
7315 return error(
"Malformed block");
7322 if (
Error Err = Stream.SkipBlock())
7327 if (
Error Err = readBlockInfo())
7333 assert(((SeenValueSymbolTable && VSTOffset > 0) ||
7334 !SeenGlobalValSummary) &&
7335 "Expected early VST parse via VSTOffset record");
7336 if (
Error Err = Stream.SkipBlock())
7342 if (!SourceFileName.
empty())
7344 assert(!SeenValueSymbolTable &&
7345 "Already read VST when parsing summary block?");
7350 if (VSTOffset > 0) {
7351 if (
Error Err = parseValueSymbolTable(VSTOffset, ValueIdToLinkageMap))
7353 SeenValueSymbolTable =
true;
7355 SeenGlobalValSummary =
true;
7356 if (
Error Err = parseEntireSummary(
Entry.ID))
7360 if (
Error Err = parseModuleStringTable())
7368 Expected<unsigned> MaybeBitCode = Stream.readRecord(
Entry.ID, Record);
7371 switch (MaybeBitCode.
get()) {
7375 if (
Error Err = parseVersionRecord(Record).takeError())
7383 return error(
"Invalid record");
7389 if (Record.
size() != 5)
7390 return error(
"Invalid hash length " + Twine(Record.
size()).str());
7391 auto &Hash = getThisModule()->second;
7393 for (
auto &Val : Record) {
7394 assert(!(Val >> 32) &&
"Unexpected high bits set");
7402 return error(
"Invalid record");
7406 VSTOffset = Record[0] - 1;
7416 ArrayRef<uint64_t> GVRecord;
7417 std::tie(Name, GVRecord) = readNameFromStrtab(Record);
7418 if (GVRecord.
size() <= 3)
7419 return error(
"Invalid record");
7420 uint64_t RawLinkage = GVRecord[3];
7423 ValueIdToLinkageMap[ValueId++] =
Linkage;
7427 setValueGUID(ValueId++, Name,
Linkage, SourceFileName);
7438ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) {
7441 for (uint64_t RefValueId : Record)
7442 Ret.push_back(std::get<0>(getValueInfoFromValueId(RefValueId)));
7447ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record,
7448 bool IsOldProfileFormat,
7449 bool HasProfile,
bool HasRelBF) {
7453 if (!IsOldProfileFormat && (HasProfile || HasRelBF))
7454 Ret.reserve(Record.
size() / 2);
7458 for (
unsigned I = 0,
E = Record.
size();
I !=
E; ++
I) {
7460 bool HasTailCall =
false;
7462 ValueInfo
Callee = std::get<0>(getValueInfoFromValueId(Record[
I]));
7463 if (IsOldProfileFormat) {
7467 }
else if (HasProfile)
7468 std::tie(Hotness, HasTailCall) =
7473 Callee, CalleeInfo(Hotness, HasTailCall, RelBF)});
7501 static_cast<size_t>(
Record[Slot + 1])};
7524 while (Slot <
Record.size())
7528std::vector<FunctionSummary::ParamAccess>
7529ModuleSummaryIndexBitcodeReader::parseParamAccesses(ArrayRef<uint64_t> Record) {
7530 auto ReadRange = [&]() {
7532 BitcodeReader::decodeSignRotatedValue(Record.
consume_front()));
7534 BitcodeReader::decodeSignRotatedValue(Record.
consume_front()));
7541 std::vector<FunctionSummary::ParamAccess> PendingParamAccesses;
7542 while (!Record.
empty()) {
7543 PendingParamAccesses.emplace_back();
7544 FunctionSummary::ParamAccess &ParamAccess = PendingParamAccesses.back();
7546 ParamAccess.
Use = ReadRange();
7551 std::get<0>(getValueInfoFromValueId(Record.
consume_front()));
7552 Call.Offsets = ReadRange();
7555 return PendingParamAccesses;
7558void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableInfo(
7559 ArrayRef<uint64_t> Record,
size_t &Slot,
7562 ValueInfo
Callee = std::get<0>(getValueInfoFromValueId(Record[Slot++]));
7566void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableSummaryRecord(
7567 ArrayRef<uint64_t> Record) {
7572 static_cast<size_t>(Record[
Slot + 1])});
7575 while (Slot < Record.
size())
7576 parseTypeIdCompatibleVtableInfo(Record, Slot, TypeId);
7579SmallVector<unsigned> ModuleSummaryIndexBitcodeReader::parseAllocInfoContext(
7580 ArrayRef<uint64_t> Record,
unsigned &
I) {
7581 SmallVector<unsigned> StackIdList;
7585 if (RadixArray.empty()) {
7586 unsigned NumStackEntries = Record[
I++];
7588 StackIdList.
reserve(NumStackEntries);
7589 for (
unsigned J = 0; J < NumStackEntries; J++) {
7590 assert(Record[
I] < StackIds.size());
7595 unsigned RadixIndex = Record[
I++];
7601 assert(RadixIndex < RadixArray.size());
7602 unsigned NumStackIds = RadixArray[RadixIndex++];
7603 StackIdList.
reserve(NumStackIds);
7604 while (NumStackIds--) {
7605 assert(RadixIndex < RadixArray.size());
7606 unsigned Elem = RadixArray[RadixIndex];
7607 if (
static_cast<std::make_signed_t<unsigned>
>(Elem) < 0) {
7608 RadixIndex = RadixIndex - Elem;
7609 assert(RadixIndex < RadixArray.size());
7610 Elem = RadixArray[RadixIndex];
7612 assert(
static_cast<std::make_signed_t<unsigned>
>(Elem) >= 0);
7625 unsigned FirstWORef = Refs.
size() - WOCnt;
7626 unsigned RefNo = FirstWORef - ROCnt;
7627 for (; RefNo < FirstWORef; ++RefNo)
7628 Refs[RefNo].setReadOnly();
7629 for (; RefNo < Refs.
size(); ++RefNo)
7630 Refs[RefNo].setWriteOnly();
7635Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(
unsigned ID) {
7636 if (
Error Err = Stream.EnterSubBlock(
ID))
7638 SmallVector<uint64_t, 64> Record;
7642 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
7645 BitstreamEntry
Entry = MaybeEntry.
get();
7648 return error(
"Invalid Summary Block: record for version expected");
7649 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
7653 return error(
"Invalid Summary Block: version expected");
7655 const uint64_t
Version = Record[0];
7656 const bool IsOldProfileFormat =
Version == 1;
7658 return error(
"Invalid summary version " + Twine(
Version) +
7659 ". Version should be in the range [1-" +
7666 GlobalValueSummary *LastSeenSummary =
nullptr;
7672 std::vector<GlobalValue::GUID> PendingTypeTests;
7673 std::vector<FunctionSummary::VFuncId> PendingTypeTestAssumeVCalls,
7674 PendingTypeCheckedLoadVCalls;
7675 std::vector<FunctionSummary::ConstVCall> PendingTypeTestAssumeConstVCalls,
7676 PendingTypeCheckedLoadConstVCalls;
7677 std::vector<FunctionSummary::ParamAccess> PendingParamAccesses;
7679 std::vector<CallsiteInfo> PendingCallsites;
7680 std::vector<AllocInfo> PendingAllocs;
7681 std::vector<uint64_t> PendingContextIds;
7684 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
7687 BitstreamEntry
Entry = MaybeEntry.
get();
7689 switch (
Entry.Kind) {
7692 return error(
"Malformed block");
7708 Expected<unsigned> MaybeBitCode = Stream.readRecord(
Entry.ID, Record);
7711 switch (
unsigned BitCode = MaybeBitCode.
get()) {
7719 uint64_t ValueID = Record[0];
7722 RefGUID = Record[1] << 32 | Record[2];
7724 RefGUID = Record[1];
7726 ValueIdToValueInfoMap[ValueID] =
7742 unsigned ValueID = Record[0];
7743 uint64_t RawFlags = Record[1];
7744 unsigned InstCount = Record[2];
7745 uint64_t RawFunFlags = 0;
7746 unsigned NumRefs = Record[3];
7747 unsigned NumRORefs = 0, NumWORefs = 0;
7748 int RefListStartIndex = 4;
7750 RawFunFlags = Record[3];
7751 NumRefs = Record[4];
7752 RefListStartIndex = 5;
7754 NumRORefs = Record[5];
7755 RefListStartIndex = 6;
7757 NumWORefs = Record[6];
7758 RefListStartIndex = 7;
7769 int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
7770 assert(Record.
size() >= RefListStartIndex + NumRefs &&
7771 "Record size inconsistent with number of references");
7773 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7777 ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
7778 IsOldProfileFormat, HasProfile, HasRelBF);
7780 auto VIAndOriginalGUID = getValueInfoFromValueId(ValueID);
7786 !IsPrevailing(VIAndOriginalGUID.first.getGUID())) {
7787 PendingCallsites.clear();
7788 PendingAllocs.clear();
7790 auto FS = std::make_unique<FunctionSummary>(
7792 std::move(Calls), std::move(PendingTypeTests),
7793 std::move(PendingTypeTestAssumeVCalls),
7794 std::move(PendingTypeCheckedLoadVCalls),
7795 std::move(PendingTypeTestAssumeConstVCalls),
7796 std::move(PendingTypeCheckedLoadConstVCalls),
7797 std::move(PendingParamAccesses), std::move(PendingCallsites),
7798 std::move(PendingAllocs));
7799 FS->setModulePath(getThisModule()->first());
7800 FS->setOriginalName(std::get<1>(VIAndOriginalGUID));
7809 unsigned ValueID = Record[0];
7810 uint64_t RawFlags = Record[1];
7811 unsigned AliaseeID = Record[2];
7813 auto AS = std::make_unique<AliasSummary>(Flags);
7819 AS->setModulePath(getThisModule()->first());
7821 auto AliaseeVI = std::get<0>(getValueInfoFromValueId(AliaseeID));
7823 if (!AliaseeInModule)
7824 return error(
"Alias expects aliasee summary to be parsed");
7825 AS->setAliasee(AliaseeVI, AliaseeInModule);
7827 auto GUID = getValueInfoFromValueId(ValueID);
7828 AS->setOriginalName(std::get<1>(GUID));
7834 unsigned ValueID = Record[0];
7835 uint64_t RawFlags = Record[1];
7836 unsigned RefArrayStart = 2;
7837 GlobalVarSummary::GVarFlags GVF(
false,
7847 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
7849 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
7850 FS->setModulePath(getThisModule()->first());
7851 auto GUID = getValueInfoFromValueId(ValueID);
7852 FS->setOriginalName(std::get<1>(GUID));
7860 unsigned ValueID = Record[0];
7861 uint64_t RawFlags = Record[1];
7863 unsigned NumRefs = Record[3];
7864 unsigned RefListStartIndex = 4;
7865 unsigned VTableListStartIndex = RefListStartIndex + NumRefs;
7868 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7870 for (
unsigned I = VTableListStartIndex,
E = Record.
size();
I !=
E; ++
I) {
7871 ValueInfo
Callee = std::get<0>(getValueInfoFromValueId(Record[
I]));
7872 uint64_t
Offset = Record[++
I];
7876 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
7877 VS->setModulePath(getThisModule()->first());
7878 VS->setVTableFuncs(VTableFuncs);
7879 auto GUID = getValueInfoFromValueId(ValueID);
7880 VS->setOriginalName(std::get<1>(GUID));
7892 unsigned ValueID = Record[0];
7893 uint64_t ModuleId = Record[1];
7894 uint64_t RawFlags = Record[2];
7895 unsigned InstCount = Record[3];
7896 uint64_t RawFunFlags = 0;
7897 unsigned NumRefs = Record[4];
7898 unsigned NumRORefs = 0, NumWORefs = 0;
7899 int RefListStartIndex = 5;
7902 RawFunFlags = Record[4];
7903 RefListStartIndex = 6;
7904 size_t NumRefsIndex = 5;
7906 unsigned NumRORefsOffset = 1;
7907 RefListStartIndex = 7;
7910 RefListStartIndex = 8;
7912 RefListStartIndex = 9;
7913 NumWORefs = Record[8];
7914 NumRORefsOffset = 2;
7917 NumRORefs = Record[RefListStartIndex - NumRORefsOffset];
7919 NumRefs = Record[NumRefsIndex];
7923 int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
7924 assert(Record.
size() >= RefListStartIndex + NumRefs &&
7925 "Record size inconsistent with number of references");
7927 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7930 ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
7931 IsOldProfileFormat, HasProfile,
false);
7932 ValueInfo
VI = std::get<0>(getValueInfoFromValueId(ValueID));
7934 auto FS = std::make_unique<FunctionSummary>(
7936 std::move(Edges), std::move(PendingTypeTests),
7937 std::move(PendingTypeTestAssumeVCalls),
7938 std::move(PendingTypeCheckedLoadVCalls),
7939 std::move(PendingTypeTestAssumeConstVCalls),
7940 std::move(PendingTypeCheckedLoadConstVCalls),
7941 std::move(PendingParamAccesses), std::move(PendingCallsites),
7942 std::move(PendingAllocs));
7943 LastSeenSummary =
FS.get();
7944 LastSeenGUID =
VI.getGUID();
7945 FS->setModulePath(ModuleIdMap[ModuleId]);
7953 unsigned ValueID = Record[0];
7954 uint64_t ModuleId = Record[1];
7955 uint64_t RawFlags = Record[2];
7956 unsigned AliaseeValueId = Record[3];
7958 auto AS = std::make_unique<AliasSummary>(Flags);
7959 LastSeenSummary = AS.get();
7960 AS->setModulePath(ModuleIdMap[ModuleId]);
7962 auto AliaseeVI = std::get<0>(getValueInfoFromValueId(AliaseeValueId));
7964 AS->setAliasee(AliaseeVI, AliaseeInModule);
7966 ValueInfo
VI = std::get<0>(getValueInfoFromValueId(ValueID));
7967 LastSeenGUID =
VI.getGUID();
7973 unsigned ValueID = Record[0];
7974 uint64_t ModuleId = Record[1];
7975 uint64_t RawFlags = Record[2];
7976 unsigned RefArrayStart = 3;
7977 GlobalVarSummary::GVarFlags GVF(
false,
7987 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
7989 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
7990 LastSeenSummary =
FS.get();
7991 FS->setModulePath(ModuleIdMap[ModuleId]);
7992 ValueInfo
VI = std::get<0>(getValueInfoFromValueId(ValueID));
7993 LastSeenGUID =
VI.getGUID();
7999 uint64_t OriginalName = Record[0];
8000 if (!LastSeenSummary)
8001 return error(
"Name attachment that does not follow a combined record");
8005 LastSeenSummary =
nullptr;
8010 assert(PendingTypeTests.empty());
8015 assert(PendingTypeTestAssumeVCalls.empty());
8016 for (
unsigned I = 0;
I != Record.
size();
I += 2)
8017 PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});
8021 assert(PendingTypeCheckedLoadVCalls.empty());
8022 for (
unsigned I = 0;
I != Record.
size();
I += 2)
8023 PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});
8027 PendingTypeTestAssumeConstVCalls.push_back(
8028 {{Record[0], Record[1]}, {Record.
begin() + 2, Record.
end()}});
8032 PendingTypeCheckedLoadConstVCalls.push_back(
8033 {{Record[0], Record[1]}, {Record.
begin() + 2, Record.
end()}});
8038 for (
unsigned I = 0;
I != Record.
size();
I += 2)
8040 static_cast<size_t>(Record[
I + 1]));
8046 for (
unsigned I = 0;
I != Record.
size();
I += 2)
8048 static_cast<size_t>(Record[
I + 1]));
8057 parseTypeIdCompatibleVtableSummaryRecord(Record);
8065 PendingParamAccesses = parseParamAccesses(Record);
8073 StackIds = ArrayRef<uint64_t>(Record);
8079 StackIds.reserve(Record.
size() / 2);
8080 for (
auto R = Record.
begin(); R != Record.
end(); R += 2)
8081 StackIds.push_back(*R << 32 | *(R + 1));
8086 RadixArray = ArrayRef<uint64_t>(Record);
8091 unsigned ValueID = Record[0];
8092 SmallVector<unsigned> StackIdList;
8094 assert(R < StackIds.size());
8097 ValueInfo
VI = std::get<0>(getValueInfoFromValueId(ValueID));
8098 PendingCallsites.push_back(CallsiteInfo({
VI, std::move(StackIdList)}));
8103 auto RecordIter = Record.
begin();
8104 unsigned ValueID = *RecordIter++;
8105 unsigned NumStackIds = *RecordIter++;
8106 unsigned NumVersions = *RecordIter++;
8107 assert(Record.
size() == 3 + NumStackIds + NumVersions);
8108 SmallVector<unsigned> StackIdList;
8109 for (
unsigned J = 0; J < NumStackIds; J++) {
8110 assert(*RecordIter < StackIds.size());
8114 SmallVector<unsigned> Versions;
8115 for (
unsigned J = 0; J < NumVersions; J++)
8117 ValueInfo
VI = std::get<0>(
8118 getValueInfoFromValueId</*AllowNullValueInfo*/ true>(ValueID));
8119 PendingCallsites.push_back(
8120 CallsiteInfo({
VI, std::move(Versions), std::move(StackIdList)}));
8128 PendingContextIds.reserve(Record.
size() / 2);
8129 for (
auto R = Record.
begin(); R != Record.
end(); R += 2)
8130 PendingContextIds.push_back(*R << 32 | *(R + 1));
8136 std::vector<MIBInfo> MIBs;
8137 unsigned NumMIBs = 0;
8139 NumMIBs = Record[
I++];
8140 unsigned MIBsRead = 0;
8141 while ((
Version >= 10 && MIBsRead++ < NumMIBs) ||
8145 auto StackIdList = parseAllocInfoContext(Record,
I);
8146 MIBs.push_back(MIBInfo(
AllocType, std::move(StackIdList)));
8152 std::vector<std::vector<ContextTotalSize>> AllContextSizes;
8153 if (
I < Record.
size()) {
8154 assert(!PendingContextIds.empty() &&
8155 "Missing context ids for alloc sizes");
8156 unsigned ContextIdIndex = 0;
8162 while (MIBsRead++ < NumMIBs) {
8164 unsigned NumContextSizeInfoEntries = Record[
I++];
8165 assert(Record.
size() -
I >= NumContextSizeInfoEntries);
8166 std::vector<ContextTotalSize> ContextSizes;
8167 ContextSizes.reserve(NumContextSizeInfoEntries);
8168 for (
unsigned J = 0; J < NumContextSizeInfoEntries; J++) {
8169 assert(ContextIdIndex < PendingContextIds.size());
8171 if (PendingContextIds[ContextIdIndex] == 0) {
8180 ContextSizes.push_back(
8181 {PendingContextIds[ContextIdIndex++], Record[
I++]});
8183 AllContextSizes.push_back(std::move(ContextSizes));
8185 PendingContextIds.clear();
8187 PendingAllocs.push_back(AllocInfo(std::move(MIBs)));
8188 if (!AllContextSizes.empty()) {
8189 assert(PendingAllocs.back().MIBs.size() == AllContextSizes.size());
8190 PendingAllocs.back().ContextSizeInfos = std::move(AllContextSizes);
8198 std::vector<MIBInfo> MIBs;
8199 unsigned NumMIBs = Record[
I++];
8200 unsigned NumVersions = Record[
I++];
8201 unsigned MIBsRead = 0;
8202 while (MIBsRead++ < NumMIBs) {
8205 SmallVector<unsigned> StackIdList;
8207 StackIdList = parseAllocInfoContext(Record,
I);
8208 MIBs.push_back(MIBInfo(
AllocType, std::move(StackIdList)));
8211 SmallVector<uint8_t> Versions;
8212 for (
unsigned J = 0; J < NumVersions; J++)
8215 PendingAllocs.push_back(AllocInfo(std::move(Versions), std::move(MIBs)));
8225Error ModuleSummaryIndexBitcodeReader::parseModuleStringTable() {
8229 SmallVector<uint64_t, 64> Record;
8231 SmallString<128> ModulePath;
8235 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
8238 BitstreamEntry
Entry = MaybeEntry.
get();
8240 switch (
Entry.Kind) {
8243 return error(
"Malformed block");
8252 Expected<unsigned> MaybeRecord = Stream.readRecord(
Entry.ID, Record);
8255 switch (MaybeRecord.
get()) {
8260 uint64_t ModuleId = Record[0];
8263 return error(
"Invalid record");
8265 LastSeenModule = TheIndex.
addModule(ModulePath);
8266 ModuleIdMap[ModuleId] = LastSeenModule->
first();
8273 if (Record.
size() != 5)
8274 return error(
"Invalid hash length " + Twine(Record.
size()).str());
8275 if (!LastSeenModule)
8276 return error(
"Invalid hash that does not follow a module path");
8278 for (
auto &Val : Record) {
8279 assert(!(Val >> 32) &&
"Unexpected high bits set");
8280 LastSeenModule->
second[Pos++] = Val;
8283 LastSeenModule =
nullptr;
8296class BitcodeErrorCategoryType :
public std::error_category {
8297 const char *
name()
const noexcept
override {
8298 return "llvm.bitcode";
8301 std::string message(
int IE)
const override {
8304 case BitcodeError::CorruptedBitcode:
8305 return "Corrupted bitcode";
8314 static BitcodeErrorCategoryType ErrorCategory;
8315 return ErrorCategory;
8319 unsigned Block,
unsigned RecordID) {
8321 return std::move(Err);
8330 switch (Entry.Kind) {
8335 return error(
"Malformed block");
8339 return std::move(Err);
8349 if (MaybeRecord.
get() == RecordID)
8360Expected<std::vector<BitcodeModule>>
8364 return FOrErr.takeError();
8365 return std::move(FOrErr->Mods);
8390 switch (Entry.Kind) {
8393 return error(
"Malformed block");
8396 uint64_t IdentificationBit = -1ull;
8400 return std::move(Err);
8406 Entry = MaybeEntry.
get();
8411 return error(
"Malformed block");
8417 return std::move(Err);
8436 if (!
I.Strtab.empty())
8443 if (!
F.Symtab.empty() &&
F.StrtabForSymtab.empty())
8444 F.StrtabForSymtab = *Strtab;
8460 if (
F.Symtab.empty())
8461 F.Symtab = *SymtabOrErr;
8466 return std::move(Err);
8471 return std::move(E);
8486BitcodeModule::getModuleImpl(
LLVMContext &Context,
bool MaterializeAll,
8487 bool ShouldLazyLoadMetadata,
bool IsImporting,
8491 std::string ProducerIdentification;
8492 if (IdentificationBit != -1ull) {
8493 if (
Error JumpFailed = Stream.JumpToBit(IdentificationBit))
8494 return std::move(JumpFailed);
8497 return std::move(
E);
8500 if (
Error JumpFailed = Stream.JumpToBit(ModuleBit))
8501 return std::move(JumpFailed);
8502 auto *
R =
new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
8505 std::unique_ptr<Module>
M =
8506 std::make_unique<Module>(ModuleIdentifier,
Context);
8507 M->setMaterializer(R);
8510 if (
Error Err =
R->parseBitcodeInto(
M.get(), ShouldLazyLoadMetadata,
8511 IsImporting, Callbacks))
8512 return std::move(Err);
8514 if (MaterializeAll) {
8516 if (
Error Err =
M->materializeAll())
8517 return std::move(Err);
8520 if (
Error Err =
R->materializeForwardReferencedFunctions())
8521 return std::move(Err);
8524 return std::move(M);
8527Expected<std::unique_ptr<Module>>
8530 return getModuleImpl(Context,
false, ShouldLazyLoadMetadata, IsImporting,
8545 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, CombinedIndex,
8546 ModulePath, IsPrevailing);
8547 return R.parseModule();
8554 return std::move(JumpFailed);
8556 auto Index = std::make_unique<ModuleSummaryIndex>(
false);
8557 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
8558 ModuleIdentifier, 0);
8560 if (
Error Err = R.parseModule())
8561 return std::move(Err);
8563 return std::move(Index);
8571 return std::move(Err);
8576 std::pair<bool, bool> Result = {
false,
false};
8578 return std::move(
E);
8580 switch (Entry.Kind) {
8583 return error(
"Malformed block");
8598 switch (MaybeBitCode.
get()) {
8604 assert(Flags <= 0x2ff &&
"Unexpected bits in flag");
8606 bool EnableSplitLTOUnit = Flags & 0x8;
8607 bool UnifiedLTO = Flags & 0x200;
8608 Result = {EnableSplitLTOUnit, UnifiedLTO};
8621 return std::move(JumpFailed);
8624 return std::move(Err);
8629 return std::move(E);
8631 switch (Entry.Kind) {
8633 return error(
"Malformed block");
8644 return Flags.takeError();
8656 return Flags.takeError();
8665 return std::move(Err);
8672 return StreamFailed.takeError();
8682 if (MsOrErr->size() != 1)
8683 return error(
"Expected a single module");
8685 return (*MsOrErr)[0];
8688Expected<std::unique_ptr<Module>>
8690 bool ShouldLazyLoadMetadata,
bool IsImporting,
8696 return BM->getLazyModule(Context, ShouldLazyLoadMetadata, IsImporting,
8701 std::unique_ptr<MemoryBuffer> &&Buffer,
LLVMContext &Context,
8702 bool ShouldLazyLoadMetadata,
bool IsImporting,
ParserCallbacks Callbacks) {
8704 IsImporting, Callbacks);
8706 (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));
8712 return getModuleImpl(Context,
true,
false,
false, Callbacks);
8724 return BM->parseModule(Context, Callbacks);
8757 return BM->readSummary(CombinedIndex, BM->getModuleIdentifier());
8766 return BM->getSummary();
8774 return BM->getLTOInfo();
8779 bool IgnoreEmptyThinLTOIndexFile) {
8784 if (IgnoreEmptyThinLTOIndexFile && !(*FileOrErr)->getBufferSize())
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static bool isConstant(const MachineInstr &MI)
AMDGPU Prepare AGPR Alloc
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Expand Atomic instructions
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static void getDecodedRelBFCallEdgeInfo(uint64_t RawFlags, uint64_t &RelBF, bool &HasTailCall)
static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val)
static cl::opt< bool > PrintSummaryGUIDs("print-summary-global-ids", cl::init(false), cl::Hidden, cl::desc("Print the global id for each value when reading the module summary"))
static AtomicOrdering getDecodedOrdering(unsigned Val)
static std::pair< CalleeInfo::HotnessType, bool > getDecodedHotnessCallEdgeInfo(uint64_t RawFlags)
static FunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags)
static std::optional< CodeModel::Model > getDecodedCodeModel(unsigned Val)
static void setSpecialRefs(SmallVectorImpl< ValueInfo > &Refs, unsigned ROCnt, unsigned WOCnt)
static bool getDecodedDSOLocal(unsigned Val)
static bool convertToString(ArrayRef< uint64_t > Record, unsigned Idx, StrTy &Result)
Convert a string from a record into an std::string, return true on failure.
static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val)
static void stripTBAA(Module *M)
static Expected< std::pair< bool, bool > > getEnableSplitLTOUnitAndUnifiedFlag(BitstreamCursor &Stream, unsigned ID, BitcodeLTOInfo <OInfo)
static int getDecodedUnaryOpcode(unsigned Val, Type *Ty)
static Expected< std::string > readTriple(BitstreamCursor &Stream)
static void parseWholeProgramDevirtResolutionByArg(ArrayRef< uint64_t > Record, size_t &Slot, WholeProgramDevirtResolution &Wpd)
static uint64_t getRawAttributeMask(Attribute::AttrKind Val)
static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags, uint64_t Version)
static GlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags)
static Attribute::AttrKind getAttrFromCode(uint64_t Code)
static Expected< uint64_t > jumpToValueSymbolTable(uint64_t Offset, BitstreamCursor &Stream)
Helper to note and return the current location, and jump to the given offset.
static Expected< bool > hasObjCCategoryInModule(BitstreamCursor &Stream)
static GlobalValue::DLLStorageClassTypes getDecodedDLLStorageClass(unsigned Val)
static GEPNoWrapFlags toGEPNoWrapFlags(uint64_t Flags)
static void decodeLLVMAttributesForBitcode(AttrBuilder &B, uint64_t EncodedAttrs, uint64_t AttrIdx)
This fills an AttrBuilder object with the LLVM attributes that have been decoded from the given integ...
static void parseTypeIdSummaryRecord(ArrayRef< uint64_t > Record, StringRef Strtab, ModuleSummaryIndex &TheIndex)
static void addRawAttributeValue(AttrBuilder &B, uint64_t Val)
static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val)
static bool hasImplicitComdat(size_t Val)
static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val)
static Error hasInvalidBitcodeHeader(BitstreamCursor &Stream)
static Expected< std::string > readIdentificationCode(BitstreamCursor &Stream)
static int getDecodedBinaryOpcode(unsigned Val, Type *Ty)
static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val)
static Expected< BitcodeModule > getSingleModule(MemoryBufferRef Buffer)
static Expected< bool > hasObjCCategory(BitstreamCursor &Stream)
static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val)
static void parseWholeProgramDevirtResolution(ArrayRef< uint64_t > Record, StringRef Strtab, size_t &Slot, TypeIdSummary &TypeId)
static void inferDSOLocal(GlobalValue *GV)
static FastMathFlags getDecodedFastMathFlags(unsigned Val)
GlobalValue::SanitizerMetadata deserializeSanitizerMetadata(unsigned V)
static Expected< BitstreamCursor > initStream(MemoryBufferRef Buffer)
static cl::opt< bool > ExpandConstantExprs("expand-constant-exprs", cl::Hidden, cl::desc("Expand constant expressions to instructions for testing purposes"))
static bool upgradeOldMemoryAttribute(MemoryEffects &ME, uint64_t EncodedKind)
static Expected< StringRef > readBlobInRecord(BitstreamCursor &Stream, unsigned Block, unsigned RecordID)
static Expected< std::string > readIdentificationBlock(BitstreamCursor &Stream)
Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the "epoch" encoded in the bit...
static bool isConstExprSupported(const BitcodeConstant *BC)
static int getDecodedCastOpcode(unsigned Val)
static Expected< std::string > readModuleTriple(BitstreamCursor &Stream)
static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Analysis containing CSE Info
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase)
This file defines the DenseMap class.
Provides ErrorOr<T> smart pointer.
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
Module.h This file contains the declarations for the Module class.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
Machine Check Debug Module
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
PowerPC Reduce CR logical Operation
This file contains the declarations for profiling metadata utility functions.
const SmallVectorImpl< MachineOperand > & Cond
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
static uint64_t decodeSignRotatedValue(uint64_t V)
Decode a signed value stored with the sign bit in the LSB for dense VBR encoding.
This file defines the SmallString class.
This file defines the SmallVector class.
Class for arbitrary precision integers.
void setSwiftError(bool V)
Specify whether this alloca is used to represent a swifterror.
PointerType * getType() const
Overload to return most specific pointer type.
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
const T & consume_front()
consume_front() - Returns the first element and drops it from ArrayRef.
static bool isValidFailureOrdering(AtomicOrdering Ordering)
static AtomicOrdering getStrongestFailureOrdering(AtomicOrdering SuccessOrdering)
Returns the strongest permitted ordering on failure, given the desired ordering on success.
static bool isValidSuccessOrdering(AtomicOrdering Ordering)
BinOp
This enumeration lists the possible modifications atomicrmw can make.
@ USubCond
Subtract only if no unsigned overflow.
@ FMinimum
*p = minimum(old, v) minimum matches the behavior of llvm.minimum.
@ Min
*p = old <signed v ? old : v
@ USubSat
*p = usub.sat(old, v) usub.sat matches the behavior of llvm.usub.sat.
@ FMaximum
*p = maximum(old, v) maximum matches the behavior of llvm.maximum.
@ UIncWrap
Increment one up to a maximum value.
@ Max
*p = old >signed v ? old : v
@ UMin
*p = old <unsigned v ? old : v
@ FMin
*p = minnum(old, v) minnum matches the behavior of llvm.minnum.
@ UMax
*p = old >unsigned v ? old : v
@ FMax
*p = maxnum(old, v) maxnum matches the behavior of llvm.maxnum.
@ UDecWrap
Decrement one until a minimum value or zero.
static bool isTypeAttrKind(AttrKind Kind)
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
@ TombstoneKey
Use as Tombstone key for DenseMap of AttrKind.
@ None
No attributes have been set.
@ EmptyKey
Use as Empty key for DenseMap of AttrKind.
@ EndAttrKinds
Sentinel value useful for loops.
LLVM Basic Block Representation.
const Instruction & back() const
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
LLVM_ABI void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block to refer to basic block New instead of basic block Old.
LLVM_ABI SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
static LLVM_ABI BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Represents a module in a bitcode file.
LLVM_ABI Expected< std::unique_ptr< ModuleSummaryIndex > > getSummary()
Parse the specified bitcode buffer, returning the module summary index.
LLVM_ABI Expected< BitcodeLTOInfo > getLTOInfo()
Returns information about the module to be used for LTO: whether to compile with ThinLTO,...
LLVM_ABI Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath, std::function< bool(GlobalValue::GUID)> IsPrevailing=nullptr)
Parse the specified bitcode buffer and merge its module summary index into CombinedIndex.
LLVM_ABI Expected< std::unique_ptr< Module > > parseModule(LLVMContext &Context, ParserCallbacks Callbacks={})
Read the entire bitcode module and return it.
LLVM_ABI Expected< std::unique_ptr< Module > > getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks={})
Read the bitcode module and prepare for lazy deserialization of function bodies.
Value * getValueFwdRef(unsigned Idx, Type *Ty, unsigned TyID, BasicBlock *ConstExprInsertBB)
void push_back(Value *V, unsigned TypeID)
void replaceValueWithoutRAUW(unsigned ValNo, Value *NewV)
Error assignValue(unsigned Idx, Value *V, unsigned TypeID)
void shrinkTo(unsigned N)
unsigned getTypeID(unsigned ValNo) const
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
Error JumpToBit(uint64_t BitNo)
Reset the stream to the specified bit number.
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
ArrayRef< uint8_t > getBitcodeBytes() const
Expected< word_t > Read(unsigned NumBits)
Expected< BitstreamEntry > advance(unsigned Flags=0)
Advance the current bitstream, returning the next entry in the stream.
Expected< BitstreamEntry > advanceSkippingSubblocks(unsigned Flags=0)
This is a convenience function for clients that don't expect any subblocks.
LLVM_ABI Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
LLVM_ABI Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP=nullptr)
Having read the ENTER_SUBBLOCK abbrevid, and enter the block.
Error SkipBlock()
Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body of this block.
LLVM_ABI Expected< unsigned > skipRecord(unsigned AbbrevID)
Read the current record and discard it, returning the code for the record.
uint64_t getCurrentByteNo() const
LLVM_ABI Expected< std::optional< BitstreamBlockInfo > > ReadBlockInfoBlock(bool ReadBlockInfoNames=false)
Read and return a block info block from the bitstream.
bool canSkipToPos(size_t pos) const
static LLVM_ABI BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)
bool isInlineAsm() const
Check if this call is an inline asm statement.
Value * getCalledOperand() const
void setAttributes(AttributeList A)
Set the attributes for this call.
LLVM_ABI Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
unsigned arg_size() const
AttributeList getAttributes() const
Return the attributes for this call.
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CaptureInfo createFromIntValue(uint32_t Data)
static CaptureInfo none()
Create CaptureInfo that does not capture any components of the pointer.
static LLVM_ABI CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static LLVM_ABI bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)
This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.
static CatchPadInst * Create(Value *CatchSwitch, ArrayRef< Value * > Args, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CatchReturnInst * Create(Value *CatchPad, BasicBlock *BB, InsertPosition InsertBefore=nullptr)
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
void emplace(Args &&...A)
static CleanupPadInst * Create(Value *ParentPad, ArrayRef< Value * > Args={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition InsertBefore=nullptr)
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
static LLVM_ABI CmpInst * Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
bool isFPPredicate() const
bool isIntPredicate() const
@ Largest
The linker will choose the largest COMDAT.
@ SameSize
The data referenced by the COMDAT must be the same size.
@ Any
The linker may choose any COMDAT.
@ NoDeduplicate
No deduplication is performed.
@ ExactMatch
The data referenced by the COMDAT must be the same.
static LLVM_ABI Constant * get(ArrayType *T, ArrayRef< Constant * > V)
static LLVM_ABI Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
static LLVM_ABI Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of array type with a float element type taken from argument ...
static LLVM_ABI Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
get() constructors - Return a constant with vector type with an element count and element type matchi...
static LLVM_ABI Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of vector type with a float element type taken from argument...
static LLVM_ABI Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static LLVM_ABI Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
static LLVM_ABI Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static LLVM_ABI Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)
static bool isSupportedGetElementPtr(const Type *SrcElemTy)
Whether creating a constant expression for this getelementptr type is supported.
static LLVM_ABI Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible.
static LLVM_ABI bool isSupportedBinOp(unsigned Opcode)
Whether creating a constant expression for this binary operator is supported.
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
static LLVM_ABI bool isSupportedCastOp(unsigned Opcode)
Whether creating a constant expression for this cast is supported.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
static LLVM_ABI ConstantPtrAuth * get(Constant *Ptr, ConstantInt *Key, ConstantInt *Disc, Constant *AddrDisc)
Return a pointer signed with the specified parameters.
static LLVM_ABI bool isOrderedRanges(ArrayRef< ConstantRange > RangesRef)
LLVM_ABI bool isUpperSignWrapped() const
Return true if the (exclusive) upper bound wraps around the signed domain.
LLVM_ABI bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type.
static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)
static LLVM_ABI Constant * get(ArrayRef< Constant * > V)
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
static LLVM_ABI DSOLocalEquivalent * get(GlobalValue *GV)
Return a DSOLocalEquivalent for the specified global value.
static LLVM_ABI Expected< DataLayout > parse(StringRef LayoutString)
Parse a data layout string and return the layout.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
bool erase(const KeyT &Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Base class for error info classes.
virtual std::string message() const
Return the error message as a string.
virtual std::error_code convertToErrorCode() const =0
Convert this error to a std::error_code.
Represents either an error or a value T.
std::error_code getError() const
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.
Convenience struct for specifying and reasoning about fast-math flags.
void setFast(bool B=true)
void setAllowContract(bool B=true)
void setAllowReciprocal(bool B=true)
void setNoSignedZeros(bool B=true)
void setNoNaNs(bool B=true)
void setAllowReassoc(bool B=true)
Flag setters.
void setApproxFunc(bool B=true)
void setNoInfs(bool B=true)
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
std::pair< ValueInfo, CalleeInfo > EdgeTy
<CalleeValueInfo, CalleeInfo> call edge pair.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
BasicBlockListType::iterator iterator
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
static GEPNoWrapFlags noUnsignedWrap()
static GEPNoWrapFlags noUnsignedSignedWrap()
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static LLVM_ABI GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
static LLVM_ABI GlobalIFunc * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Resolver, Module *Parent)
If a parent module is specified, the ifunc is automatically inserted into the end of the specified mo...
LLVM_ABI void setComdat(Comdat *C)
LLVM_ABI void setSection(StringRef S)
Change the section for this global.
void setOriginalName(GlobalValue::GUID Name)
Initialize the original name hash in this summary.
static LLVM_ABI GUID getGUIDAssumingExternalLinkage(StringRef GlobalName)
Return a 64-bit global unique ID constructed from the name of a global symbol.
static bool isLocalLinkage(LinkageTypes Linkage)
void setUnnamedAddr(UnnamedAddr Val)
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
bool hasLocalLinkage() const
bool hasDefaultVisibility() const
void setDLLStorageClass(DLLStorageClassTypes C)
void setThreadLocalMode(ThreadLocalMode Val)
bool hasExternalWeakLinkage() const
DLLStorageClassTypes
Storage classes of global values for PE targets.
@ DLLExportStorageClass
Function to be accessible from DLL.
@ DLLImportStorageClass
Function to be imported from DLL.
void setDSOLocal(bool Local)
PointerType * getType() const
Global values are always pointers.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
@ DefaultVisibility
The GV is visible.
@ HiddenVisibility
The GV is hidden.
@ ProtectedVisibility
The GV is protected.
static LLVM_ABI std::string getGlobalIdentifier(StringRef Name, GlobalValue::LinkageTypes Linkage, StringRef FileName)
Return the modified name for a global value suitable to be used as the key for a global lookup (e....
void setVisibility(VisibilityTypes V)
LLVM_ABI void setSanitizerMetadata(SanitizerMetadata Meta)
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ CommonLinkage
Tentative definitions.
@ InternalLinkage
Rename collisions when linking (static functions).
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
@ WeakODRLinkage
Same, but only replaced by something equivalent.
@ ExternalLinkage
Externally visible function.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
@ AppendingLinkage
Special purpose, only applies to global arrays.
@ AvailableExternallyLinkage
Available for inspection, not emission.
@ ExternalWeakLinkage
ExternalWeak linkage description.
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
LLVM_ABI void setPartition(StringRef Part)
void setAttributes(AttributeSet A)
Set attribute list for this global.
LLVM_ABI void setCodeModel(CodeModel::Model CM)
Change the code model for this global.
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalVariable.
LLVM_ABI void addDestination(BasicBlock *Dest)
Add a destination.
static IndirectBrInst * Create(Value *Address, unsigned NumDests, InsertPosition InsertBefore=nullptr)
unsigned getNumDestinations() const
return the number of possible destinations in this indirectbr instruction.
static LLVM_ABI InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT, bool canThrow=false)
InlineAsm::get - Return the specified uniqued inline asm string.
std::vector< ConstraintInfo > ConstraintInfoVector
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
LLVM_ABI void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB)
Replace specified successor OldBB to point at the provided block.
const char * getOpcodeName() const
LLVM_ABI InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)
Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
@ MIN_INT_BITS
Minimum number of bits that can be specified.
@ MAX_INT_BITS
Maximum number of bits that can be specified.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This is an important class for using LLVM in a threaded context.
static LLVM_ABI LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
LLVM_ABI void addClause(Constant *ClauseVal)
Add a catch or filter clause to the landing pad.
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
LLVM_ABI StringRef getString() const
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
ValueT lookup(const KeyT &Key) const
size_t getBufferSize() const
StringRef getBufferIdentifier() const
const char * getBufferStart() const
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
static MemoryEffectsBase readOnly()
static MemoryEffectsBase argMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
static MemoryEffectsBase inaccessibleMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
static MemoryEffectsBase errnoMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
static MemoryEffectsBase createFromIntValue(uint32_t Data)
static MemoryEffectsBase writeOnly()
static MemoryEffectsBase otherMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
static MemoryEffectsBase inaccessibleOrArgMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
static MemoryEffectsBase none()
static MemoryEffectsBase unknown()
Class to hold module path string table and global value map, and encapsulate methods for operating on...
TypeIdSummary & getOrInsertTypeIdSummary(StringRef TypeId)
Return an existing or new TypeIdSummary entry for TypeId.
ModulePathStringTableTy::value_type ModuleInfo
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID)
Return a ValueInfo for GUID.
StringRef saveString(StringRef String)
LLVM_ABI void setFlags(uint64_t Flags)
CfiFunctionIndex & cfiFunctionDecls()
void addBlockCount(uint64_t C)
ModuleInfo * addModule(StringRef ModPath, ModuleHash Hash=ModuleHash{{0}})
Add a new module with the given Hash, mapped to the given ModID, and return a reference to the module...
void addGlobalValueSummary(const GlobalValue &GV, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for a value.
static constexpr uint64_t BitcodeSummaryVersion
CfiFunctionIndex & cfiFunctionDefs()
GlobalValueSummary * findSummaryInModule(ValueInfo VI, StringRef ModuleId) const
Find the summary for ValueInfo VI in module ModuleId, or nullptr if not found.
unsigned addOrGetStackIdIndex(uint64_t StackId)
ModuleInfo * getModule(StringRef ModPath)
Return module entry for module with the given ModPath.
void addOriginalName(GlobalValue::GUID ValueGUID, GlobalValue::GUID OrigGUID)
Add an original name for the value of the given GUID.
TypeIdCompatibleVtableInfo & getOrInsertTypeIdCompatibleVtableSummary(StringRef TypeId)
Return an existing or new TypeIdCompatibleVtableMap entry for TypeId.
A Module instance is used to store all the information related to an LLVM module.
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
NamedMDNode * getNamedMetadata(StringRef Name) const
Return the first NamedMDNode in the module with the specified name.
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
LLVM_ABI void addOperand(MDNode *M)
static LLVM_ABI NoCFIValue * get(GlobalValue *GV)
Return a NoCFIValue for the specified function.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
static ResumeInst * Create(Value *Exn, InsertPosition InsertBefore=nullptr)
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, InsertPosition InsertBefore=nullptr)
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
ArrayRef< int > getShuffleMask() const
StringRef str() const
Explicit conversion to StringRef.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
iterator erase(const_iterator CI)
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.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
constexpr bool empty() const
empty - Check if the string is empty.
constexpr size_t size() const
size - Get the string size.
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
static LLVM_ABI StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
LLVM_ABI void setName(StringRef Name)
Change the name of this type to the specified name, or to a name with a suffix if there is a collisio...
LLVM_ABI Error setBodyOrError(ArrayRef< Type * > Elements, bool isPacked=false)
Specify a body for an opaque identified type or return an error if it would make the type recursive.
static SwitchInst * Create(Value *Value, BasicBlock *Default, unsigned NumCases, InsertPosition InsertBefore=nullptr)
LLVM_ABI bool visitTBAAMetadata(const Instruction *I, const MDNode *MD)
Visit an instruction, or a TBAA node itself as part of a metadata, and return true if it is valid,...
@ HasZeroInit
zeroinitializer is valid for this target extension type.
static LLVM_ABI Expected< TargetExtType * > getOrError(LLVMContext &Context, StringRef Name, ArrayRef< Type * > Types={}, ArrayRef< unsigned > Ints={})
Return a target extension type having the specified name and optional type and integer parameters,...
Triple - Helper class for working with autoconf configuration names.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM_ABI std::string str() const
Return the twine contents as a std::string.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM_ABI Type * getStructElementType(unsigned N) const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isArrayTy() const
True if this is an instance of ArrayType.
static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)
bool isLabelTy() const
Return true if this is 'label'.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
Type * getArrayElementType() const
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
LLVM_ABI unsigned getStructNumElements() const
LLVM_ABI uint64_t getArrayNumElements() const
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isStructTy() const
True if this is an instance of StructType.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
bool isFunctionTy() const
True if this is an instance of FunctionType.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
bool isVoidTy() const
Return true if this is 'void'.
bool isMetadataTy() const
Return true if this is 'metadata'.
static LLVM_ABI UnaryOperator * Create(UnaryOps Op, Value *S, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a unary instruction, given the opcode and an operand.
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI void setName(const Twine &Name)
Change the name of the value.
LLVM_ABI void deleteValue()
Delete a pointer to a generic Value.
std::pair< iterator, bool > insert(const ValueT &V)
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
const ParentTy * getParent() const
self_iterator getIterator()
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
constexpr char TypeName[]
Key for Kernel::Arg::Metadata::mTypeName.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
constexpr uint8_t RecordLength
Length of the parts of a physical GOFF record.
@ BasicBlock
Various leaf nodes.
LLVM_ABI AttributeList getAttributes(LLVMContext &C, ID id, FunctionType *FT)
Return the attributes for an intrinsic.
@ SingleThread
Synchronized with respect to signal handlers executing in the same thread.
@ System
Synchronized with respect to all concurrently executing threads.
@ TYPE_CODE_OPAQUE_POINTER
@ FS_CONTEXT_RADIX_TREE_ARRAY
@ FS_COMBINED_GLOBALVAR_INIT_REFS
@ FS_TYPE_CHECKED_LOAD_VCALLS
@ FS_COMBINED_ORIGINAL_NAME
@ FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS
@ FS_TYPE_TEST_ASSUME_CONST_VCALL
@ FS_PERMODULE_GLOBALVAR_INIT_REFS
@ FS_TYPE_TEST_ASSUME_VCALLS
@ FS_COMBINED_ALLOC_INFO_NO_CONTEXT
@ FS_COMBINED_CALLSITE_INFO
@ FS_PERMODULE_CALLSITE_INFO
@ FS_PERMODULE_ALLOC_INFO
@ FS_TYPE_CHECKED_LOAD_CONST_VCALL
@ IDENTIFICATION_CODE_EPOCH
@ IDENTIFICATION_CODE_STRING
@ CST_CODE_CE_INBOUNDS_GEP
@ CST_CODE_INLINEASM_OLD3
@ CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD
@ CST_CODE_DSO_LOCAL_EQUIVALENT
@ CST_CODE_INLINEASM_OLD2
@ CST_CODE_CE_GEP_WITH_INRANGE
@ VST_CODE_COMBINED_ENTRY
@ COMDAT_SELECTION_KIND_LARGEST
@ COMDAT_SELECTION_KIND_ANY
@ COMDAT_SELECTION_KIND_SAME_SIZE
@ COMDAT_SELECTION_KIND_EXACT_MATCH
@ COMDAT_SELECTION_KIND_NO_DUPLICATES
@ ATTR_KIND_STACK_PROTECT
@ ATTR_KIND_STACK_PROTECT_STRONG
@ ATTR_KIND_SANITIZE_MEMORY
@ ATTR_KIND_OPTIMIZE_FOR_SIZE
@ ATTR_KIND_INACCESSIBLEMEM_ONLY
@ ATTR_KIND_FNRETTHUNK_EXTERN
@ ATTR_KIND_NO_DIVERGENCE_SOURCE
@ ATTR_KIND_SANITIZE_ADDRESS
@ ATTR_KIND_NO_IMPLICIT_FLOAT
@ ATTR_KIND_DEAD_ON_UNWIND
@ ATTR_KIND_STACK_ALIGNMENT
@ ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY
@ ATTR_KIND_STACK_PROTECT_REQ
@ ATTR_KIND_NULL_POINTER_IS_VALID
@ ATTR_KIND_SANITIZE_HWADDRESS
@ ATTR_KIND_RETURNS_TWICE
@ ATTR_KIND_SHADOWCALLSTACK
@ ATTR_KIND_OPT_FOR_FUZZING
@ ATTR_KIND_SANITIZE_NUMERICAL_STABILITY
@ ATTR_KIND_ALLOCATED_POINTER
@ ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION
@ ATTR_KIND_CORO_ELIDE_SAFE
@ ATTR_KIND_NON_LAZY_BIND
@ ATTR_KIND_DEREFERENCEABLE
@ ATTR_KIND_OPTIMIZE_NONE
@ ATTR_KIND_DEREFERENCEABLE_OR_NULL
@ ATTR_KIND_SANITIZE_REALTIME
@ ATTR_KIND_SPECULATIVE_LOAD_HARDENING
@ ATTR_KIND_ALWAYS_INLINE
@ ATTR_KIND_SANITIZE_TYPE
@ ATTR_KIND_PRESPLIT_COROUTINE
@ ATTR_KIND_SANITIZE_ALLOC_TOKEN
@ ATTR_KIND_NO_SANITIZE_COVERAGE
@ ATTR_KIND_DEAD_ON_RETURN
@ ATTR_KIND_SANITIZE_REALTIME_BLOCKING
@ ATTR_KIND_NO_SANITIZE_BOUNDS
@ ATTR_KIND_SANITIZE_MEMTAG
@ ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE
@ ATTR_KIND_SANITIZE_THREAD
@ ATTR_KIND_OPTIMIZE_FOR_DEBUGGING
@ SYNC_SCOPE_NAMES_BLOCK_ID
@ PARAMATTR_GROUP_BLOCK_ID
@ IDENTIFICATION_BLOCK_ID
@ GLOBALVAL_SUMMARY_BLOCK_ID
@ FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID
@ OPERAND_BUNDLE_TAGS_BLOCK_ID
@ BLOCKINFO_BLOCK_ID
BLOCKINFO_BLOCK is used to define metadata about blocks, for example, standard abbrevs that should be...
@ MODULE_CODE_SOURCE_FILENAME
@ MODULE_CODE_SECTIONNAME
@ FUNC_CODE_INST_ATOMICRMW_OLD
@ FUNC_CODE_INST_CATCHRET
@ FUNC_CODE_INST_LANDINGPAD
@ FUNC_CODE_INST_EXTRACTVAL
@ FUNC_CODE_INST_CATCHPAD
@ FUNC_CODE_INST_CATCHSWITCH
@ FUNC_CODE_INST_INBOUNDS_GEP_OLD
@ FUNC_CODE_INST_STOREATOMIC_OLD
@ FUNC_CODE_INST_CLEANUPRET
@ FUNC_CODE_INST_LANDINGPAD_OLD
@ FUNC_CODE_DEBUG_RECORD_VALUE
@ FUNC_CODE_INST_LOADATOMIC
@ FUNC_CODE_DEBUG_RECORD_ASSIGN
@ FUNC_CODE_INST_STOREATOMIC
@ FUNC_CODE_INST_ATOMICRMW
@ FUNC_CODE_DEBUG_LOC_AGAIN
@ FUNC_CODE_INST_EXTRACTELT
@ FUNC_CODE_INST_INDIRECTBR
@ FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE
@ FUNC_CODE_INST_INSERTVAL
@ FUNC_CODE_DECLAREBLOCKS
@ FUNC_CODE_DEBUG_RECORD_LABEL
@ FUNC_CODE_INST_INSERTELT
@ FUNC_CODE_BLOCKADDR_USERS
@ FUNC_CODE_INST_CLEANUPPAD
@ FUNC_CODE_INST_SHUFFLEVEC
@ FUNC_CODE_INST_STORE_OLD
@ FUNC_CODE_INST_UNREACHABLE
@ FUNC_CODE_INST_CMPXCHG_OLD
@ FUNC_CODE_DEBUG_RECORD_DECLARE
@ FUNC_CODE_OPERAND_BUNDLE
@ PARAMATTR_CODE_ENTRY_OLD
@ PARAMATTR_GRP_CODE_ENTRY
initializer< Ty > init(const Ty &Val)
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
NodeAddr< FuncNode * > Func
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
FunctionAddr VTableAddr Value
LLVM_ABI void UpgradeIntrinsicCall(CallBase *CB, Function *NewFn)
This is the complement to the above, replacing a specific call to an intrinsic function with a call t...
StringMapEntry< Value * > ValueName
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
LLVM_ABI const std::error_category & BitcodeErrorCategory()
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.
LLVM_ABI Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, ParserCallbacks Callbacks={})
Read the specified bitcode file, returning the module.
LLVM_ABI unsigned getBranchWeightOffset(const MDNode *ProfileData)
Return the offset to the first branch weight data.
LLVM_ABI void UpgradeInlineAsmString(std::string *AsmStr)
Upgrade comment in call to inline asm that represents an objc retain release marker.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
std::error_code make_error_code(BitcodeError E)
LLVM_ABI bool stripDebugInfo(Function &F)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI Expected< bool > isBitcodeContainingObjCCategory(MemoryBufferRef Buffer)
Return true if Buffer contains a bitcode file with ObjC code (category or class) in it.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
LLVM_ABI bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn, bool CanUpgradeDebugIntrinsicsToRecords=true)
This is a more granular function that simply checks an intrinsic function for upgrading,...
LLVM_ABI void UpgradeAttributes(AttrBuilder &B)
Upgrade attributes that changed format or kind.
LLVM_ABI Expected< std::string > getBitcodeTargetTriple(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the triple information.
LLVM_ABI std::unique_ptr< Module > parseModule(const uint8_t *Data, size_t Size, LLVMContext &Context)
Fuzzer friendly interface for the llvm bitcode parser.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
LLVM_ABI Expected< BitcodeFileContents > getBitcodeFileContents(MemoryBufferRef Buffer)
Returns the contents of a bitcode file.
LLVM_ABI void UpgradeNVVMAnnotations(Module &M)
Convert legacy nvvm.annotations metadata to appropriate function attributes.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
auto cast_or_null(const Y &Val)
LLVM_ABI bool UpgradeModuleFlags(Module &M)
This checks for module flags which should be upgraded.
MemoryEffectsBase< IRMemLocation > MemoryEffects
Summary of how a function affects memory in the program.
auto uninitialized_copy(R &&Src, IterTy Dst)
LLVM_ABI Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
LLVM_ABI void UpgradeOperandBundles(std::vector< OperandBundleDef > &OperandBundles)
Upgrade operand bundles (without knowing about their user instruction).
LLVM_ABI Constant * UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy)
This is an auto-upgrade for bitcast constant expression between pointers with different address space...
LLVM_ABI Expected< std::unique_ptr< ModuleSummaryIndex > > getModuleSummaryIndex(MemoryBufferRef Buffer)
Parse the specified bitcode buffer, returning the module summary index.
auto dyn_cast_or_null(const Y &Val)
OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F)
Wrapper function around std::transform to apply a function to a range and store the result elsewhere.
FunctionAddr VTableAddr uintptr_t uintptr_t Version
LLVM_ABI Expected< std::string > getBitcodeProducerString(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the producer string information.
auto reverse(ContainerTy &&C)
LLVM_ABI Expected< std::unique_ptr< Module > > getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata=false, bool IsImporting=false, ParserCallbacks Callbacks={})
Read the header of the specified bitcode buffer and prepare for lazy deserialization of function bodi...
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
detail::ValueMatchesPoly< M > HasValue(M Matcher)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI std::string UpgradeDataLayoutString(StringRef DL, StringRef Triple)
Upgrade the datalayout string by adding a section for address space pointers.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
LLVM_ABI Expected< BitcodeLTOInfo > getBitcodeLTOInfo(MemoryBufferRef Buffer)
Returns LTO information for the specified bitcode file.
BumpPtrAllocatorImpl BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
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...
LLVM_ABI GlobalVariable * UpgradeGlobalVariable(GlobalVariable *GV)
This checks for global variables which should be upgraded.
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
LLVM_ABI bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
AtomicOrdering
Atomic ordering for LLVM's memory model.
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
@ ArgMem
Access to memory via argument pointers.
@ InaccessibleMem
Memory that is inaccessible via LLVM IR.
LLVM_ABI Instruction * UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy, Instruction *&Temp)
This is an auto-upgrade for bitcast between pointers with different address spaces: the instruction i...
MaybeAlign decodeMaybeAlign(unsigned Value)
Dual operation of the encode function above.
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
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.
bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr, const unsigned char *&BufEnd, bool VerifyBufferSize)
SkipBitcodeWrapperHeader - Some systems wrap bc files with a special header for padding or other reas...
bool isBitcodeWrapper(const unsigned char *BufPtr, const unsigned char *BufEnd)
isBitcodeWrapper - Return true if the given bytes are the magic bytes for an LLVM IR bitcode wrapper.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
gep_type_iterator gep_type_begin(const User *GEP)
LLVM_ABI APInt readWideAPInt(ArrayRef< uint64_t > Vals, unsigned TypeBits)
LLVM_ABI Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
LLVM_ABI bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
LLVM_ABI void UpgradeFunctionAttributes(Function &F)
Correct any IR that is relying on old function attribute behavior.
std::vector< TypeIdOffsetVtableInfo > TypeIdCompatibleVtableInfo
List of vtable definitions decorated by a particular type identifier, and their corresponding offsets...
LLVM_ABI Error readModuleSummaryIndex(MemoryBufferRef Buffer, ModuleSummaryIndex &CombinedIndex)
Parse the specified bitcode buffer and merge the index into CombinedIndex.
LLVM_ABI void UpgradeARCRuntime(Module &M)
Convert calls to ARC runtime functions to intrinsic calls and upgrade the old retain release marker t...
LLVM_ABI Expected< std::unique_ptr< ModuleSummaryIndex > > getModuleSummaryIndexForFile(StringRef Path, bool IgnoreEmptyThinLTOIndexFile=false)
Parse the module summary index out of an IR file and return the module summary index object if found,...
LLVM_ABI Expected< std::unique_ptr< Module > > getOwningLazyBitcodeModule(std::unique_ptr< MemoryBuffer > &&Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata=false, bool IsImporting=false, ParserCallbacks Callbacks={})
Like getLazyBitcodeModule, except that the module takes ownership of the memory buffer if successful.
LLVM_ABI std::error_code errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err)
Implement std::hash so that hash_code can be used in STL containers.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Basic information extracted from a bitcode module to be used for LTO.
static Bitfield::Type get(StorageType Packed)
Unpacks the field from the Packed value.
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...
static constexpr unsigned RelBlockFreqBits
The value stored in RelBlockFreq has to be interpreted as the digits of a scaled number with a scale ...
Flags specific to function summaries.
std::vector< Call > Calls
In the per-module summary, it summarizes the byte offset applied to each pointer parameter before pas...
ConstantRange Use
The range contains byte offsets from the parameter pointer which accessed by the function.
static constexpr uint32_t RangeWidth
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
static LLVM_ABI const char * BranchWeights
std::optional< ValueTypeCallbackTy > ValueType
The ValueType callback is called for every function definition or declaration and allows accessing th...
std::optional< DataLayoutCallbackFuncTy > DataLayout
std::optional< MDTypeCallbackTy > MDType
The MDType callback is called for every value in metadata.
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
Kind
Specifies which kind of type check we should emit for this byte array.
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
enum llvm::TypeTestResolution::Kind TheKind
ValID - Represents a reference of a definition of some sort with no type.
enum llvm::WholeProgramDevirtResolution::Kind TheKind
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
std::string SingleImplName