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");
991bool LLParser::parseAliasOrIFunc(
const std::string &
Name, LocTy NameLoc,
992 unsigned L,
unsigned Visibility,
993 unsigned DLLStorageClass,
bool DSOLocal,
1008 return error(NameLoc,
"invalid linkage type for alias");
1011 return error(NameLoc,
1012 "symbol with local linkage must have default visibility");
1015 return error(NameLoc,
1016 "symbol with local linkage cannot have a DLL storage class");
1020 if (parseType(Ty) ||
1021 parseToken(
lltok::comma,
"expected comma after alias or ifunc's type"))
1030 if (parseGlobalTypeAndValue(Aliasee))
1035 if (parseValID(
ID,
nullptr))
1038 return error(AliaseeLoc,
"invalid aliasee");
1039 Aliasee =
ID.ConstantVal;
1043 auto *PTy = dyn_cast<PointerType>(AliaseeType);
1045 return error(AliaseeLoc,
"An alias or ifunc must have pointer type");
1046 unsigned AddrSpace = PTy->getAddressSpace();
1052 if (!
Name.empty()) {
1053 auto I = ForwardRefVals.find(
Name);
1054 if (
I != ForwardRefVals.end()) {
1055 GVal =
I->second.first;
1056 ForwardRefVals.erase(
Name);
1058 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1061 auto I = ForwardRefValIDs.find(NumberedVals.size());
1062 if (
I != ForwardRefValIDs.end()) {
1063 GVal =
I->second.first;
1064 ForwardRefValIDs.erase(
I);
1069 std::unique_ptr<GlobalAlias> GA;
1070 std::unique_ptr<GlobalIFunc> GI;
1100 return tokError(
"unknown alias or ifunc property!");
1105 NumberedVals.push_back(GV);
1112 "forward reference and definition of alias have different types");
1134 case lltok::kw_sanitize_memtag:
1150 Meta.NoAddress =
true;
1153 Meta.NoHWAddress =
true;
1155 case lltok::kw_sanitize_memtag:
1159 Meta.IsDynInit =
true;
1162 return tokError(
"non-sanitizer token passed to LLParser::parseSanitizer()");
1182bool LLParser::parseGlobal(
const std::string &
Name, LocTy NameLoc,
1183 unsigned Linkage,
bool HasLinkage,
1184 unsigned Visibility,
unsigned DLLStorageClass,
1188 return error(NameLoc,
1189 "symbol with local linkage must have default visibility");
1192 return error(NameLoc,
1193 "symbol with local linkage cannot have a DLL storage class");
1197 LocTy IsExternallyInitializedLoc;
1201 if (parseOptionalAddrSpace(AddrSpace) ||
1203 IsExternallyInitialized,
1204 &IsExternallyInitializedLoc) ||
1205 parseGlobalType(IsConstant) || parseType(Ty, TyLoc))
1214 if (parseGlobalValue(Ty,
Init))
1219 return error(TyLoc,
"invalid type for global variable");
1224 if (!
Name.empty()) {
1225 auto I = ForwardRefVals.find(
Name);
1226 if (
I != ForwardRefVals.end()) {
1227 GVal =
I->second.first;
1228 ForwardRefVals.erase(
I);
1230 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1233 auto I = ForwardRefValIDs.find(NumberedVals.size());
1234 if (
I != ForwardRefValIDs.end()) {
1235 GVal =
I->second.first;
1236 ForwardRefValIDs.erase(
I);
1245 NumberedVals.push_back(GV);
1263 "forward reference and definition of global have different types");
1283 }
else if (Lex.
getKind() == lltok::kw_align) {
1285 if (parseOptionalAlignment(Alignment))
1290 if (parseGlobalObjectMetadataAttachment(*GV))
1293 if (parseSanitizer(GV))
1297 if (parseOptionalComdat(
Name,
C))
1302 return tokError(
"unknown global variable property!");
1308 std::vector<unsigned> FwdRefAttrGrps;
1309 if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps,
false, BuiltinLoc))
1311 if (
Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
1313 ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
1321bool LLParser::parseUnnamedAttrGrp() {
1327 return tokError(
"expected attribute group id");
1330 std::vector<unsigned> unused;
1338 auto R = NumberedAttrBuilders.find(VarID);
1339 if (R == NumberedAttrBuilders.end())
1342 if (parseFnAttributeValuePairs(
R->second, unused,
true, BuiltinLoc) ||
1343 parseToken(
lltok::rbrace,
"expected end of attribute group"))
1346 if (!
R->second.hasAttributes())
1347 return error(AttrGrpLoc,
"attribute group has no attributes");
1354#define GET_ATTR_NAMES
1355#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
1356 case lltok::kw_##DISPLAY_NAME: \
1357 return Attribute::ENUM_NAME;
1358#include "llvm/IR/Attributes.inc"
1367 return parseRequiredTypeAttr(
B, Lex.
getKind(), Attr);
1370 case Attribute::Alignment: {
1379 if (parseOptionalAlignment(Alignment,
true))
1382 B.addAlignmentAttr(Alignment);
1385 case Attribute::StackAlignment: {
1390 parseUInt32(Alignment))
1393 if (parseOptionalStackAlignment(Alignment))
1396 B.addStackAlignmentAttr(Alignment);
1399 case Attribute::AllocSize: {
1400 unsigned ElemSizeArg;
1401 std::optional<unsigned> NumElemsArg;
1402 if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
1404 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1407 case Attribute::VScaleRange: {
1408 unsigned MinValue, MaxValue;
1409 if (parseVScaleRangeArguments(MinValue, MaxValue))
1411 B.addVScaleRangeAttr(MinValue,
1412 MaxValue > 0 ? MaxValue : std::optional<unsigned>());
1415 case Attribute::Dereferenceable: {
1417 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1419 B.addDereferenceableAttr(Bytes);
1422 case Attribute::DereferenceableOrNull: {
1424 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1426 B.addDereferenceableOrNullAttr(Bytes);
1429 case Attribute::UWTable: {
1431 if (parseOptionalUWTableKind(Kind))
1433 B.addUWTableAttr(Kind);
1436 case Attribute::AllocKind: {
1438 if (parseAllocKind(Kind))
1440 B.addAllocKindAttr(Kind);
1443 case Attribute::Memory: {
1444 std::optional<MemoryEffects> ME = parseMemoryAttr();
1447 B.addMemoryAttr(*ME);
1450 case Attribute::NoFPClass: {
1453 B.addNoFPClassAttr(NoFPClass);
1460 B.addAttribute(Attr);
1468 case lltok::kw_readnone:
1471 case lltok::kw_readonly:
1474 case lltok::kw_writeonly:
1493bool LLParser::parseFnAttributeValuePairs(
AttrBuilder &
B,
1494 std::vector<unsigned> &FwdRefAttrGrps,
1495 bool InAttrGrp, LocTy &BuiltinLoc) {
1496 bool HaveError =
false;
1507 if (parseStringAttribute(
B))
1519 "cannot have an attribute group reference in an attribute group");
1529 if (Token == lltok::kw_builtin)
1541 return error(Lex.
getLoc(),
"unterminated attribute group");
1544 if (parseEnumAttribute(Attr,
B, InAttrGrp))
1551 HaveError |=
error(Loc,
"this attribute does not apply to functions");
1555 B.addMemoryAttr(ME);
1569 PTy->getAddressSpace());
1578 error(Loc,
"'" +
Name +
"' is not a basic block");
1580 error(Loc,
"'" +
Name +
"' defined with type '" +
1593 error(Loc,
"global variable reference must have pointer type");
1604 auto I = ForwardRefVals.find(
Name);
1605 if (
I != ForwardRefVals.end())
1606 Val =
I->second.first;
1611 return cast_or_null<GlobalValue>(
1612 checkValidVariableType(Loc,
"@" +
Name, Ty, Val));
1616 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
1623 error(Loc,
"global variable reference must have pointer type");
1627 GlobalValue *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
1632 auto I = ForwardRefValIDs.find(
ID);
1633 if (
I != ForwardRefValIDs.end())
1634 Val =
I->second.first;
1639 return cast_or_null<GlobalValue>(
1640 checkValidVariableType(Loc,
"@" +
Twine(
ID), Ty, Val));
1644 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
1652Comdat *LLParser::getComdat(
const std::string &
Name, LocTy Loc) {
1656 if (
I != ComdatSymTab.
end())
1661 ForwardRefComdats[
Name] = Loc;
1671bool LLParser::parseToken(
lltok::Kind T,
const char *ErrMsg) {
1673 return tokError(ErrMsg);
1680bool LLParser::parseStringConstant(std::string &Result) {
1682 return tokError(
"expected string constant");
1690bool LLParser::parseUInt32(
uint32_t &Val) {
1692 return tokError(
"expected integer");
1694 if (Val64 !=
unsigned(Val64))
1695 return tokError(
"expected 32-bit integer (too large)");
1703bool LLParser::parseUInt64(
uint64_t &Val) {
1705 return tokError(
"expected integer");
1718 return tokError(
"expected localdynamic, initialexec or localexec");
1746 return parseTLSModel(TLM) ||
1747 parseToken(
lltok::rparen,
"expected ')' after thread local model");
1755bool LLParser::parseOptionalAddrSpace(
unsigned &AddrSpace,
unsigned DefaultAS) {
1756 AddrSpace = DefaultAS;
1760 auto ParseAddrspaceValue = [&](
unsigned &AddrSpace) ->
bool {
1763 if (AddrSpaceStr ==
"A") {
1765 }
else if (AddrSpaceStr ==
"G") {
1767 }
else if (AddrSpaceStr ==
"P") {
1770 return tokError(
"invalid symbolic addrspace '" + AddrSpaceStr +
"'");
1776 return tokError(
"expected integer or string constant");
1778 if (parseUInt32(AddrSpace))
1780 if (!isUInt<24>(AddrSpace))
1781 return error(Loc,
"invalid address space, must be a 24-bit integer");
1785 return parseToken(
lltok::lparen,
"expected '(' in address space") ||
1786 ParseAddrspaceValue(AddrSpace) ||
1797 if (EatIfPresent(
lltok::equal) && parseStringConstant(Val))
1799 B.addAttribute(Attr, Val);
1804bool LLParser::parseOptionalParamOrReturnAttrs(
AttrBuilder &
B,
bool IsParam) {
1805 bool HaveError =
false;
1812 if (parseStringAttribute(
B))
1822 if (parseEnumAttribute(Attr,
B,
false))
1826 HaveError |=
error(Loc,
"this attribute does not apply to parameters");
1828 HaveError |=
error(Loc,
"this attribute does not apply to return values");
1876bool LLParser::parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
1877 unsigned &Visibility,
1878 unsigned &DLLStorageClass,
bool &DSOLocal) {
1882 parseOptionalDSOLocal(DSOLocal);
1883 parseOptionalVisibility(Visibility);
1884 parseOptionalDLLStorageClass(DLLStorageClass);
1887 return error(Lex.
getLoc(),
"dso_location and DLL-StorageClass mismatch");
1893void LLParser::parseOptionalDSOLocal(
bool &DSOLocal) {
1915void LLParser::parseOptionalVisibility(
unsigned &Res) {
1938void LLParser::parseOptionalDLLStorageClass(
unsigned &Res) {
2005bool LLParser::parseOptionalCallingConv(
unsigned &
CC) {
2074 return parseUInt32(
CC);
2084bool LLParser::parseMetadataAttachment(
unsigned &Kind,
MDNode *&MD) {
2091 return parseMDNode(MD);
2096bool LLParser::parseInstructionMetadata(
Instruction &Inst) {
2099 return tokError(
"expected metadata after comma");
2103 if (parseMetadataAttachment(MDK,
N))
2106 if (MDK == LLVMContext::MD_DIAssignID)
2107 TempDIAssignIDAttachments[
N].push_back(&Inst);
2111 if (MDK == LLVMContext::MD_tbaa)
2112 InstsWithTBAATag.push_back(&Inst);
2121bool LLParser::parseGlobalObjectMetadataAttachment(
GlobalObject &GO) {
2124 if (parseMetadataAttachment(MDK,
N))
2133bool LLParser::parseOptionalFunctionMetadata(
Function &
F) {
2135 if (parseGlobalObjectMetadataAttachment(
F))
2143bool LLParser::parseOptionalAlignment(
MaybeAlign &Alignment,
bool AllowParens) {
2144 Alignment = std::nullopt;
2145 if (!EatIfPresent(lltok::kw_align))
2151 bool HaveParens =
false;
2157 if (parseUInt64(
Value))
2161 return error(ParenLoc,
"expected ')'");
2164 return error(AlignLoc,
"alignment is not a power of two");
2166 return error(AlignLoc,
"huge alignments are not supported yet");
2176bool LLParser::parseOptionalDerefAttrBytes(
lltok::Kind AttrKind,
2178 assert((AttrKind == lltok::kw_dereferenceable ||
2179 AttrKind == lltok::kw_dereferenceable_or_null) &&
2183 if (!EatIfPresent(AttrKind))
2187 return error(ParenLoc,
"expected '('");
2189 if (parseUInt64(Bytes))
2193 return error(ParenLoc,
"expected ')'");
2195 return error(DerefLoc,
"dereferenceable bytes must be non-zero");
2199bool LLParser::parseOptionalUWTableKind(
UWTableKind &Kind) {
2210 return error(KindLoc,
"expected unwind table kind");
2219 return error(ParenLoc,
"expected '('");
2222 if (parseStringConstant(Arg))
2223 return error(KindLoc,
"expected allockind value");
2227 }
else if (
A ==
"realloc") {
2229 }
else if (
A ==
"free") {
2231 }
else if (
A ==
"uninitialized") {
2233 }
else if (
A ==
"zeroed") {
2235 }
else if (
A ==
"aligned") {
2238 return error(KindLoc,
Twine(
"unknown allockind ") +
A);
2243 return error(ParenLoc,
"expected ')'");
2245 return error(KindLoc,
"expected allockind value");
2256 return std::nullopt;
2271 return std::nullopt;
2275std::optional<MemoryEffects> LLParser::parseMemoryAttr() {
2285 tokError(
"expected '('");
2286 return std::nullopt;
2289 bool SeenLoc =
false;
2295 tokError(
"expected ':' after location");
2296 return std::nullopt;
2303 tokError(
"expected memory location (argmem, inaccessiblemem) "
2304 "or access kind (none, read, write, readwrite)");
2306 tokError(
"expected access kind (none, read, write, readwrite)");
2307 return std::nullopt;
2316 tokError(
"default access kind must be specified first");
2317 return std::nullopt;
2326 tokError(
"unterminated memory attribute");
2327 return std::nullopt;
2369unsigned LLParser::parseNoFPClassAttr() {
2374 tokError(
"expected '('");
2381 if (TestMask != 0) {
2385 !parseUInt64(
Value)) {
2387 error(Lex.
getLoc(),
"invalid mask value for 'nofpclass'");
2398 error(Lex.
getLoc(),
"expected nofpclass test mask");
2416bool LLParser::parseOptionalCommaAlign(
MaybeAlign &Alignment,
2417 bool &AteExtraComma) {
2418 AteExtraComma =
false;
2422 AteExtraComma =
true;
2426 if (Lex.
getKind() != lltok::kw_align)
2427 return error(Lex.
getLoc(),
"expected metadata or 'align'");
2429 if (parseOptionalAlignment(Alignment))
2442bool LLParser::parseOptionalCommaAddrSpace(
unsigned &AddrSpace, LocTy &Loc,
2443 bool &AteExtraComma) {
2444 AteExtraComma =
false;
2448 AteExtraComma =
true;
2454 return error(Lex.
getLoc(),
"expected metadata or 'addrspace'");
2456 if (parseOptionalAddrSpace(AddrSpace))
2463bool LLParser::parseAllocSizeArguments(
unsigned &BaseSizeArg,
2464 std::optional<unsigned> &HowManyArg) {
2467 auto StartParen = Lex.
getLoc();
2469 return error(StartParen,
"expected '('");
2471 if (parseUInt32(BaseSizeArg))
2475 auto HowManyAt = Lex.
getLoc();
2477 if (parseUInt32(HowMany))
2479 if (HowMany == BaseSizeArg)
2480 return error(HowManyAt,
2481 "'allocsize' indices can't refer to the same parameter");
2482 HowManyArg = HowMany;
2484 HowManyArg = std::nullopt;
2486 auto EndParen = Lex.
getLoc();
2488 return error(EndParen,
"expected ')'");
2492bool LLParser::parseVScaleRangeArguments(
unsigned &MinValue,
2493 unsigned &MaxValue) {
2496 auto StartParen = Lex.
getLoc();
2498 return error(StartParen,
"expected '('");
2500 if (parseUInt32(MinValue))
2504 if (parseUInt32(MaxValue))
2507 MaxValue = MinValue;
2509 auto EndParen = Lex.
getLoc();
2511 return error(EndParen,
"expected ')'");
2520bool LLParser::parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
2525 return parseScope(SSID) || parseOrdering(Ordering);
2535 auto StartParenAt = Lex.
getLoc();
2537 return error(StartParenAt,
"Expected '(' in syncscope");
2540 auto SSNAt = Lex.
getLoc();
2541 if (parseStringConstant(SSN))
2542 return error(SSNAt,
"Expected synchronization scope name");
2544 auto EndParenAt = Lex.
getLoc();
2546 return error(EndParenAt,
"Expected ')' in syncscope");
2561 return tokError(
"Expected ordering on atomic instruction");
2580bool LLParser::parseOptionalStackAlignment(
unsigned &Alignment) {
2582 if (!EatIfPresent(lltok::kw_alignstack))
2586 return error(ParenLoc,
"expected '('");
2588 if (parseUInt32(Alignment))
2592 return error(ParenLoc,
"expected ')'");
2594 return error(AlignLoc,
"stack alignment is not a power of two");
2608 bool &AteExtraComma) {
2609 AteExtraComma =
false;
2612 return tokError(
"expected ',' as start of index list");
2616 if (Indices.
empty())
2617 return tokError(
"expected index");
2618 AteExtraComma =
true;
2622 if (parseUInt32(
Idx))
2635bool LLParser::parseType(
Type *&Result,
const Twine &Msg,
bool AllowVoid) {
2639 return tokError(Msg);
2648 if (
Result->isPointerTy()) {
2650 if (parseOptionalAddrSpace(AddrSpace))
2656 return tokError(
"ptr* is invalid - use ptr instead");
2667 if (parseTargetExtType(Result))
2673 if (parseAnonStructType(Result,
false))
2679 if (parseArrayVectorType(Result,
false))
2686 if (parseAnonStructType(Result,
true) ||
2687 parseToken(
lltok::greater,
"expected '>' at end of packed struct"))
2689 }
else if (parseArrayVectorType(Result,
true))
2694 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.
getStrVal()];
2700 Entry.second = Lex.
getLoc();
2709 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.
getUIntVal()];
2715 Entry.second = Lex.
getLoc();
2728 if (!AllowVoid &&
Result->isVoidTy())
2729 return error(TypeLoc,
"void type only allowed for function results");
2735 return tokError(
"basic block pointers are invalid");
2737 return tokError(
"pointers to void are invalid - use i8* instead");
2739 return tokError(
"pointer to this type is invalid");
2747 return tokError(
"basic block pointers are invalid");
2749 return tokError(
"pointers to void are invalid; use i8* instead");
2751 return tokError(
"pointer to this type is invalid");
2753 if (parseOptionalAddrSpace(AddrSpace) ||
2754 parseToken(
lltok::star,
"expected '*' in address space"))
2763 if (parseFunctionType(Result))
2776 PerFunctionState &PFS,
bool IsMustTailCall,
2777 bool InVarArgsFunc) {
2783 if (!ArgList.
empty() &&
2784 parseToken(
lltok::comma,
"expected ',' in argument list"))
2789 const char *
Msg =
"unexpected ellipsis in argument list for ";
2790 if (!IsMustTailCall)
2791 return tokError(
Twine(Msg) +
"non-musttail call");
2793 return tokError(
Twine(Msg) +
"musttail call in non-varargs function");
2795 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
2800 Type *ArgTy =
nullptr;
2802 if (parseType(ArgTy, ArgLoc))
2808 if (parseMetadataAsValue(V, PFS))
2812 if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
2819 if (IsMustTailCall && InVarArgsFunc)
2820 return tokError(
"expected '...' at end of argument list for musttail call "
2821 "in varargs function");
2832 if (!EatIfPresent(AttrToken))
2841 B.addTypeAttr(AttrKind, Ty);
2854bool LLParser::parseOptionalOperandBundles(
2862 if (!BundleList.
empty() &&
2863 parseToken(
lltok::comma,
"expected ',' in input list"))
2867 if (parseStringConstant(
Tag))
2870 if (parseToken(
lltok::lparen,
"expected '(' in operand bundle"))
2873 std::vector<Value *> Inputs;
2876 if (!Inputs.empty() &&
2877 parseToken(
lltok::comma,
"expected ',' in input list"))
2881 Value *Input =
nullptr;
2882 if (parseType(Ty) || parseValue(Ty, Input, PFS))
2884 Inputs.push_back(Input);
2892 if (BundleList.
empty())
2893 return error(BeginLoc,
"operand bundle set must not be empty");
2910 unsigned CurValID = 0;
2922 Type *ArgTy =
nullptr;
2926 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2930 return error(TypeLoc,
"argument can not have void type");
2937 return error(TypeLoc,
"argument expected to be numbered '%" +
2938 Twine(CurValID) +
"'");
2944 return error(TypeLoc,
"invalid type for function argument");
2959 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2963 return error(TypeLoc,
"argument can not have void type");
2971 return error(TypeLoc,
"argument expected to be numbered '%" +
2972 Twine(CurValID) +
"'");
2980 return error(TypeLoc,
"invalid type for function argument");
2988 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
2993bool LLParser::parseFunctionType(
Type *&Result) {
2997 return tokError(
"invalid function return type");
3001 if (parseArgumentList(ArgList, IsVarArg))
3005 for (
unsigned i = 0, e = ArgList.
size(); i != e; ++i) {
3006 if (!ArgList[i].
Name.empty())
3007 return error(ArgList[i].Loc,
"argument name invalid in function type");
3008 if (ArgList[i].
Attrs.hasAttributes())
3009 return error(ArgList[i].Loc,
3010 "argument attributes invalid in function type");
3014 for (
unsigned i = 0, e = ArgList.
size(); i != e; ++i)
3023bool LLParser::parseAnonStructType(
Type *&Result,
bool Packed) {
3025 if (parseStructBody(Elts))
3034 std::pair<Type *, LocTy> &Entry,
3037 if (Entry.first && !Entry.second.isValid())
3038 return error(TypeLoc,
"redefinition of type");
3044 Entry.second =
SMLoc();
3049 ResultTy = Entry.first;
3061 return error(TypeLoc,
"forward references to non-struct type");
3065 return parseArrayVectorType(ResultTy,
true);
3066 return parseType(ResultTy);
3070 Entry.second =
SMLoc();
3076 StructType *STy = cast<StructType>(Entry.first);
3079 if (parseStructBody(Body) ||
3080 (isPacked && parseToken(
lltok::greater,
"expected '>' in packed struct")))
3109 return error(EltTyLoc,
"invalid element type for struct");
3117 return error(EltTyLoc,
"invalid element type for struct");
3122 return parseToken(
lltok::rbrace,
"expected '}' at end of struct");
3131bool LLParser::parseArrayVectorType(
Type *&Result,
bool IsVector) {
3132 bool Scalable =
false;
3136 if (parseToken(
lltok::kw_x,
"expected 'x' after vscale"))
3144 return tokError(
"expected number in address space");
3150 if (parseToken(
lltok::kw_x,
"expected 'x' after element count"))
3154 Type *EltTy =
nullptr;
3155 if (parseType(EltTy))
3159 "expected end of sequential type"))
3164 return error(SizeLoc,
"zero element vector is illegal");
3166 return error(SizeLoc,
"size too large for vector");
3168 return error(TypeLoc,
"invalid vector element type");
3172 return error(TypeLoc,
"invalid array element type");
3189bool LLParser::parseTargetExtType(
Type *&Result) {
3194 if (parseToken(
lltok::lparen,
"expected '(' in target extension type") ||
3195 parseStringConstant(TypeName))
3203 bool SeenInt =
false;
3210 if (parseUInt32(IntVal))
3213 }
else if (SeenInt) {
3216 return tokError(
"expected uint32 param");
3219 if (parseType(TypeParam,
true))
3225 if (parseToken(
lltok::rparen,
"expected ')' in target extension type"))
3238 :
P(
p),
F(
f), FunctionNumber(functionNumber) {
3243 NumberedVals.push_back(&
A);
3246LLParser::PerFunctionState::~PerFunctionState() {
3249 for (
const auto &
P : ForwardRefVals) {
3250 if (isa<BasicBlock>(
P.second.first))
3252 P.second.first->replaceAllUsesWith(
3254 P.second.first->deleteValue();
3257 for (
const auto &
P : ForwardRefValIDs) {
3258 if (isa<BasicBlock>(
P.second.first))
3260 P.second.first->replaceAllUsesWith(
3262 P.second.first->deleteValue();
3266bool LLParser::PerFunctionState::finishFunction() {
3267 if (!ForwardRefVals.empty())
3268 return P.error(ForwardRefVals.begin()->second.second,
3269 "use of undefined value '%" + ForwardRefVals.begin()->first +
3271 if (!ForwardRefValIDs.empty())
3272 return P.error(ForwardRefValIDs.begin()->second.second,
3273 "use of undefined value '%" +
3274 Twine(ForwardRefValIDs.begin()->first) +
"'");
3281Value *LLParser::PerFunctionState::getVal(
const std::string &
Name,
Type *Ty,
3284 Value *Val =
F.getValueSymbolTable()->lookup(
Name);
3289 auto I = ForwardRefVals.find(
Name);
3290 if (
I != ForwardRefVals.end())
3291 Val =
I->second.first;
3296 return P.checkValidVariableType(Loc,
"%" +
Name, Ty, Val);
3300 P.error(Loc,
"invalid use of a non-first-class type");
3312 P.error(Loc,
"name is too long which can result in name collisions, "
3313 "consider making the name shorter or "
3314 "increasing -non-global-value-max-name-size");
3318 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
3322Value *LLParser::PerFunctionState::getVal(
unsigned ID,
Type *Ty, LocTy Loc) {
3324 Value *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
3329 auto I = ForwardRefValIDs.find(
ID);
3330 if (
I != ForwardRefValIDs.end())
3331 Val =
I->second.first;
3336 return P.checkValidVariableType(Loc,
"%" +
Twine(
ID), Ty, Val);
3339 P.error(Loc,
"invalid use of a non-first-class type");
3351 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
3357bool LLParser::PerFunctionState::setInstName(
int NameID,
3358 const std::string &NameStr,
3362 if (NameID != -1 || !NameStr.empty())
3363 return P.error(NameLoc,
"instructions returning void cannot have a name");
3369 if (NameStr.empty()) {
3372 NameID = NumberedVals.size();
3374 if (
unsigned(NameID) != NumberedVals.size())
3375 return P.error(NameLoc,
"instruction expected to be numbered '%" +
3376 Twine(NumberedVals.size()) +
"'");
3378 auto FI = ForwardRefValIDs.find(NameID);
3379 if (FI != ForwardRefValIDs.end()) {
3382 return P.error(NameLoc,
"instruction forward referenced with type '" +
3386 Sentinel->replaceAllUsesWith(Inst);
3388 ForwardRefValIDs.erase(FI);
3391 NumberedVals.push_back(Inst);
3396 auto FI = ForwardRefVals.find(NameStr);
3397 if (FI != ForwardRefVals.end()) {
3400 return P.error(NameLoc,
"instruction forward referenced with type '" +
3404 Sentinel->replaceAllUsesWith(Inst);
3406 ForwardRefVals.erase(FI);
3412 if (Inst->
getName() != NameStr)
3413 return P.error(NameLoc,
"multiple definition of local value named '" +
3420BasicBlock *LLParser::PerFunctionState::getBB(
const std::string &
Name,
3422 return dyn_cast_or_null<BasicBlock>(
3426BasicBlock *LLParser::PerFunctionState::getBB(
unsigned ID, LocTy Loc) {
3427 return dyn_cast_or_null<BasicBlock>(
3434BasicBlock *LLParser::PerFunctionState::defineBB(
const std::string &
Name,
3435 int NameID, LocTy Loc) {
3438 if (NameID != -1 &&
unsigned(NameID) != NumberedVals.size()) {
3439 P.error(Loc,
"label expected to be numbered '" +
3440 Twine(NumberedVals.size()) +
"'");
3443 BB = getBB(NumberedVals.size(), Loc);
3445 P.error(Loc,
"unable to create block numbered '" +
3446 Twine(NumberedVals.size()) +
"'");
3450 BB = getBB(
Name, Loc);
3452 P.error(Loc,
"unable to create block named '" +
Name +
"'");
3463 ForwardRefValIDs.erase(NumberedVals.size());
3464 NumberedVals.push_back(BB);
3467 ForwardRefVals.erase(
Name);
3484bool LLParser::parseValID(
ValID &
ID, PerFunctionState *PFS,
Type *ExpectedTy) {
3488 return tokError(
"expected value token");
3531 if (parseGlobalValueVector(Elts) ||
3532 parseToken(
lltok::rbrace,
"expected end of struct constant"))
3535 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.
size());
3536 ID.UIntVal = Elts.
size();
3537 memcpy(
ID.ConstantStructElts.get(), Elts.
data(),
3538 Elts.
size() *
sizeof(Elts[0]));
3550 if (parseGlobalValueVector(Elts) ||
3552 parseToken(
lltok::rbrace,
"expected end of packed struct")) ||
3556 if (isPackedStruct) {
3557 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.
size());
3558 memcpy(
ID.ConstantStructElts.get(), Elts.
data(),
3559 Elts.
size() *
sizeof(Elts[0]));
3560 ID.UIntVal = Elts.
size();
3566 return error(
ID.Loc,
"constant vector must not be empty");
3568 if (!Elts[0]->
getType()->isIntegerTy() &&
3569 !Elts[0]->
getType()->isFloatingPointTy() &&
3570 !Elts[0]->
getType()->isPointerTy())
3573 "vector elements must have integer, pointer or floating point type");
3576 for (
unsigned i = 1, e = Elts.
size(); i != e; ++i)
3578 return error(FirstEltLoc,
"vector element #" +
Twine(i) +
3579 " is not of type '" +
3590 if (parseGlobalValueVector(Elts) ||
3602 if (!Elts[0]->
getType()->isFirstClassType())
3603 return error(FirstEltLoc,
"invalid array element type: " +
3609 for (
unsigned i = 0, e = Elts.
size(); i != e; ++i) {
3611 return error(FirstEltLoc,
"array element #" +
Twine(i) +
3612 " is not of type '" +
3632 bool HasSideEffect, AlignStack, AsmDialect, CanThrow;
3635 parseOptionalToken(lltok::kw_alignstack, AlignStack) ||
3638 parseStringConstant(
ID.StrVal) ||
3639 parseToken(
lltok::comma,
"expected comma in inline asm expression") ||
3644 (
unsigned(AsmDialect) << 2) | (
unsigned(CanThrow) << 3);
3655 if (parseToken(
lltok::lparen,
"expected '(' in block address expression") ||
3656 parseValID(Fn, PFS) ||
3658 "expected comma in block address expression") ||
3659 parseValID(Label, PFS) ||
3660 parseToken(
lltok::rparen,
"expected ')' in block address expression"))
3664 return error(Fn.
Loc,
"expected function name in blockaddress");
3666 return error(
Label.Loc,
"expected basic block name in blockaddress");
3671 if (Fn.
UIntVal < NumberedVals.size())
3672 GV = NumberedVals[Fn.
UIntVal];
3673 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3679 if (!isa<Function>(GV))
3680 return error(Fn.
Loc,
"expected function name in blockaddress");
3681 F = cast<Function>(GV);
3682 if (
F->isDeclaration())
3683 return error(Fn.
Loc,
"cannot take blockaddress inside a declaration");
3689 ForwardRefBlockAddresses.insert(std::make_pair(
3691 std::map<ValID, GlobalValue *>()))
3692 .first->second.insert(std::make_pair(std::move(Label),
nullptr))
3701 "type of blockaddress must be a pointer and not '" +
3706 FwdDeclAS = PFS->getFunction().getAddressSpace();
3715 ID.ConstantVal = FwdRef;
3723 if (BlockAddressPFS &&
F == &BlockAddressPFS->getFunction()) {
3725 BB = BlockAddressPFS->getBB(
Label.UIntVal,
Label.Loc);
3727 BB = BlockAddressPFS->getBB(
Label.StrVal,
Label.Loc);
3729 return error(
Label.Loc,
"referenced value is not a basic block");
3732 return error(
Label.Loc,
"cannot take address of numeric label after "
3733 "the function is defined");
3734 BB = dyn_cast_or_null<BasicBlock>(
3735 F->getValueSymbolTable()->lookup(
Label.StrVal));
3737 return error(
Label.Loc,
"referenced value is not a basic block");
3751 if (parseValID(Fn, PFS))
3756 "expected global value name in dso_local_equivalent");
3761 if (Fn.
UIntVal < NumberedVals.size())
3762 GV = NumberedVals[Fn.
UIntVal];
3763 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3770 ? ForwardRefDSOLocalEquivalentIDs
3771 : ForwardRefDSOLocalEquivalentNames;
3772 GlobalValue *&FwdRef = FwdRefMap.try_emplace(Fn,
nullptr).first->second;
3779 ID.ConstantVal = FwdRef;
3785 return error(Fn.
Loc,
"expected a function, alias to function, or ifunc "
3786 "in dso_local_equivalent");
3797 if (parseValID(
ID, PFS))
3801 return error(
ID.Loc,
"expected global value name in no_cfi");
3813 Type *DestTy =
nullptr;
3816 if (parseToken(
lltok::lparen,
"expected '(' after constantexpr cast") ||
3817 parseGlobalTypeAndValue(SrcVal) ||
3818 parseToken(
lltok::kw_to,
"expected 'to' in constantexpr cast") ||
3819 parseType(DestTy) ||
3820 parseToken(
lltok::rparen,
"expected ')' at end of constantexpr cast"))
3823 return error(
ID.Loc,
"invalid cast opcode for cast from '" +
3832 return error(
ID.Loc,
"extractvalue constexprs are no longer supported");
3834 return error(
ID.Loc,
"insertvalue constexprs are no longer supported");
3836 return error(
ID.Loc,
"udiv constexprs are no longer supported");
3838 return error(
ID.Loc,
"sdiv constexprs are no longer supported");
3840 return error(
ID.Loc,
"urem constexprs are no longer supported");
3842 return error(
ID.Loc,
"srem constexprs are no longer supported");
3844 return error(
ID.Loc,
"fadd constexprs are no longer supported");
3846 return error(
ID.Loc,
"fsub constexprs are no longer supported");
3848 return error(
ID.Loc,
"fmul constexprs are no longer supported");
3850 return error(
ID.Loc,
"fdiv constexprs are no longer supported");
3852 return error(
ID.Loc,
"frem constexprs are no longer supported");
3854 return error(
ID.Loc,
"and constexprs are no longer supported");
3856 return error(
ID.Loc,
"or constexprs are no longer supported");
3858 return error(
ID.Loc,
"lshr constexprs are no longer supported");
3860 return error(
ID.Loc,
"ashr constexprs are no longer supported");
3862 return error(
ID.Loc,
"fneg constexprs are no longer supported");
3864 return error(
ID.Loc,
"select constexprs are no longer supported");
3866 return error(
ID.Loc,
"zext constexprs are no longer supported");
3868 return error(
ID.Loc,
"sext constexprs are no longer supported");
3870 return error(
ID.Loc,
"fptrunc constexprs are no longer supported");
3872 return error(
ID.Loc,
"fpext constexprs are no longer supported");
3874 return error(
ID.Loc,
"uitofp constexprs are no longer supported");
3876 return error(
ID.Loc,
"sitofp constexprs are no longer supported");
3878 return error(
ID.Loc,
"fptoui constexprs are no longer supported");
3880 return error(
ID.Loc,
"fptosi constexprs are no longer supported");
3886 if (parseCmpPredicate(PredVal, Opc) ||
3887 parseToken(
lltok::lparen,
"expected '(' in compare constantexpr") ||
3888 parseGlobalTypeAndValue(Val0) ||
3889 parseToken(
lltok::comma,
"expected comma in compare constantexpr") ||
3890 parseGlobalTypeAndValue(Val1) ||
3891 parseToken(
lltok::rparen,
"expected ')' in compare constantexpr"))
3895 return error(
ID.Loc,
"compare operands must have the same type");
3899 if (Opc == Instruction::FCmp) {
3901 return error(
ID.Loc,
"fcmp requires floating point operands");
3904 assert(Opc == Instruction::ICmp &&
"Unexpected opcode for CmpInst!");
3907 return error(
ID.Loc,
"icmp requires pointer or integer operands");
3925 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
3926 Opc == Instruction::Mul || Opc == Instruction::Shl) {
3935 if (parseToken(
lltok::lparen,
"expected '(' in binary constantexpr") ||
3936 parseGlobalTypeAndValue(Val0) ||
3937 parseToken(
lltok::comma,
"expected comma in binary constantexpr") ||
3938 parseGlobalTypeAndValue(Val1) ||
3939 parseToken(
lltok::rparen,
"expected ')' in binary constantexpr"))
3942 return error(
ID.Loc,
"operands of constexpr must have same type");
3946 "constexpr requires integer or integer vector operands");
3961 bool InBounds =
false;
3965 if (Opc == Instruction::GetElementPtr)
3968 if (parseToken(
lltok::lparen,
"expected '(' in constantexpr"))
3971 if (Opc == Instruction::GetElementPtr) {
3972 if (parseType(Ty) ||
3973 parseToken(
lltok::comma,
"expected comma after getelementptr's type"))
3977 std::optional<unsigned> InRangeOp;
3978 if (parseGlobalValueVector(
3979 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp :
nullptr) ||
3983 if (Opc == Instruction::GetElementPtr) {
3984 if (Elts.
size() == 0 ||
3985 !Elts[0]->getType()->isPtrOrPtrVectorTy())
3986 return error(
ID.Loc,
"base of getelementptr must be a pointer");
3991 ? cast<FixedVectorType>(
BaseType)->getNumElements()
3998 return error(
ID.Loc,
"getelementptr index must be an integer");
3999 if (
auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
4000 unsigned ValNumEl = cast<FixedVectorType>(ValVTy)->getNumElements();
4001 if (GEPWidth && (ValNumEl != GEPWidth))
4004 "getelementptr vector index has a wrong number of elements");
4007 GEPWidth = ValNumEl;
4012 if (!Indices.empty() && !Ty->
isSized(&Visited))
4013 return error(
ID.Loc,
"base element of getelementptr must be sized");
4016 return error(
ID.Loc,
"invalid getelementptr indices");
4019 if (*InRangeOp == 0)
4021 "inrange keyword may not appear on pointer operand");
4026 InBounds, InRangeOp);
4027 }
else if (Opc == Instruction::ShuffleVector) {
4028 if (Elts.
size() != 3)
4029 return error(
ID.Loc,
"expected three operands to shufflevector");
4031 return error(
ID.Loc,
"invalid operands to shufflevector");
4035 }
else if (Opc == Instruction::ExtractElement) {
4036 if (Elts.
size() != 2)
4037 return error(
ID.Loc,
"expected two operands to extractelement");
4039 return error(
ID.Loc,
"invalid extractelement operands");
4042 assert(Opc == Instruction::InsertElement &&
"Unknown opcode");
4043 if (Elts.
size() != 3)
4044 return error(
ID.Loc,
"expected three operands to insertelement");
4046 return error(
ID.Loc,
"invalid insertelement operands");
4065 bool Parsed = parseValID(
ID,
nullptr, Ty) ||
4066 convertValIDToValue(Ty,
ID, V,
nullptr);
4067 if (V && !(
C = dyn_cast<Constant>(V)))
4068 return error(
ID.Loc,
"global values must be constants");
4072bool LLParser::parseGlobalTypeAndValue(
Constant *&V) {
4074 return parseType(Ty) || parseGlobalValue(Ty, V);
4086 return tokError(
"expected comdat variable");
4089 if (parseToken(
lltok::rparen,
"expected ')' after comdat var"))
4092 if (GlobalName.
empty())
4093 return tokError(
"comdat cannot be unnamed");
4094 C = getComdat(std::string(GlobalName), KwLoc);
4104 std::optional<unsigned> *InRangeOp) {
4114 *InRangeOp = Elts.
size();
4117 if (parseGlobalTypeAndValue(
C))
4125bool LLParser::parseMDTuple(
MDNode *&MD,
bool IsDistinct) {
4127 if (parseMDNodeVector(Elts))
4138bool LLParser::parseMDNode(
MDNode *&
N) {
4140 return parseSpecializedMDNode(
N);
4142 return parseToken(
lltok::exclaim,
"expected '!' here") || parseMDNodeTail(
N);
4145bool LLParser::parseMDNodeTail(
MDNode *&
N) {
4148 return parseMDTuple(
N);
4151 return parseMDNodeID(
N);
4157template <
class FieldTy>
struct MDFieldImpl {
4158 typedef MDFieldImpl ImplTy;
4162 void assign(FieldTy Val) {
4164 this->Val = std::move(Val);
4167 explicit MDFieldImpl(FieldTy
Default)
4175template <
class FieldTypeA,
class FieldTypeB>
struct MDEitherFieldImpl {
4176 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
4187 void assign(FieldTypeA
A) {
4189 this->A = std::move(
A);
4193 void assign(FieldTypeB
B) {
4195 this->B = std::move(
B);
4199 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
4201 WhatIs(IsInvalid) {}
4204struct MDUnsignedField :
public MDFieldImpl<uint64_t> {
4211struct LineField :
public MDUnsignedField {
4212 LineField() : MDUnsignedField(0, UINT32_MAX) {}
4215struct ColumnField :
public MDUnsignedField {
4216 ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
4219struct DwarfTagField :
public MDUnsignedField {
4225struct DwarfMacinfoTypeField :
public MDUnsignedField {
4231struct DwarfAttEncodingField :
public MDUnsignedField {
4232 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::
DW_ATE_hi_user) {}
4235struct DwarfVirtualityField :
public MDUnsignedField {
4239struct DwarfLangField :
public MDUnsignedField {
4243struct DwarfCCField :
public MDUnsignedField {
4244 DwarfCCField() : MDUnsignedField(0, dwarf::
DW_CC_hi_user) {}
4247struct EmissionKindField :
public MDUnsignedField {
4248 EmissionKindField() : MDUnsignedField(0,
DICompileUnit::LastEmissionKind) {}
4251struct NameTableKindField :
public MDUnsignedField {
4252 NameTableKindField()
4255 DICompileUnit::DebugNameTableKind::LastDebugNameTableKind) {}
4258struct DIFlagField :
public MDFieldImpl<DINode::DIFlags> {
4259 DIFlagField() : MDFieldImpl(
DINode::FlagZero) {}
4262struct DISPFlagField :
public MDFieldImpl<DISubprogram::DISPFlags> {
4263 DISPFlagField() : MDFieldImpl(
DISubprogram::SPFlagZero) {}
4266struct MDAPSIntField :
public MDFieldImpl<APSInt> {
4267 MDAPSIntField() : ImplTy(
APSInt()) {}
4270struct MDSignedField :
public MDFieldImpl<int64_t> {
4274 MDSignedField(int64_t
Default = 0)
4276 MDSignedField(int64_t
Default, int64_t Min, int64_t Max)
4280struct MDBoolField :
public MDFieldImpl<bool> {
4284struct MDField :
public MDFieldImpl<Metadata *> {
4287 MDField(
bool AllowNull =
true) : ImplTy(nullptr), AllowNull(AllowNull) {}
4290struct MDStringField :
public MDFieldImpl<MDString *> {
4292 MDStringField(
bool AllowEmpty =
true)
4293 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
4296struct MDFieldList :
public MDFieldImpl<SmallVector<Metadata *, 4>> {
4300struct ChecksumKindField :
public MDFieldImpl<DIFile::ChecksumKind> {
4304struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
4305 MDSignedOrMDField(int64_t
Default = 0,
bool AllowNull =
true)
4306 : ImplTy(MDSignedField(
Default), MDField(AllowNull)) {}
4308 MDSignedOrMDField(int64_t
Default, int64_t Min, int64_t Max,
4309 bool AllowNull =
true)
4310 : ImplTy(MDSignedField(
Default, Min,
Max), MDField(AllowNull)) {}
4312 bool isMDSignedField()
const {
return WhatIs == IsTypeA; }
4313 bool isMDField()
const {
return WhatIs == IsTypeB; }
4314 int64_t getMDSignedValue()
const {
4315 assert(isMDSignedField() &&
"Wrong field type");
4318 Metadata *getMDFieldValue()
const {
4319 assert(isMDField() &&
"Wrong field type");
4331 return tokError(
"expected integer");
4340 MDUnsignedField &Result) {
4342 return tokError(
"expected unsigned integer");
4345 if (U.ugt(Result.Max))
4346 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4348 Result.assign(U.getZExtValue());
4349 assert(Result.Val <= Result.Max &&
"Expected value in range");
4356 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4360 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4366 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4369 return tokError(
"expected DWARF tag");
4373 return tokError(
"invalid DWARF tag" +
Twine(
" '") + Lex.
getStrVal() +
"'");
4374 assert(
Tag <= Result.Max &&
"Expected valid DWARF tag");
4383 DwarfMacinfoTypeField &Result) {
4385 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4388 return tokError(
"expected DWARF macinfo type");
4392 return tokError(
"invalid DWARF macinfo type" +
Twine(
" '") +
4394 assert(Macinfo <= Result.Max &&
"Expected valid DWARF macinfo type");
4396 Result.assign(Macinfo);
4403 DwarfVirtualityField &Result) {
4405 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4408 return tokError(
"expected DWARF virtuality code");
4412 return tokError(
"invalid DWARF virtuality code" +
Twine(
" '") +
4414 assert(Virtuality <= Result.Max &&
"Expected valid DWARF virtuality code");
4415 Result.assign(Virtuality);
4423 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4426 return tokError(
"expected DWARF language");
4430 return tokError(
"invalid DWARF language" +
Twine(
" '") + Lex.
getStrVal() +
4432 assert(Lang <= Result.Max &&
"Expected valid DWARF language");
4433 Result.assign(Lang);
4441 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4444 return tokError(
"expected DWARF calling convention");
4448 return tokError(
"invalid DWARF calling convention" +
Twine(
" '") +
4450 assert(
CC <= Result.Max &&
"Expected valid DWARF calling convention");
4458 EmissionKindField &Result) {
4460 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4463 return tokError(
"expected emission kind");
4467 return tokError(
"invalid emission kind" +
Twine(
" '") + Lex.
getStrVal() +
4469 assert(*Kind <= Result.Max &&
"Expected valid emission kind");
4470 Result.assign(*Kind);
4477 NameTableKindField &Result) {
4479 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4482 return tokError(
"expected nameTable kind");
4486 return tokError(
"invalid nameTable kind" +
Twine(
" '") + Lex.
getStrVal() +
4488 assert(((
unsigned)*Kind) <= Result.Max &&
"Expected valid nameTable kind");
4489 Result.assign((
unsigned)*Kind);
4496 DwarfAttEncodingField &Result) {
4498 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4501 return tokError(
"expected DWARF type attribute encoding");
4505 return tokError(
"invalid DWARF type attribute encoding" +
Twine(
" '") +
4507 assert(Encoding <= Result.Max &&
"Expected valid DWARF language");
4508 Result.assign(Encoding);
4524 bool Res = parseUInt32(TempVal);
4530 return tokError(
"expected debug info flag");
4534 return tokError(
Twine(
"invalid debug info flag '") + Lex.
getStrVal() +
4549 Result.assign(Combined);
4564 bool Res = parseUInt32(TempVal);
4570 return tokError(
"expected debug info flag");
4574 return tokError(
Twine(
"invalid subprogram debug info flag '") +
4589 Result.assign(Combined);
4596 return tokError(
"expected signed integer");
4600 return tokError(
"value for '" +
Name +
"' too small, limit is " +
4603 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4605 Result.assign(S.getExtValue());
4606 assert(Result.Val >= Result.Min &&
"Expected value in range");
4607 assert(Result.Val <= Result.Max &&
"Expected value in range");
4616 return tokError(
"expected 'true' or 'false'");
4618 Result.assign(
true);
4621 Result.assign(
false);
4631 if (!Result.AllowNull)
4632 return tokError(
"'" +
Name +
"' cannot be null");
4634 Result.assign(
nullptr);
4639 if (parseMetadata(MD,
nullptr))
4648 MDSignedOrMDField &Result) {
4651 MDSignedField Res = Result.A;
4652 if (!parseMDField(Loc,
Name, Res)) {
4660 MDField Res = Result.B;
4661 if (!parseMDField(Loc,
Name, Res)) {
4673 if (parseStringConstant(S))
4676 if (!Result.AllowEmpty && S.empty())
4677 return error(ValueLoc,
"'" +
Name +
"' cannot be empty");
4679 Result.assign(S.empty() ?
nullptr :
MDString::get(Context, S));
4686 if (parseMDNodeVector(MDs))
4689 Result.assign(std::move(MDs));
4695 ChecksumKindField &Result) {
4696 std::optional<DIFile::ChecksumKind> CSKind =
4700 return tokError(
"invalid checksum kind" +
Twine(
" '") + Lex.
getStrVal() +
4703 Result.assign(*CSKind);
4710template <
class ParserTy>
4711bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
4714 return tokError(
"expected field label here");
4723template <
class ParserTy>
4724bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) {
4731 if (parseMDFieldsImplBody(ParseField))
4734 ClosingLoc = Lex.
getLoc();
4738template <
class FieldTy>
4739bool LLParser::parseMDField(
StringRef Name, FieldTy &Result) {
4741 return tokError(
"field '" +
Name +
"' cannot be specified more than once");
4745 return parseMDField(Loc,
Name, Result);
4748bool LLParser::parseSpecializedMDNode(
MDNode *&
N,
bool IsDistinct) {
4751#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4752 if (Lex.getStrVal() == #CLASS) \
4753 return parse##CLASS(N, IsDistinct);
4754#include "llvm/IR/Metadata.def"
4756 return tokError(
"expected metadata type");
4759#define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4760#define NOP_FIELD(NAME, TYPE, INIT)
4761#define REQUIRE_FIELD(NAME, TYPE, INIT) \
4763 return error(ClosingLoc, "missing required field '" #NAME "'");
4764#define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4765 if (Lex.getStrVal() == #NAME) \
4766 return parseMDField(#NAME, NAME);
4767#define PARSE_MD_FIELDS() \
4768 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4771 if (parseMDFieldsImpl( \
4773 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4774 return tokError(Twine("invalid field '") + Lex.getStrVal() + \
4779 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4781#define GET_OR_DISTINCT(CLASS, ARGS) \
4782 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4787bool LLParser::parseDILocation(
MDNode *&Result,
bool IsDistinct) {
4788#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4789 OPTIONAL(line, LineField, ); \
4790 OPTIONAL(column, ColumnField, ); \
4791 REQUIRED(scope, MDField, ( false)); \
4792 OPTIONAL(inlinedAt, MDField, ); \
4793 OPTIONAL(isImplicitCode, MDBoolField, (false));
4795#undef VISIT_MD_FIELDS
4799 inlinedAt.Val, isImplicitCode.Val));
4805bool LLParser::parseDIAssignID(
MDNode *&Result,
bool IsDistinct) {
4807 return Lex.
Error(
"missing 'distinct', required for !DIAssignID()");
4823bool LLParser::parseGenericDINode(
MDNode *&Result,
bool IsDistinct) {
4824#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4825 REQUIRED(tag, DwarfTagField, ); \
4826 OPTIONAL(header, MDStringField, ); \
4827 OPTIONAL(operands, MDFieldList, );
4829#undef VISIT_MD_FIELDS
4832 (Context, tag.Val, header.Val, operands.Val));
4840bool LLParser::parseDISubrange(
MDNode *&Result,
bool IsDistinct) {
4841#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4842 OPTIONAL(count, MDSignedOrMDField, (-1, -1, INT64_MAX, false)); \
4843 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4844 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4845 OPTIONAL(stride, MDSignedOrMDField, );
4847#undef VISIT_MD_FIELDS
4854 auto convToMetadata = [&](MDSignedOrMDField Bound) ->
Metadata * {
4855 if (Bound.isMDSignedField())
4858 if (Bound.isMDField())
4859 return Bound.getMDFieldValue();
4863 Count = convToMetadata(
count);
4864 LowerBound = convToMetadata(lowerBound);
4866 Stride = convToMetadata(stride);
4869 (Context, Count, LowerBound, UpperBound, Stride));
4877bool LLParser::parseDIGenericSubrange(
MDNode *&Result,
bool IsDistinct) {
4878#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4879 OPTIONAL(count, MDSignedOrMDField, ); \
4880 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4881 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4882 OPTIONAL(stride, MDSignedOrMDField, );
4884#undef VISIT_MD_FIELDS
4886 auto ConvToMetadata = [&](MDSignedOrMDField Bound) ->
Metadata * {
4887 if (Bound.isMDSignedField())
4889 Context, {dwarf::DW_OP_consts,
4890 static_cast<uint64_t>(Bound.getMDSignedValue())});
4891 if (Bound.isMDField())
4892 return Bound.getMDFieldValue();
4897 Metadata *LowerBound = ConvToMetadata(lowerBound);
4899 Metadata *Stride = ConvToMetadata(stride);
4902 (Context, Count, LowerBound, UpperBound, Stride));
4909bool LLParser::parseDIEnumerator(
MDNode *&Result,
bool IsDistinct) {
4910#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4911 REQUIRED(name, MDStringField, ); \
4912 REQUIRED(value, MDAPSIntField, ); \
4913 OPTIONAL(isUnsigned, MDBoolField, (false));
4915#undef VISIT_MD_FIELDS
4917 if (isUnsigned.Val &&
value.Val.isNegative())
4918 return tokError(
"unsigned enumerator with negative value");
4923 if (!isUnsigned.Val &&
value.Val.isUnsigned() &&
value.Val.isSignBitSet())
4935bool LLParser::parseDIBasicType(
MDNode *&Result,
bool IsDistinct) {
4936#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4937 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
4938 OPTIONAL(name, MDStringField, ); \
4939 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4940 OPTIONAL(align, MDUnsi