73 "Can't read textual IR with a Context that discards named Values");
76 if (parseTargetDefinitions(DataLayoutCallback))
86 restoreParsingState(Slots);
90 if (parseType(Ty) || parseConstantValue(Ty,
C))
93 return error(Lex.
getLoc(),
"expected end of string");
99 restoreParsingState(Slots);
108 Read =
End.getPointer() - Start.getPointer();
113void LLParser::restoreParsingState(
const SlotMapping *Slots) {
120 std::make_pair(
I.getKey(), std::make_pair(
I.second,
LocTy())));
121 for (
const auto &
I : Slots->
Types)
122 NumberedTypes.insert(
123 std::make_pair(
I.first, std::make_pair(
I.second,
LocTy())));
132 for (
const auto &RAG : ForwardRefAttrGroups) {
133 Value *V = RAG.first;
134 const std::vector<unsigned> &Attrs = RAG.second;
137 for (
const auto &Attr : Attrs) {
138 auto R = NumberedAttrBuilders.find(Attr);
139 if (R != NumberedAttrBuilders.end())
143 if (
Function *Fn = dyn_cast<Function>(V)) {
153 Fn->setAlignment(*
A);
158 Fn->setAttributes(AS);
159 }
else if (
CallInst *CI = dyn_cast<CallInst>(V)) {
165 CI->setAttributes(AS);
166 }
else if (
InvokeInst *II = dyn_cast<InvokeInst>(V)) {
172 II->setAttributes(AS);
173 }
else if (
CallBrInst *CBI = dyn_cast<CallBrInst>(V)) {
179 CBI->setAttributes(AS);
180 }
else if (
auto *GV = dyn_cast<GlobalVariable>(V)) {
191 if (!ForwardRefBlockAddresses.empty())
192 return error(ForwardRefBlockAddresses.begin()->first.Loc,
193 "expected function name in blockaddress");
195 auto ResolveForwardRefDSOLocalEquivalents = [&](
const ValID &GVRef,
200 }
else if (GVRef.
UIntVal < NumberedVals.size()) {
201 GV = dyn_cast<GlobalValue>(NumberedVals[GVRef.
UIntVal]);
206 "' referenced by dso_local_equivalent");
210 "expected a function, alias to function, or ifunc "
211 "in dso_local_equivalent");
214 FwdRef->replaceAllUsesWith(Equiv);
215 FwdRef->eraseFromParent();
222 for (
auto &Iter : ForwardRefDSOLocalEquivalentIDs) {
223 if (ResolveForwardRefDSOLocalEquivalents(Iter.first, Iter.second))
226 for (
auto &Iter : ForwardRefDSOLocalEquivalentNames) {
227 if (ResolveForwardRefDSOLocalEquivalents(Iter.first, Iter.second))
230 ForwardRefDSOLocalEquivalentIDs.clear();
231 ForwardRefDSOLocalEquivalentNames.clear();
233 for (
const auto &NT : NumberedTypes)
234 if (
NT.second.second.isValid())
236 "use of undefined type '%" +
Twine(
NT.first) +
"'");
238 for (
StringMap<std::pair<Type*, LocTy> >::iterator
I =
239 NamedTypes.begin(),
E = NamedTypes.end();
I !=
E; ++
I)
240 if (
I->second.second.isValid())
241 return error(
I->second.second,
242 "use of undefined type named '" +
I->getKey() +
"'");
244 if (!ForwardRefComdats.empty())
245 return error(ForwardRefComdats.begin()->second,
246 "use of undefined comdat '$" +
247 ForwardRefComdats.begin()->first +
"'");
249 if (!ForwardRefVals.empty())
250 return error(ForwardRefVals.begin()->second.second,
251 "use of undefined value '@" + ForwardRefVals.begin()->first +
254 if (!ForwardRefValIDs.empty())
255 return error(ForwardRefValIDs.begin()->second.second,
256 "use of undefined value '@" +
257 Twine(ForwardRefValIDs.begin()->first) +
"'");
259 if (!ForwardRefMDNodes.empty())
260 return error(ForwardRefMDNodes.begin()->second.second,
261 "use of undefined metadata '!" +
262 Twine(ForwardRefMDNodes.begin()->first) +
"'");
265 for (
auto &
N : NumberedMetadata) {
266 if (
N.second && !
N.second->isResolved())
267 N.second->resolveCycles();
270 for (
auto *Inst : InstsWithTBAATag) {
271 MDNode *MD = Inst->getMetadata(LLVMContext::MD_tbaa);
272 assert(MD &&
"UpgradeInstWithTBAATag should have a TBAA tag");
274 if (MD != UpgradedMD)
275 Inst->setMetadata(LLVMContext::MD_tbaa, UpgradedMD);
283 if (UpgradeDebugInfo)
296 for (
const auto &
I : NamedTypes)
297 Slots->
NamedTypes.insert(std::make_pair(
I.getKey(),
I.second.first));
298 for (
const auto &
I : NumberedTypes)
299 Slots->
Types.insert(std::make_pair(
I.first,
I.second.first));
305bool LLParser::validateEndOfIndex() {
309 if (!ForwardRefValueInfos.empty())
310 return error(ForwardRefValueInfos.begin()->second.front().second,
311 "use of undefined summary '^" +
312 Twine(ForwardRefValueInfos.begin()->first) +
"'");
314 if (!ForwardRefAliasees.empty())
315 return error(ForwardRefAliasees.begin()->second.front().second,
316 "use of undefined summary '^" +
317 Twine(ForwardRefAliasees.begin()->first) +
"'");
319 if (!ForwardRefTypeIds.empty())
320 return error(ForwardRefTypeIds.begin()->second.front().second,
321 "use of undefined type id summary '^" +
322 Twine(ForwardRefTypeIds.begin()->first) +
"'");
343 if (parseTargetDefinition(TentativeDLStr, DLStrLoc))
347 if (parseSourceFileName())
356 if (
auto LayoutOverride =
358 TentativeDLStr = *LayoutOverride;
368bool LLParser::parseTopLevelEntities() {
376 if (parseSummaryEntry())
380 if (parseSourceFileName())
392 return tokError(
"expected top-level entity");
403 if (parseModuleAsm())
407 if (parseUnnamedType())
411 if (parseNamedType())
415 if (parseUnnamedGlobal())
419 if (parseNamedGlobal())
424 if (parseStandaloneMetadata())
428 if (parseSummaryEntry())
432 if (parseNamedMetadata())
436 if (parseUnnamedAttrGrp())
440 if (parseUseListOrder())
444 if (parseUseListOrderBB())
453bool LLParser::parseModuleAsm() {
459 parseStringConstant(AsmStr))
469bool LLParser::parseTargetDefinition(std::string &TentativeDLStr,
475 return tokError(
"unknown target property");
478 if (parseToken(
lltok::equal,
"expected '=' after target triple") ||
479 parseStringConstant(Str))
485 if (parseToken(
lltok::equal,
"expected '=' after target datalayout"))
488 if (parseStringConstant(TentativeDLStr))
496bool LLParser::parseSourceFileName() {
499 if (parseToken(
lltok::equal,
"expected '=' after source_filename") ||
500 parseStringConstant(SourceFileName))
509bool LLParser::parseUnnamedType() {
514 if (parseToken(
lltok::equal,
"expected '=' after name") ||
519 if (parseStructDefinition(TypeLoc,
"", NumberedTypes[
TypeID], Result))
522 if (!isa<StructType>(Result)) {
523 std::pair<Type*, LocTy> &Entry = NumberedTypes[
TypeID];
525 return error(TypeLoc,
"non-struct types may not be recursive");
527 Entry.second =
SMLoc();
535bool LLParser::parseNamedType() {
540 if (parseToken(
lltok::equal,
"expected '=' after name") ||
545 if (parseStructDefinition(NameLoc,
Name, NamedTypes[
Name], Result))
548 if (!isa<StructType>(Result)) {
549 std::pair<Type*, LocTy> &Entry = NamedTypes[
Name];
551 return error(NameLoc,
"non-struct types may not be recursive");
553 Entry.second =
SMLoc();
561bool LLParser::parseDeclare() {
565 std::vector<std::pair<unsigned, MDNode *>> MDs;
569 if (parseMetadataAttachment(MDK,
N))
571 MDs.push_back({MDK,
N});
575 if (parseFunctionHeader(
F,
false))
578 F->addMetadata(MD.first, *MD.second);
584bool LLParser::parseDefine() {
589 return parseFunctionHeader(
F,
true) || parseOptionalFunctionMetadata(*
F) ||
590 parseFunctionBody(*
F);
596bool LLParser::parseGlobalType(
bool &IsConstant) {
603 return tokError(
"expected 'global' or 'constant'");
609bool LLParser::parseOptionalUnnamedAddr(
630bool LLParser::parseUnnamedGlobal() {
631 unsigned VarID = NumberedVals.size();
639 "variable expected to be numbered '%" +
Twine(VarID) +
"'");
642 if (parseToken(
lltok::equal,
"expected '=' after name"))
647 unsigned Linkage, Visibility, DLLStorageClass;
651 if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
653 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
658 return parseGlobal(
Name, NameLoc, Linkage, HasLinkage, Visibility,
659 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
662 return parseAliasOrIFunc(
Name, NameLoc, Linkage, Visibility,
663 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
672bool LLParser::parseNamedGlobal() {
679 unsigned Linkage, Visibility, DLLStorageClass;
683 if (parseToken(
lltok::equal,
"expected '=' in global variable") ||
684 parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
686 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
691 return parseGlobal(
Name, NameLoc, Linkage, HasLinkage, Visibility,
692 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
695 return parseAliasOrIFunc(
Name, NameLoc, Linkage, Visibility,
696 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
700bool LLParser::parseComdat() {
710 return tokError(
"expected comdat type");
715 return tokError(
"unknown selection kind");
737 if (
I != ComdatSymTab.
end() && !ForwardRefComdats.erase(
Name))
738 return error(NameLoc,
"redefinition of comdat '$" +
Name +
"'");
741 if (
I != ComdatSymTab.
end())
745 C->setSelectionKind(SK);
752bool LLParser::parseMDString(
MDString *&Result) {
754 if (parseStringConstant(Str))
762bool LLParser::parseMDNodeID(
MDNode *&Result) {
766 if (parseUInt32(MID))
770 if (NumberedMetadata.count(MID)) {
771 Result = NumberedMetadata[MID];
776 auto &FwdRef = ForwardRefMDNodes[MID];
779 Result = FwdRef.first.get();
780 NumberedMetadata[MID].reset(Result);
786bool LLParser::parseNamedMetadata() {
805 if (parseDIExpression(
N,
false))
811 return tokError(
"found DIArgList outside of function");
819 return parseToken(
lltok::rbrace,
"expected end of metadata node");
824bool LLParser::parseStandaloneMetadata() {
827 unsigned MetadataID = 0;
830 if (parseUInt32(MetadataID) || parseToken(
lltok::equal,
"expected '=' here"))
835 return tokError(
"unexpected type in metadata definition");
839 if (parseSpecializedMDNode(
Init, IsDistinct))
842 parseMDTuple(
Init, IsDistinct))
846 auto FI = ForwardRefMDNodes.find(MetadataID);
847 if (FI != ForwardRefMDNodes.end()) {
848 auto *ToReplace = FI->second.first.get();
851 if (isa<DIAssignID>(
Init)) {
852 for (
auto *Inst : TempDIAssignIDAttachments[ToReplace]) {
853 assert(!Inst->getMetadata(LLVMContext::MD_DIAssignID) &&
854 "Inst unexpectedly already has DIAssignID attachment");
855 Inst->setMetadata(LLVMContext::MD_DIAssignID,
Init);
859 ToReplace->replaceAllUsesWith(
Init);
860 ForwardRefMDNodes.erase(FI);
862 assert(NumberedMetadata[MetadataID] ==
Init &&
"Tracking VH didn't work");
864 if (NumberedMetadata.count(MetadataID))
865 return tokError(
"Metadata id is already used");
866 NumberedMetadata[MetadataID].reset(
Init);
873bool LLParser::skipModuleSummaryEntry() {
883 "Expected 'gv', 'module', 'typeid', 'flags' or 'blockcount' at the "
884 "start of summary entry");
886 return parseSummaryIndexFlags();
888 return parseBlockCount();
890 if (parseToken(
lltok::colon,
"expected ':' at start of summary entry") ||
891 parseToken(
lltok::lparen,
"expected '(' at start of summary entry"))
895 unsigned NumOpenParen = 1;
905 return tokError(
"found end of file while parsing summary entry");
911 }
while (NumOpenParen > 0);
917bool LLParser::parseSummaryEntry() {
931 return skipModuleSummaryEntry();
936 result = parseGVEntry(SummaryID);
939 result = parseModuleEntry(SummaryID);
942 result = parseTypeIdEntry(SummaryID);
945 result = parseTypeIdCompatibleVtableEntry(SummaryID);
948 result = parseSummaryIndexFlags();
951 result = parseBlockCount();
954 result =
error(Lex.
getLoc(),
"unexpected summary kind");
979 std::string ErrString;
981 ErrOS << Message <<
" (" << *Ty1 <<
" vs " << *Ty2 <<
")";
999bool LLParser::parseAliasOrIFunc(
const std::string &
Name, LocTy NameLoc,
1000 unsigned L,
unsigned Visibility,
1001 unsigned DLLStorageClass,
bool DSOLocal,
1016 return error(NameLoc,
"invalid linkage type for alias");
1019 return error(NameLoc,
1020 "symbol with local linkage must have default visibility");
1023 return error(NameLoc,
1024 "symbol with local linkage cannot have a DLL storage class");
1028 if (parseType(Ty) ||
1029 parseToken(
lltok::comma,
"expected comma after alias or ifunc's type"))
1038 if (parseGlobalTypeAndValue(Aliasee))
1043 if (parseValID(
ID,
nullptr))
1046 return error(AliaseeLoc,
"invalid aliasee");
1047 Aliasee =
ID.ConstantVal;
1051 auto *PTy = dyn_cast<PointerType>(AliaseeType);
1053 return error(AliaseeLoc,
"An alias or ifunc must have pointer type");
1054 unsigned AddrSpace = PTy->getAddressSpace();
1057 if (!PTy->isOpaqueOrPointeeTypeMatches(Ty))
1061 "explicit pointee type doesn't match operand's pointee type", Ty,
1062 PTy->getNonOpaquePointerElementType()));
1064 if (!PTy->isOpaque() &&
1065 !PTy->getNonOpaquePointerElementType()->isFunctionTy())
1066 return error(ExplicitTypeLoc,
1067 "explicit pointee type should be a function type");
1074 if (!
Name.empty()) {
1075 auto I = ForwardRefVals.find(
Name);
1076 if (
I != ForwardRefVals.end()) {
1077 GVal =
I->second.first;
1078 ForwardRefVals.erase(
Name);
1080 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1083 auto I = ForwardRefValIDs.find(NumberedVals.size());
1084 if (
I != ForwardRefValIDs.end()) {
1085 GVal =
I->second.first;
1086 ForwardRefValIDs.erase(
I);
1091 std::unique_ptr<GlobalAlias> GA;
1092 std::unique_ptr<GlobalIFunc> GI;
1122 return tokError(
"unknown alias or ifunc property!");
1127 NumberedVals.push_back(GV);
1134 "forward reference and definition of alias have different types");
1156 case lltok::kw_sanitize_memtag:
1172 Meta.NoAddress =
true;
1175 Meta.NoHWAddress =
true;
1177 case lltok::kw_sanitize_memtag:
1181 Meta.IsDynInit =
true;
1184 return tokError(
"non-sanitizer token passed to LLParser::parseSanitizer()");
1204bool LLParser::parseGlobal(
const std::string &
Name, LocTy NameLoc,
1205 unsigned Linkage,
bool HasLinkage,
1206 unsigned Visibility,
unsigned DLLStorageClass,
1210 return error(NameLoc,
1211 "symbol with local linkage must have default visibility");
1214 return error(NameLoc,
1215 "symbol with local linkage cannot have a DLL storage class");
1219 LocTy IsExternallyInitializedLoc;
1223 if (parseOptionalAddrSpace(AddrSpace) ||
1225 IsExternallyInitialized,
1226 &IsExternallyInitializedLoc) ||
1227 parseGlobalType(IsConstant) || parseType(Ty, TyLoc))
1236 if (parseGlobalValue(Ty,
Init))
1241 return error(TyLoc,
"invalid type for global variable");
1246 if (!
Name.empty()) {
1247 auto I = ForwardRefVals.find(
Name);
1248 if (
I != ForwardRefVals.end()) {
1249 GVal =
I->second.first;
1250 ForwardRefVals.erase(
I);
1252 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1255 auto I = ForwardRefValIDs.find(NumberedVals.size());
1256 if (
I != ForwardRefValIDs.end()) {
1257 GVal =
I->second.first;
1258 ForwardRefValIDs.erase(
I);
1267 NumberedVals.push_back(GV);
1285 "forward reference and definition of global have different types");
1305 }
else if (Lex.
getKind() == lltok::kw_align) {
1307 if (parseOptionalAlignment(Alignment))
1312 if (parseGlobalObjectMetadataAttachment(*GV))
1315 if (parseSanitizer(GV))
1319 if (parseOptionalComdat(
Name,
C))
1324 return tokError(
"unknown global variable property!");
1330 std::vector<unsigned> FwdRefAttrGrps;
1331 if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps,
false, BuiltinLoc))
1333 if (
Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
1335 ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
1343bool LLParser::parseUnnamedAttrGrp() {
1349 return tokError(
"expected attribute group id");
1352 std::vector<unsigned> unused;
1360 auto R = NumberedAttrBuilders.find(VarID);
1361 if (R == NumberedAttrBuilders.end())
1364 if (parseFnAttributeValuePairs(
R->second, unused,
true, BuiltinLoc) ||
1365 parseToken(
lltok::rbrace,
"expected end of attribute group"))
1368 if (!
R->second.hasAttributes())
1369 return error(AttrGrpLoc,
"attribute group has no attributes");
1376#define GET_ATTR_NAMES
1377#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
1378 case lltok::kw_##DISPLAY_NAME: \
1379 return Attribute::ENUM_NAME;
1380#include "llvm/IR/Attributes.inc"
1389 return parseRequiredTypeAttr(
B, Lex.
getKind(), Attr);
1392 case Attribute::Alignment: {
1401 if (parseOptionalAlignment(Alignment,
true))
1404 B.addAlignmentAttr(Alignment);
1407 case Attribute::StackAlignment: {
1412 parseUInt32(Alignment))
1415 if (parseOptionalStackAlignment(Alignment))
1418 B.addStackAlignmentAttr(Alignment);
1421 case Attribute::AllocSize: {
1422 unsigned ElemSizeArg;
1423 std::optional<unsigned> NumElemsArg;
1424 if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
1426 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1429 case Attribute::VScaleRange: {
1430 unsigned MinValue, MaxValue;
1431 if (parseVScaleRangeArguments(MinValue, MaxValue))
1433 B.addVScaleRangeAttr(MinValue,
1434 MaxValue > 0 ? MaxValue : std::optional<unsigned>());
1437 case Attribute::Dereferenceable: {
1439 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1441 B.addDereferenceableAttr(Bytes);
1444 case Attribute::DereferenceableOrNull: {
1446 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1448 B.addDereferenceableOrNullAttr(Bytes);
1451 case Attribute::UWTable: {
1453 if (parseOptionalUWTableKind(Kind))
1455 B.addUWTableAttr(Kind);
1458 case Attribute::AllocKind: {
1460 if (parseAllocKind(Kind))
1462 B.addAllocKindAttr(Kind);
1465 case Attribute::Memory: {
1466 std::optional<MemoryEffects> ME = parseMemoryAttr();
1469 B.addMemoryAttr(*ME);
1472 case Attribute::NoFPClass: {
1475 B.addNoFPClassAttr(NoFPClass);
1482 B.addAttribute(Attr);
1490 case lltok::kw_readnone:
1493 case lltok::kw_readonly:
1496 case lltok::kw_writeonly:
1515bool LLParser::parseFnAttributeValuePairs(
AttrBuilder &
B,
1516 std::vector<unsigned> &FwdRefAttrGrps,
1517 bool InAttrGrp, LocTy &BuiltinLoc) {
1518 bool HaveError =
false;
1529 if (parseStringAttribute(
B))
1541 "cannot have an attribute group reference in an attribute group");
1551 if (Token == lltok::kw_builtin)
1563 return error(Lex.
getLoc(),
"unterminated attribute group");
1566 if (parseEnumAttribute(Attr,
B, InAttrGrp))
1573 HaveError |=
error(Loc,
"this attribute does not apply to functions");
1577 B.addMemoryAttr(ME);
1588 if (PTy->isOpaque())
1592 PTy->getAddressSpace());
1594 Type *ElemTy = PTy->getNonOpaquePointerElementType();
1595 if (
auto *FT = dyn_cast<FunctionType>(ElemTy))
1597 PTy->getAddressSpace(),
"", M);
1610 error(Loc,
"'" +
Name +
"' is not a basic block");
1612 error(Loc,
"'" +
Name +
"' defined with type '" +
1625 error(Loc,
"global variable reference must have pointer type");
1636 auto I = ForwardRefVals.find(
Name);
1637 if (
I != ForwardRefVals.end())
1638 Val =
I->second.first;
1643 return cast_or_null<GlobalValue>(
1644 checkValidVariableType(Loc,
"@" +
Name, Ty, Val));
1648 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
1655 error(Loc,
"global variable reference must have pointer type");
1659 GlobalValue *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
1664 auto I = ForwardRefValIDs.find(
ID);
1665 if (
I != ForwardRefValIDs.end())
1666 Val =
I->second.first;
1671 return cast_or_null<GlobalValue>(
1672 checkValidVariableType(Loc,
"@" +
Twine(
ID), Ty, Val));
1676 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
1684Comdat *LLParser::getComdat(
const std::string &
Name, LocTy Loc) {
1688 if (
I != ComdatSymTab.
end())
1693 ForwardRefComdats[
Name] = Loc;
1703bool LLParser::parseToken(
lltok::Kind T,
const char *ErrMsg) {
1705 return tokError(ErrMsg);
1712bool LLParser::parseStringConstant(std::string &Result) {
1714 return tokError(
"expected string constant");
1722bool LLParser::parseUInt32(
uint32_t &Val) {
1724 return tokError(
"expected integer");
1726 if (Val64 !=
unsigned(Val64))
1727 return tokError(
"expected 32-bit integer (too large)");
1735bool LLParser::parseUInt64(
uint64_t &Val) {
1737 return tokError(
"expected integer");
1750 return tokError(
"expected localdynamic, initialexec or localexec");
1778 return parseTLSModel(TLM) ||
1779 parseToken(
lltok::rparen,
"expected ')' after thread local model");
1787bool LLParser::parseOptionalAddrSpace(
unsigned &AddrSpace,
unsigned DefaultAS) {
1788 AddrSpace = DefaultAS;
1792 auto ParseAddrspaceValue = [&](
unsigned &AddrSpace) ->
bool {
1795 if (AddrSpaceStr ==
"A") {
1797 }
else if (AddrSpaceStr ==
"G") {
1799 }
else if (AddrSpaceStr ==
"P") {
1802 return tokError(
"invalid symbolic addrspace '" + AddrSpaceStr +
"'");
1808 return tokError(
"expected integer or string constant");
1810 if (parseUInt32(AddrSpace))
1812 if (!isUInt<24>(AddrSpace))
1813 return error(Loc,
"invalid address space, must be a 24-bit integer");
1817 return parseToken(
lltok::lparen,
"expected '(' in address space") ||
1818 ParseAddrspaceValue(AddrSpace) ||
1829 if (EatIfPresent(
lltok::equal) && parseStringConstant(Val))
1831 B.addAttribute(Attr, Val);
1836bool LLParser::parseOptionalParamOrReturnAttrs(
AttrBuilder &
B,
bool IsParam) {
1837 bool HaveError =
false;
1844 if (parseStringAttribute(
B))
1854 if (parseEnumAttribute(Attr,
B,
false))
1858 HaveError |=
error(Loc,
"this attribute does not apply to parameters");
1860 HaveError |=
error(Loc,
"this attribute does not apply to return values");
1908bool LLParser::parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
1909 unsigned &Visibility,
1910 unsigned &DLLStorageClass,
bool &DSOLocal) {
1914 parseOptionalDSOLocal(DSOLocal);
1915 parseOptionalVisibility(Visibility);
1916 parseOptionalDLLStorageClass(DLLStorageClass);
1919 return error(Lex.
getLoc(),
"dso_location and DLL-StorageClass mismatch");
1925void LLParser::parseOptionalDSOLocal(
bool &DSOLocal) {
1947void LLParser::parseOptionalVisibility(
unsigned &Res) {
1970void LLParser::parseOptionalDLLStorageClass(
unsigned &Res) {
2034bool LLParser::parseOptionalCallingConv(
unsigned &
CC) {
2096 return parseUInt32(
CC);
2106bool LLParser::parseMetadataAttachment(
unsigned &Kind,
MDNode *&MD) {
2113 return parseMDNode(MD);
2118bool LLParser::parseInstructionMetadata(
Instruction &Inst) {
2121 return tokError(
"expected metadata after comma");
2125 if (parseMetadataAttachment(MDK,
N))
2128 if (MDK == LLVMContext::MD_DIAssignID)
2129 TempDIAssignIDAttachments[
N].push_back(&Inst);
2133 if (MDK == LLVMContext::MD_tbaa)
2134 InstsWithTBAATag.push_back(&Inst);
2143bool LLParser::parseGlobalObjectMetadataAttachment(
GlobalObject &GO) {
2146 if (parseMetadataAttachment(MDK,
N))
2155bool LLParser::parseOptionalFunctionMetadata(
Function &
F) {
2157 if (parseGlobalObjectMetadataAttachment(
F))
2165bool LLParser::parseOptionalAlignment(
MaybeAlign &Alignment,
bool AllowParens) {
2166 Alignment = std::nullopt;
2167 if (!EatIfPresent(lltok::kw_align))
2173 bool HaveParens =
false;
2179 if (parseUInt64(
Value))
2183 return error(ParenLoc,
"expected ')'");
2186 return error(AlignLoc,
"alignment is not a power of two");
2188 return error(AlignLoc,
"huge alignments are not supported yet");
2198bool LLParser::parseOptionalDerefAttrBytes(
lltok::Kind AttrKind,
2200 assert((AttrKind == lltok::kw_dereferenceable ||
2201 AttrKind == lltok::kw_dereferenceable_or_null) &&
2205 if (!EatIfPresent(AttrKind))
2209 return error(ParenLoc,
"expected '('");
2211 if (parseUInt64(Bytes))
2215 return error(ParenLoc,
"expected ')'");
2217 return error(DerefLoc,
"dereferenceable bytes must be non-zero");
2221bool LLParser::parseOptionalUWTableKind(
UWTableKind &Kind) {
2232 return error(KindLoc,
"expected unwind table kind");
2241 return error(ParenLoc,
"expected '('");
2244 if (parseStringConstant(
Arg))
2245 return error(KindLoc,
"expected allockind value");
2249 }
else if (
A ==
"realloc") {
2251 }
else if (
A ==
"free") {
2253 }
else if (
A ==
"uninitialized") {
2255 }
else if (
A ==
"zeroed") {
2257 }
else if (
A ==
"aligned") {
2260 return error(KindLoc,
Twine(
"unknown allockind ") +
A);
2265 return error(ParenLoc,
"expected ')'");
2267 return error(KindLoc,
"expected allockind value");
2278 return std::nullopt;
2293 return std::nullopt;
2297std::optional<MemoryEffects> LLParser::parseMemoryAttr() {
2307 tokError(
"expected '('");
2308 return std::nullopt;
2311 bool SeenLoc =
false;
2317 tokError(
"expected ':' after location");
2318 return std::nullopt;
2325 tokError(
"expected memory location (argmem, inaccessiblemem) "
2326 "or access kind (none, read, write, readwrite)");
2328 tokError(
"expected access kind (none, read, write, readwrite)");
2329 return std::nullopt;
2338 tokError(
"default access kind must be specified first");
2339 return std::nullopt;
2348 tokError(
"unterminated memory attribute");
2349 return std::nullopt;
2391unsigned LLParser::parseNoFPClassAttr() {
2396 tokError(
"expected '('");
2403 if (TestMask != 0) {
2407 !parseUInt64(
Value)) {
2409 error(Lex.
getLoc(),
"invalid mask value for 'nofpclass'");
2420 error(Lex.
getLoc(),
"expected nofpclass test mask");
2438bool LLParser::parseOptionalCommaAlign(
MaybeAlign &Alignment,
2439 bool &AteExtraComma) {
2440 AteExtraComma =
false;
2444 AteExtraComma =
true;
2448 if (Lex.
getKind() != lltok::kw_align)
2449 return error(Lex.
getLoc(),
"expected metadata or 'align'");
2451 if (parseOptionalAlignment(Alignment))
2464bool LLParser::parseOptionalCommaAddrSpace(
unsigned &AddrSpace, LocTy &Loc,
2465 bool &AteExtraComma) {
2466 AteExtraComma =
false;
2470 AteExtraComma =
true;
2476 return error(Lex.
getLoc(),
"expected metadata or 'addrspace'");
2478 if (parseOptionalAddrSpace(AddrSpace))
2485bool LLParser::parseAllocSizeArguments(
unsigned &BaseSizeArg,
2486 std::optional<unsigned> &HowManyArg) {
2489 auto StartParen = Lex.
getLoc();
2491 return error(StartParen,
"expected '('");
2493 if (parseUInt32(BaseSizeArg))
2497 auto HowManyAt = Lex.
getLoc();
2499 if (parseUInt32(HowMany))
2501 if (HowMany == BaseSizeArg)
2502 return error(HowManyAt,
2503 "'allocsize' indices can't refer to the same parameter");
2504 HowManyArg = HowMany;
2506 HowManyArg = std::nullopt;
2508 auto EndParen = Lex.
getLoc();
2510 return error(EndParen,
"expected ')'");
2514bool LLParser::parseVScaleRangeArguments(
unsigned &MinValue,
2515 unsigned &MaxValue) {
2518 auto StartParen = Lex.
getLoc();
2520 return error(StartParen,
"expected '('");
2522 if (parseUInt32(MinValue))
2526 if (parseUInt32(MaxValue))
2529 MaxValue = MinValue;
2531 auto EndParen = Lex.
getLoc();
2533 return error(EndParen,
"expected ')'");
2542bool LLParser::parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
2547 return parseScope(SSID) || parseOrdering(Ordering);
2557 auto StartParenAt = Lex.
getLoc();
2559 return error(StartParenAt,
"Expected '(' in syncscope");
2562 auto SSNAt = Lex.
getLoc();
2563 if (parseStringConstant(SSN))
2564 return error(SSNAt,
"Expected synchronization scope name");
2566 auto EndParenAt = Lex.
getLoc();
2568 return error(EndParenAt,
"Expected ')' in syncscope");
2583 return tokError(
"Expected ordering on atomic instruction");
2602bool LLParser::parseOptionalStackAlignment(
unsigned &Alignment) {
2604 if (!EatIfPresent(lltok::kw_alignstack))
2608 return error(ParenLoc,
"expected '('");
2610 if (parseUInt32(Alignment))
2614 return error(ParenLoc,
"expected ')'");
2616 return error(AlignLoc,
"stack alignment is not a power of two");
2630 bool &AteExtraComma) {
2631 AteExtraComma =
false;
2634 return tokError(
"expected ',' as start of index list");
2638 if (Indices.
empty())
2639 return tokError(
"expected index");
2640 AteExtraComma =
true;
2644 if (parseUInt32(
Idx))
2657bool LLParser::parseType(
Type *&Result,
const Twine &Msg,
bool AllowVoid) {
2661 return tokError(Msg);
2670 if (
Result->isOpaquePointerTy()) {
2672 if (parseOptionalAddrSpace(AddrSpace))
2678 return tokError(
"ptr* is invalid - use ptr instead");
2689 if (parseTargetExtType(Result))
2695 if (parseAnonStructType(Result,
false))
2701 if (parseArrayVectorType(Result,
false))
2708 if (parseAnonStructType(Result,
true) ||
2709 parseToken(
lltok::greater,
"expected '>' at end of packed struct"))
2711 }
else if (parseArrayVectorType(Result,
true))
2716 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.
getStrVal()];
2722 Entry.second = Lex.
getLoc();
2731 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.
getUIntVal()];
2737 Entry.second = Lex.
getLoc();
2750 if (!AllowVoid &&
Result->isVoidTy())
2751 return error(TypeLoc,
"void type only allowed for function results");
2757 return tokError(
"basic block pointers are invalid");
2759 return tokError(
"pointers to void are invalid - use i8* instead");
2761 return tokError(
"pointer to this type is invalid");
2769 return tokError(
"basic block pointers are invalid");
2771 return tokError(
"pointers to void are invalid; use i8* instead");
2773 return tokError(
"pointer to this type is invalid");
2775 if (parseOptionalAddrSpace(AddrSpace) ||
2776 parseToken(
lltok::star,
"expected '*' in address space"))
2785 if (parseFunctionType(Result))
2798 PerFunctionState &PFS,
bool IsMustTailCall,
2799 bool InVarArgsFunc) {
2805 if (!ArgList.
empty() &&
2806 parseToken(
lltok::comma,
"expected ',' in argument list"))
2811 const char *
Msg =
"unexpected ellipsis in argument list for ";
2812 if (!IsMustTailCall)
2813 return tokError(
Twine(Msg) +
"non-musttail call");
2815 return tokError(
Twine(Msg) +
"musttail call in non-varargs function");
2817 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
2822 Type *ArgTy =
nullptr;
2824 if (parseType(ArgTy, ArgLoc))
2830 if (parseMetadataAsValue(V, PFS))
2834 if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
2841 if (IsMustTailCall && InVarArgsFunc)
2842 return tokError(
"expected '...' at end of argument list for musttail call "
2843 "in varargs function");
2854 if (!EatIfPresent(AttrToken))
2863 B.addTypeAttr(AttrKind, Ty);
2876bool LLParser::parseOptionalOperandBundles(
2884 if (!BundleList.
empty() &&
2885 parseToken(
lltok::comma,
"expected ',' in input list"))
2889 if (parseStringConstant(
Tag))
2892 if (parseToken(
lltok::lparen,
"expected '(' in operand bundle"))
2895 std::vector<Value *> Inputs;
2898 if (!Inputs.empty() &&
2899 parseToken(
lltok::comma,
"expected ',' in input list"))
2903 Value *Input =
nullptr;
2904 if (parseType(Ty) || parseValue(Ty, Input, PFS))
2906 Inputs.push_back(Input);
2914 if (BundleList.
empty())
2915 return error(BeginLoc,
"operand bundle set must not be empty");
2932 unsigned CurValID = 0;
2944 Type *ArgTy =
nullptr;
2948 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2952 return error(TypeLoc,
"argument can not have void type");
2959 return error(TypeLoc,
"argument expected to be numbered '%" +
2960 Twine(CurValID) +
"'");
2966 return error(TypeLoc,
"invalid type for function argument");
2981 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2985 return error(TypeLoc,
"argument can not have void type");
2993 return error(TypeLoc,
"argument expected to be numbered '%" +
2994 Twine(CurValID) +
"'");
3002 return error(TypeLoc,
"invalid type for function argument");
3010 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
3015bool LLParser::parseFunctionType(
Type *&Result) {
3019 return tokError(
"invalid function return type");
3023 if (parseArgumentList(ArgList, IsVarArg))
3027 for (
unsigned i = 0, e = ArgList.
size(); i != e; ++i) {
3028 if (!ArgList[i].
Name.empty())
3029 return error(ArgList[i].Loc,
"argument name invalid in function type");
3030 if (ArgList[i].
Attrs.hasAttributes())
3031 return error(ArgList[i].Loc,
3032 "argument attributes invalid in function type");
3036 for (
unsigned i = 0, e = ArgList.
size(); i != e; ++i)
3045bool LLParser::parseAnonStructType(
Type *&Result,
bool Packed) {
3047 if (parseStructBody(Elts))
3056 std::pair<Type *, LocTy> &Entry,
3059 if (Entry.first && !Entry.second.isValid())
3060 return error(TypeLoc,
"redefinition of type");
3066 Entry.second =
SMLoc();
3071 ResultTy = Entry.first;
3083 return error(TypeLoc,
"forward references to non-struct type");
3087 return parseArrayVectorType(ResultTy,
true);
3088 return parseType(ResultTy);
3092 Entry.second =
SMLoc();
3098 StructType *STy = cast<StructType>(Entry.first);
3101 if (parseStructBody(Body) ||
3102 (isPacked && parseToken(
lltok::greater,
"expected '>' in packed struct")))
3131 return error(EltTyLoc,
"invalid element type for struct");
3139 return error(EltTyLoc,
"invalid element type for struct");
3144 return parseToken(
lltok::rbrace,
"expected '}' at end of struct");
3153bool LLParser::parseArrayVectorType(
Type *&Result,
bool IsVector) {
3154 bool Scalable =
false;
3158 if (parseToken(
lltok::kw_x,
"expected 'x' after vscale"))
3166 return tokError(
"expected number in address space");
3172 if (parseToken(
lltok::kw_x,
"expected 'x' after element count"))
3176 Type *EltTy =
nullptr;
3177 if (parseType(EltTy))
3181 "expected end of sequential type"))
3186 return error(SizeLoc,
"zero element vector is illegal");
3188 return error(SizeLoc,
"size too large for vector");
3190 return error(TypeLoc,
"invalid vector element type");
3194 return error(TypeLoc,
"invalid array element type");
3211bool LLParser::parseTargetExtType(
Type *&Result) {
3216 if (parseToken(
lltok::lparen,
"expected '(' in target extension type") ||
3217 parseStringConstant(TypeName))
3225 bool SeenInt =
false;
3232 if (parseUInt32(IntVal))
3235 }
else if (SeenInt) {
3238 return tokError(
"expected uint32 param");
3241 if (parseType(TypeParam,
true))
3247 if (parseToken(
lltok::rparen,
"expected ')' in target extension type"))
3260 :
P(
p),
F(
f), FunctionNumber(functionNumber) {
3265 NumberedVals.push_back(&
A);
3268LLParser::PerFunctionState::~PerFunctionState() {
3271 for (
const auto &
P : ForwardRefVals) {
3272 if (isa<BasicBlock>(
P.second.first))
3274 P.second.first->replaceAllUsesWith(
3276 P.second.first->deleteValue();
3279 for (
const auto &
P : ForwardRefValIDs) {
3280 if (isa<BasicBlock>(
P.second.first))
3282 P.second.first->replaceAllUsesWith(
3284 P.second.first->deleteValue();
3288bool LLParser::PerFunctionState::finishFunction() {
3289 if (!ForwardRefVals.empty())
3290 return P.error(ForwardRefVals.begin()->second.second,
3291 "use of undefined value '%" + ForwardRefVals.begin()->first +
3293 if (!ForwardRefValIDs.empty())
3294 return P.error(ForwardRefValIDs.begin()->second.second,
3295 "use of undefined value '%" +
3296 Twine(ForwardRefValIDs.begin()->first) +
"'");
3303Value *LLParser::PerFunctionState::getVal(
const std::string &
Name,
Type *Ty,
3306 Value *Val =
F.getValueSymbolTable()->lookup(
Name);
3311 auto I = ForwardRefVals.find(
Name);
3312 if (
I != ForwardRefVals.end())
3313 Val =
I->second.first;
3318 return P.checkValidVariableType(Loc,
"%" +
Name, Ty, Val);
3322 P.error(Loc,
"invalid use of a non-first-class type");
3334 P.error(Loc,
"name is too long which can result in name collisions, "
3335 "consider making the name shorter or "
3336 "increasing -non-global-value-max-name-size");
3340 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
3344Value *LLParser::PerFunctionState::getVal(
unsigned ID,
Type *Ty, LocTy Loc) {
3346 Value *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
3351 auto I = ForwardRefValIDs.find(
ID);
3352 if (
I != ForwardRefValIDs.end())
3353 Val =
I->second.first;
3358 return P.checkValidVariableType(Loc,
"%" +
Twine(
ID), Ty, Val);
3361 P.error(Loc,
"invalid use of a non-first-class type");
3373 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
3379bool LLParser::PerFunctionState::setInstName(
int NameID,
3380 const std::string &NameStr,
3384 if (NameID != -1 || !NameStr.empty())
3385 return P.error(NameLoc,
"instructions returning void cannot have a name");
3391 if (NameStr.empty()) {
3394 NameID = NumberedVals.size();
3396 if (
unsigned(NameID) != NumberedVals.size())
3397 return P.error(NameLoc,
"instruction expected to be numbered '%" +
3398 Twine(NumberedVals.size()) +
"'");
3400 auto FI = ForwardRefValIDs.find(NameID);
3401 if (FI != ForwardRefValIDs.end()) {
3404 return P.error(NameLoc,
"instruction forward referenced with type '" +
3408 Sentinel->replaceAllUsesWith(Inst);
3410 ForwardRefValIDs.erase(FI);
3413 NumberedVals.push_back(Inst);
3418 auto FI = ForwardRefVals.find(NameStr);
3419 if (FI != ForwardRefVals.end()) {
3422 return P.error(NameLoc,
"instruction forward referenced with type '" +
3426 Sentinel->replaceAllUsesWith(Inst);
3428 ForwardRefVals.erase(FI);
3434 if (Inst->
getName() != NameStr)
3435 return P.error(NameLoc,
"multiple definition of local value named '" +
3442BasicBlock *LLParser::PerFunctionState::getBB(
const std::string &
Name,
3444 return dyn_cast_or_null<BasicBlock>(
3448BasicBlock *LLParser::PerFunctionState::getBB(
unsigned ID, LocTy Loc) {
3449 return dyn_cast_or_null<BasicBlock>(
3456BasicBlock *LLParser::PerFunctionState::defineBB(
const std::string &
Name,
3457 int NameID, LocTy Loc) {
3460 if (NameID != -1 &&
unsigned(NameID) != NumberedVals.size()) {
3461 P.error(Loc,
"label expected to be numbered '" +
3462 Twine(NumberedVals.size()) +
"'");
3465 BB = getBB(NumberedVals.size(), Loc);
3467 P.error(Loc,
"unable to create block numbered '" +
3468 Twine(NumberedVals.size()) +
"'");
3472 BB = getBB(
Name, Loc);
3474 P.error(Loc,
"unable to create block named '" +
Name +
"'");
3485 ForwardRefValIDs.erase(NumberedVals.size());
3486 NumberedVals.push_back(BB);
3489 ForwardRefVals.erase(
Name);
3506bool LLParser::parseValID(
ValID &
ID, PerFunctionState *PFS,
Type *ExpectedTy) {
3510 return tokError(
"expected value token");
3553 if (parseGlobalValueVector(Elts) ||
3554 parseToken(
lltok::rbrace,
"expected end of struct constant"))
3557 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.
size());
3558 ID.UIntVal = Elts.
size();
3559 memcpy(
ID.ConstantStructElts.get(), Elts.
data(),
3560 Elts.
size() *
sizeof(Elts[0]));
3572 if (parseGlobalValueVector(Elts) ||
3574 parseToken(
lltok::rbrace,
"expected end of packed struct")) ||
3578 if (isPackedStruct) {
3579 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.
size());
3580 memcpy(
ID.ConstantStructElts.get(), Elts.
data(),
3581 Elts.
size() *
sizeof(Elts[0]));
3582 ID.UIntVal = Elts.
size();
3588 return error(
ID.Loc,
"constant vector must not be empty");
3590 if (!Elts[0]->
getType()->isIntegerTy() &&
3591 !Elts[0]->
getType()->isFloatingPointTy() &&
3592 !Elts[0]->
getType()->isPointerTy())
3595 "vector elements must have integer, pointer or floating point type");
3598 for (
unsigned i = 1, e = Elts.
size(); i != e; ++i)
3600 return error(FirstEltLoc,
"vector element #" +
Twine(i) +
3601 " is not of type '" +
3612 if (parseGlobalValueVector(Elts) ||
3624 if (!Elts[0]->
getType()->isFirstClassType())
3625 return error(FirstEltLoc,
"invalid array element type: " +
3631 for (
unsigned i = 0, e = Elts.
size(); i != e; ++i) {
3633 return error(FirstEltLoc,
"array element #" +
Twine(i) +
3634 " is not of type '" +
3654 bool HasSideEffect, AlignStack, AsmDialect, CanThrow;
3657 parseOptionalToken(lltok::kw_alignstack, AlignStack) ||
3660 parseStringConstant(
ID.StrVal) ||
3661 parseToken(
lltok::comma,
"expected comma in inline asm expression") ||
3666 (
unsigned(AsmDialect) << 2) | (
unsigned(CanThrow) << 3);
3677 if (parseToken(
lltok::lparen,
"expected '(' in block address expression") ||
3678 parseValID(Fn, PFS) ||
3680 "expected comma in block address expression") ||
3681 parseValID(Label, PFS) ||
3682 parseToken(
lltok::rparen,
"expected ')' in block address expression"))
3686 return error(Fn.
Loc,
"expected function name in blockaddress");
3688 return error(
Label.Loc,
"expected basic block name in blockaddress");
3693 if (Fn.
UIntVal < NumberedVals.size())
3694 GV = NumberedVals[Fn.
UIntVal];
3695 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3701 if (!isa<Function>(GV))
3702 return error(Fn.
Loc,
"expected function name in blockaddress");
3703 F = cast<Function>(GV);
3704 if (
F->isDeclaration())
3705 return error(Fn.
Loc,
"cannot take blockaddress inside a declaration");
3711 ForwardRefBlockAddresses.insert(std::make_pair(
3713 std::map<ValID, GlobalValue *>()))
3714 .first->second.insert(std::make_pair(std::move(Label),
nullptr))
3723 "type of blockaddress must be a pointer and not '" +
3728 FwdDeclAS = PFS->getFunction().getAddressSpace();
3737 ID.ConstantVal = FwdRef;
3745 if (BlockAddressPFS &&
F == &BlockAddressPFS->getFunction()) {
3747 BB = BlockAddressPFS->getBB(
Label.UIntVal,
Label.Loc);
3749 BB = BlockAddressPFS->getBB(
Label.StrVal,
Label.Loc);
3751 return error(
Label.Loc,
"referenced value is not a basic block");
3754 return error(
Label.Loc,
"cannot take address of numeric label after "
3755 "the function is defined");
3756 BB = dyn_cast_or_null<BasicBlock>(
3757 F->getValueSymbolTable()->lookup(
Label.StrVal));
3759 return error(
Label.Loc,
"referenced value is not a basic block");
3773 if (parseValID(Fn, PFS))
3778 "expected global value name in dso_local_equivalent");
3783 if (Fn.
UIntVal < NumberedVals.size())
3784 GV = NumberedVals[Fn.
UIntVal];
3785 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3792 ? ForwardRefDSOLocalEquivalentIDs
3793 : ForwardRefDSOLocalEquivalentNames;
3794 GlobalValue *&FwdRef = FwdRefMap.try_emplace(Fn,
nullptr).first->second;
3801 ID.ConstantVal = FwdRef;
3807 return error(Fn.
Loc,
"expected a function, alias to function, or ifunc "
3808 "in dso_local_equivalent");
3819 if (parseValID(
ID, PFS))
3823 return error(
ID.Loc,
"expected global value name in no_cfi");
3843 Type *DestTy =
nullptr;
3846 if (parseToken(
lltok::lparen,
"expected '(' after constantexpr cast") ||
3847 parseGlobalTypeAndValue(SrcVal) ||
3848 parseToken(
lltok::kw_to,
"expected 'to' in constantexpr cast") ||
3849 parseType(DestTy) ||
3850 parseToken(
lltok::rparen,
"expected ')' at end of constantexpr cast"))
3853 return error(
ID.Loc,
"invalid cast opcode for cast from '" +
3862 return error(
ID.Loc,
"extractvalue constexprs are no longer supported");
3864 return error(
ID.Loc,
"insertvalue constexprs are no longer supported");
3866 return error(
ID.Loc,
"udiv constexprs are no longer supported");
3868 return error(
ID.Loc,
"sdiv constexprs are no longer supported");
3870 return error(
ID.Loc,
"urem constexprs are no longer supported");
3872 return error(
ID.Loc,
"srem constexprs are no longer supported");
3874 return error(
ID.Loc,
"fadd constexprs are no longer supported");
3876 return error(
ID.Loc,
"fsub constexprs are no longer supported");
3878 return error(
ID.Loc,
"fmul constexprs are no longer supported");
3880 return error(
ID.Loc,
"fdiv constexprs are no longer supported");
3882 return error(
ID.Loc,
"frem constexprs are no longer supported");
3884 return error(
ID.Loc,
"fneg constexprs are no longer supported");
3886 return error(
ID.Loc,
"select constexprs are no longer supported");
3892 if (parseCmpPredicate(PredVal, Opc) ||
3893 parseToken(
lltok::lparen,
"expected '(' in compare constantexpr") ||
3894 parseGlobalTypeAndValue(Val0) ||
3895 parseToken(
lltok::comma,
"expected comma in compare constantexpr") ||
3896 parseGlobalTypeAndValue(Val1) ||
3897 parseToken(
lltok::rparen,
"expected ')' in compare constantexpr"))
3901 return error(
ID.Loc,
"compare operands must have the same type");
3905 if (Opc == Instruction::FCmp) {
3907 return error(
ID.Loc,
"fcmp requires floating point operands");
3910 assert(Opc == Instruction::ICmp &&
"Unexpected opcode for CmpInst!");
3913 return error(
ID.Loc,
"icmp requires pointer or integer operands");
3933 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
3934 Opc == Instruction::Mul || Opc == Instruction::Shl) {
3942 }
else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
3943 Opc == Instruction::LShr || Opc == Instruction::AShr) {
3947 if (parseToken(
lltok::lparen,
"expected '(' in binary constantexpr") ||
3948 parseGlobalTypeAndValue(Val0) ||
3949 parseToken(
lltok::comma,
"expected comma in binary constantexpr") ||
3950 parseGlobalTypeAndValue(Val1) ||
3951 parseToken(
lltok::rparen,
"expected ')' in binary constantexpr"))
3954 return error(
ID.Loc,
"operands of constexpr must have same type");
3957 case Instruction::Add:
3958 case Instruction::Sub:
3959 case Instruction::Mul:
3960 case Instruction::UDiv:
3961 case Instruction::SDiv:
3962 case Instruction::URem:
3963 case Instruction::SRem:
3964 case Instruction::Shl:
3965 case Instruction::AShr:
3966 case Instruction::LShr:
3968 return error(
ID.Loc,
"constexpr requires integer operands");
3970 case Instruction::FAdd:
3971 case Instruction::FSub:
3972 case Instruction::FMul:
3973 case Instruction::FDiv:
3974 case Instruction::FRem:
3976 return error(
ID.Loc,
"constexpr requires fp operands");
3997 if (parseToken(
lltok::lparen,
"expected '(' in logical constantexpr") ||
3998 parseGlobalTypeAndValue(Val0) ||
3999 parseToken(
lltok::comma,
"expected comma in logical constantexpr") ||
4000 parseGlobalTypeAndValue(Val1) ||
4001 parseToken(
lltok::rparen,
"expected ')' in logical constantexpr"))
4004 return error(
ID.Loc,
"operands of constexpr must have same type");
4007 "constexpr requires integer or integer vector operands");
4019 bool InBounds =
false;
4023 if (Opc == Instruction::GetElementPtr)
4026 if (parseToken(
lltok::lparen,
"expected '(' in constantexpr"))
4030 if (Opc == Instruction::GetElementPtr) {
4031 if (parseType(Ty) ||
4032 parseToken(
lltok::comma,
"expected comma after getelementptr's type"))
4036 std::optional<unsigned> InRangeOp;
4037 if (parseGlobalValueVector(
4038 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp :
nullptr) ||
4042 if (Opc == Instruction::GetElementPtr) {
4043 if (Elts.
size() == 0 ||
4044 !Elts[0]->getType()->isPtrOrPtrVectorTy())
4045 return error(
ID.Loc,
"base of getelementptr must be a pointer");
4048 auto *BasePointerType = cast<PointerType>(
BaseType->getScalarType());
4049 if (!BasePointerType->isOpaqueOrPointeeTypeMatches(Ty)) {
4053 "explicit pointee type doesn't match operand's pointee type",
4054 Ty, BasePointerType->getNonOpaquePointerElementType()));
4059 ? cast<FixedVectorType>(
BaseType)->getNumElements()
4066 return error(
ID.Loc,
"getelementptr index must be an integer");
4067 if (
auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
4068 unsigned ValNumEl = cast<FixedVectorType>(ValVTy)->getNumElements();
4069 if (GEPWidth && (ValNumEl != GEPWidth))
4072 "getelementptr vector index has a wrong number of elements");
4075 GEPWidth = ValNumEl;
4080 if (!Indices.empty() && !Ty->
isSized(&Visited))
4081 return error(
ID.Loc,
"base element of getelementptr must be sized");
4084 return error(
ID.Loc,
"invalid getelementptr indices");
4087 if (*InRangeOp == 0)
4089 "inrange keyword may not appear on pointer operand");
4094 InBounds, InRangeOp);
4095 }
else if (Opc == Instruction::ShuffleVector) {
4096 if (Elts.
size() != 3)
4097 return error(
ID.Loc,
"expected three operands to shufflevector");
4099 return error(
ID.Loc,
"invalid operands to shufflevector");
4103 }
else if (Opc == Instruction::ExtractElement) {
4104 if (Elts.
size() != 2)
4105 return error(
ID.Loc,
"expected two operands to extractelement");
4107 return error(
ID.Loc,
"invalid extractelement operands");
4110 assert(Opc == Instruction::InsertElement &&
"Unknown opcode");
4111 if (Elts.
size() != 3)
4112 return error(
ID.Loc,
"expected three operands to insertelement");
4114 return error(
ID.Loc,
"invalid insertelement operands");
4133 bool Parsed = parseValID(
ID,
nullptr, Ty) ||
4134 convertValIDToValue(Ty,
ID, V,
nullptr);
4135 if (V && !(
C = dyn_cast<Constant>(V)))
4136 return error(
ID.Loc,
"global values must be constants");
4140bool LLParser::parseGlobalTypeAndValue(
Constant *&V) {
4142 return parseType(Ty) || parseGlobalValue(Ty, V);
4154 return tokError(
"expected comdat variable");
4157 if (parseToken(
lltok::rparen,
"expected ')' after comdat var"))
4160 if (GlobalName.
empty())
4161 return tokError(
"comdat cannot be unnamed");
4162 C = getComdat(std::string(GlobalName), KwLoc);
4172 std::optional<unsigned> *InRangeOp) {
4182 *InRangeOp = Elts.
size();
4185 if (parseGlobalTypeAndValue(
C))
4193bool LLParser::parseMDTuple(
MDNode *&MD,
bool IsDistinct) {
4195 if (parseMDNodeVector(Elts))
4206bool LLParser::parseMDNode(
MDNode *&
N) {
4208 return parseSpecializedMDNode(
N);
4210 return parseToken(
lltok::exclaim,
"expected '!' here") || parseMDNodeTail(
N);
4213bool LLParser::parseMDNodeTail(
MDNode *&
N) {
4216 return parseMDTuple(
N);
4219 return parseMDNodeID(
N);
4225template <
class FieldTy>
struct MDFieldImpl {
4226 typedef MDFieldImpl ImplTy;
4230 void assign(FieldTy Val) {
4232 this->Val = std::move(Val);
4235 explicit MDFieldImpl(FieldTy
Default)
4243template <
class FieldTypeA,
class FieldTypeB>
struct MDEitherFieldImpl {
4244 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
4255 void assign(FieldTypeA
A) {
4257 this->A = std::move(
A);
4261 void assign(FieldTypeB
B) {
4263 this->B = std::move(
B);
4267 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
4269 WhatIs(IsInvalid) {}
4272struct MDUnsignedField :
public MDFieldImpl<uint64_t> {
4279struct LineField :
public MDUnsignedField {
4280 LineField() : MDUnsignedField(0, UINT32_MAX) {}
4283struct ColumnField :
public MDUnsignedField {
4284 ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
4287struct DwarfTagField :
public MDUnsignedField {
4293struct DwarfMacinfoTypeField :
public MDUnsignedField {
4299struct DwarfAttEncodingField :
public MDUnsignedField {
4300 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::
DW_ATE_hi_user) {}
4303struct DwarfVirtualityField :
public MDUnsignedField {
4307struct DwarfLangField :
public MDUnsignedField {
4311struct DwarfCCField :
public MDUnsignedField {
4312 DwarfCCField() : MDUnsignedField(0, dwarf::
DW_CC_hi_user) {}
4315struct EmissionKindField :
public MDUnsignedField {
4316 EmissionKindField() : MDUnsignedField(0,
DICompileUnit::LastEmissionKind) {}
4319struct NameTableKindField :
public MDUnsignedField {
4320 NameTableKindField()
4323 DICompileUnit::DebugNameTableKind::LastDebugNameTableKind) {}
4326struct DIFlagField :
public MDFieldImpl<DINode::DIFlags> {
4327 DIFlagField() : MDFieldImpl(
DINode::FlagZero) {}
4330struct DISPFlagField :
public MDFieldImpl<DISubprogram::DISPFlags> {
4331 DISPFlagField() : MDFieldImpl(
DISubprogram::SPFlagZero) {}
4334struct MDAPSIntField :
public MDFieldImpl<APSInt> {
4335 MDAPSIntField() : ImplTy(
APSInt()) {}
4338struct MDSignedField :
public MDFieldImpl<int64_t> {
4342 MDSignedField(int64_t
Default = 0)
4344 MDSignedField(int64_t
Default, int64_t Min, int64_t Max)
4348struct MDBoolField :
public MDFieldImpl<bool> {
4352struct MDField :
public MDFieldImpl<Metadata *> {
4355 MDField(
bool AllowNull =
true) : ImplTy(nullptr), AllowNull(AllowNull) {}
4358struct MDStringField :
public MDFieldImpl<MDString *> {
4360 MDStringField(
bool AllowEmpty =
true)
4361 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
4364struct MDFieldList :
public MDFieldImpl<SmallVector<Metadata *, 4>> {
4368struct ChecksumKindField :
public MDFieldImpl<DIFile::ChecksumKind> {
4372struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
4373 MDSignedOrMDField(int64_t
Default = 0,
bool AllowNull =
true)
4374 : ImplTy(MDSignedField(
Default), MDField(AllowNull)) {}
4376 MDSignedOrMDField(int64_t
Default, int64_t Min, int64_t Max,
4377 bool AllowNull =
true)
4378 : ImplTy(MDSignedField(
Default, Min,
Max), MDField(AllowNull)) {}
4380 bool isMDSignedField()
const {
return WhatIs == IsTypeA; }
4381 bool isMDField()
const {
return WhatIs == IsTypeB; }
4382 int64_t getMDSignedValue()
const {
4383 assert(isMDSignedField() &&
"Wrong field type");
4386 Metadata *getMDFieldValue()
const {
4387 assert(isMDField() &&
"Wrong field type");
4399 return tokError(
"expected integer");
4408 MDUnsignedField &Result) {
4410 return tokError(
"expected unsigned integer");
4413 if (U.ugt(Result.Max))
4414 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4416 Result.assign(U.getZExtValue());
4417 assert(Result.Val <= Result.Max &&
"Expected value in range");
4424 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4428 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4434 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4437 return tokError(
"expected DWARF tag");
4441 return tokError(
"invalid DWARF tag" +
Twine(
" '") + Lex.
getStrVal() +
"'");
4442 assert(
Tag <= Result.Max &&
"Expected valid DWARF tag");
4451 DwarfMacinfoTypeField &Result) {
4453 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4456 return tokError(
"expected DWARF macinfo type");
4460 return tokError(
"invalid DWARF macinfo type" +
Twine(
" '") +
4462 assert(Macinfo <= Result.Max &&
"Expected valid DWARF macinfo type");
4464 Result.assign(Macinfo);
4471 DwarfVirtualityField &Result) {
4473 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4476 return tokError(
"expected DWARF virtuality code");
4480 return tokError(
"invalid DWARF virtuality code" +
Twine(
" '") +
4482 assert(Virtuality <= Result.Max &&
"Expected valid DWARF virtuality code");
4483 Result.assign(Virtuality);
4491 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4494 return tokError(
"expected DWARF language");
4498 return tokError(
"invalid DWARF language" +
Twine(
" '") + Lex.
getStrVal() +
4500 assert(Lang <= Result.Max &&
"Expected valid DWARF language");
4501 Result.assign(Lang);
4509 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4512 return tokError(
"expected DWARF calling convention");
4516 return tokError(
"invalid DWARF calling convention" +
Twine(
" '") +
4518 assert(
CC <= Result.Max &&
"Expected valid DWARF calling convention");
4526 EmissionKindField &Result) {
4528 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4531 return tokError(
"expected emission kind");
4535 return tokError(
"invalid emission kind" +
Twine(
" '") + Lex.
getStrVal() +
4537 assert(*Kind <= Result.Max &&
"Expected valid emission kind");
4538 Result.assign(*Kind);
4545 NameTableKindField &Result) {
4547 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4550 return tokError(
"expected nameTable kind");
4554 return tokError(
"invalid nameTable kind" +
Twine(
" '") + Lex.
getStrVal() +
4556 assert(((
unsigned)*Kind) <= Result.Max &&
"Expected valid nameTable kind");
4557 Result.assign((
unsigned)*Kind);
4564 DwarfAttEncodingField &Result) {
4566 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4569 return tokError(
"expected DWARF type attribute encoding");
4573 return tokError(
"invalid DWARF type attribute encoding" +
Twine(
" '") +
4575 assert(Encoding <= Result.Max &&
"Expected valid DWARF language");
4576 Result.assign(Encoding);
4592 bool Res = parseUInt32(TempVal);
4598 return tokError(
"expected debug info flag");
4602 return tokError(
Twine(
"invalid debug info flag '") + Lex.
getStrVal() +
4617 Result.assign(Combined);
4632 bool Res = parseUInt32(TempVal);
4638 return tokError(
"expected debug info flag");
4642 return tokError(
Twine(
"invalid subprogram debug info flag '") +
4657 Result.assign(Combined);
4664 return tokError(
"expected signed integer");
4668 return tokError(
"value for '" +
Name +
"' too small, limit is " +
4671 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4673 Result.assign(S.getExtValue());
4674 assert(Result.Val >= Result.Min &&
"Expected value in range");
4675 assert(Result.Val <= Result.Max &&
"Expected value in range");
4684 return tokError(
"expected 'true' or 'false'");
4686 Result.assign(
true);
4689 Result.assign(
false);
4699 if (!Result.AllowNull)
4700 return tokError(
"'" +
Name +
"' cannot be null");
4702 Result.assign(
nullptr);
4707 if (parseMetadata(MD,
nullptr))
4716 MDSignedOrMDField &Result) {
4719 MDSignedField Res = Result.A;
4720 if (!parseMDField(Loc,
Name, Res)) {
4728 MDField Res = Result.B;
4729 if (!parseMDField(Loc,
Name, Res)) {
4741 if (parseStringConstant(S))
4744 if (!Result.AllowEmpty && S.empty())
4745 return error(ValueLoc,
"'" +
Name +
"' cannot be empty");
4747 Result.assign(S.empty() ?
nullptr :
MDString::get(Context, S));
4754 if (parseMDNodeVector(MDs))
4757 Result.assign(std::move(MDs));
4763 ChecksumKindField &Result) {
4764 std::optional<DIFile::ChecksumKind> CSKind =
4768 return tokError(
"invalid checksum kind" +
Twine(
" '") + Lex.
getStrVal() +
4771 Result.assign(*CSKind);
4778template <
class ParserTy>
4779bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
4782 return tokError(
"expected field label here");
4791template <
class ParserTy>
4792bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) {
4799 if (parseMDFieldsImplBody(ParseField))
4802 ClosingLoc = Lex.
getLoc();
4806template <
class FieldTy>
4807bool LLParser::parseMDField(
StringRef Name, FieldTy &Result) {
4809 return tokError(
"field '" +
Name +
"' cannot be specified more than once");
4813 return parseMDField(Loc,
Name, Result);
4816bool LLParser::parseSpecializedMDNode(
MDNode *&
N,
bool IsDistinct) {
4819#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4820 if (Lex.getStrVal() == #CLASS) \
4821 return parse##CLASS(N, IsDistinct);
4822#include "llvm/IR/Metadata.def"
4824 return tokError(
"expected metadata type");
4827#define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4828#define NOP_FIELD(NAME, TYPE, INIT)
4829#define REQUIRE_FIELD(NAME, TYPE, INIT) \
4831 return error(ClosingLoc, "missing required field '" #NAME "'");
4832#define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4833 if (Lex.getStrVal() == #NAME) \
4834 return parseMDField(#NAME, NAME);
4835#define PARSE_MD_FIELDS() \
4836 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4839 if (parseMDFieldsImpl( \
4841 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4842 return tokError(Twine("invalid field '") + Lex.getStrVal() + \
4847 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4849#define GET_OR_DISTINCT(CLASS, ARGS) \
4850 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4855bool LLParser::parseDILocation(
MDNode *&Result,
bool IsDistinct) {
4856#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4857 OPTIONAL(line, LineField, ); \
4858 OPTIONAL(column, ColumnField, ); \
4859 REQUIRED(scope, MDField, ( false)); \
4860 OPTIONAL(inlinedAt, MDField, ); \
4861 OPTIONAL(isImplicitCode, MDBoolField, (false));
4863#undef VISIT_MD_FIELDS
4867 inlinedAt.Val, isImplicitCode.Val));
4873bool LLParser::parseDIAssignID(
MDNode *&Result,
bool IsDistinct) {
4875 return Lex.
Error(
"missing 'distinct', required for !DIAssignID()");
4891bool LLParser::parseGenericDINode(
MDNode *&Result,
bool IsDistinct) {
4892#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4893 REQUIRED(tag, DwarfTagField, ); \
4894 OPTIONAL(header, MDStringField, ); \
4895 OPTIONAL(operands, MDFieldList, );
4897#undef VISIT_MD_FIELDS
4900 (Context, tag.Val, header.Val, operands.Val));
4908bool LLParser::parseDISubrange(
MDNode *&Result,
bool IsDistinct) {
4909#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4910 OPTIONAL(count, MDSignedOrMDField, (-1, -1, INT64_MAX, false)); \
4911 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4912 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4913 OPTIONAL(stride, MDSignedOrMDField, );
4915#undef VISIT_MD_FIELDS
4922 auto convToMetadata = [&](MDSignedOrMDField Bound) ->
Metadata * {
4923 if (Bound.isMDSignedField())
4926 if (Bound.isMDField())
4927 return Bound.getMDFieldValue();
4931 Count = convToMetadata(
count);
4932 LowerBound = convToMetadata(lowerBound);
4933 UpperBound = convToMetadata(upperBound);
4934 Stride = convToMetadata(stride);
4937 (Context, Count, LowerBound, UpperBound, Stride));
4945bool LLParser::parseDIGenericSubrange(
MDNode *&Result,
bool IsDistinct) {
4946#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4947 OPTIONAL(count, MDSignedOrMDField, ); \