68 isa_and_nonnull<PointerType>(L.
getTyVal())) {
91 "Can't read textual IR with a Context that discards named Values");
94 if (parseTargetDefinitions())
102 validateEndOfIndex();
107 restoreParsingState(Slots);
111 if (parseType(Ty) || parseConstantValue(Ty,
C))
114 return error(Lex.
getLoc(),
"expected end of string");
120 restoreParsingState(Slots);
129 Read = End.getPointer() - Start.getPointer();
134 void LLParser::restoreParsingState(
const SlotMapping *Slots) {
141 std::make_pair(
I.getKey(), std::make_pair(
I.second,
LocTy())));
142 for (
const auto &
I : Slots->
Types)
143 NumberedTypes.insert(
144 std::make_pair(
I.first, std::make_pair(
I.second,
LocTy())));
153 for (
const auto &RAG : ForwardRefAttrGroups) {
154 Value *V = RAG.first;
155 const std::vector<unsigned> &
Attrs = RAG.second;
158 for (
const auto &Attr :
Attrs) {
159 auto R = NumberedAttrBuilders.find(Attr);
160 if (R != NumberedAttrBuilders.end())
164 if (
Function *Fn = dyn_cast<Function>(V)) {
173 if (FnAttrs.hasAlignmentAttr()) {
174 Fn->setAlignment(FnAttrs.getAlignment());
179 Fn->setAttributes(AS);
180 }
else if (
CallInst *CI = dyn_cast<CallInst>(V)) {
186 CI->setAttributes(AS);
187 }
else if (
InvokeInst *II = dyn_cast<InvokeInst>(V)) {
193 II->setAttributes(AS);
194 }
else if (
CallBrInst *CBI = dyn_cast<CallBrInst>(V)) {
200 CBI->setAttributes(AS);
201 }
else if (
auto *GV = dyn_cast<GlobalVariable>(V)) {
212 if (!ForwardRefBlockAddresses.empty())
213 return error(ForwardRefBlockAddresses.begin()->first.Loc,
214 "expected function name in blockaddress");
216 for (
const auto &
NT : NumberedTypes)
217 if (
NT.second.second.isValid())
218 return error(
NT.second.second,
219 "use of undefined type '%" +
Twine(
NT.first) +
"'");
221 for (
StringMap<std::pair<Type*, LocTy> >::iterator
I =
222 NamedTypes.begin(),
E = NamedTypes.end();
I !=
E; ++
I)
223 if (
I->second.second.isValid())
224 return error(
I->second.second,
225 "use of undefined type named '" +
I->getKey() +
"'");
227 if (!ForwardRefComdats.empty())
228 return error(ForwardRefComdats.begin()->second,
229 "use of undefined comdat '$" +
230 ForwardRefComdats.begin()->first +
"'");
232 if (!ForwardRefVals.empty())
233 return error(ForwardRefVals.begin()->second.second,
234 "use of undefined value '@" + ForwardRefVals.begin()->first +
237 if (!ForwardRefValIDs.empty())
238 return error(ForwardRefValIDs.begin()->second.second,
239 "use of undefined value '@" +
240 Twine(ForwardRefValIDs.begin()->first) +
"'");
242 if (!ForwardRefMDNodes.empty())
243 return error(ForwardRefMDNodes.begin()->second.second,
244 "use of undefined metadata '!" +
245 Twine(ForwardRefMDNodes.begin()->first) +
"'");
248 for (
auto &
N : NumberedMetadata) {
249 if (
N.second && !
N.second->isResolved())
250 N.second->resolveCycles();
253 for (
auto *Inst : InstsWithTBAATag) {
254 MDNode *MD = Inst->getMetadata(LLVMContext::MD_tbaa);
255 assert(MD &&
"UpgradeInstWithTBAATag should have a TBAA tag");
257 if (MD != UpgradedMD)
258 Inst->setMetadata(LLVMContext::MD_tbaa, UpgradedMD);
271 F.replaceAllUsesWith(Remangled.getValue());
276 if (UpgradeDebugInfo)
289 for (
const auto &
I : NamedTypes)
290 Slots->
NamedTypes.insert(std::make_pair(
I.getKey(),
I.second.first));
291 for (
const auto &
I : NumberedTypes)
292 Slots->
Types.insert(std::make_pair(
I.first,
I.second.first));
298 bool LLParser::validateEndOfIndex() {
302 if (!ForwardRefValueInfos.empty())
303 return error(ForwardRefValueInfos.begin()->second.front().second,
304 "use of undefined summary '^" +
305 Twine(ForwardRefValueInfos.begin()->first) +
"'");
307 if (!ForwardRefAliasees.empty())
308 return error(ForwardRefAliasees.begin()->second.front().second,
309 "use of undefined summary '^" +
310 Twine(ForwardRefAliasees.begin()->first) +
"'");
312 if (!ForwardRefTypeIds.empty())
313 return error(ForwardRefTypeIds.begin()->second.front().second,
314 "use of undefined type id summary '^" +
315 Twine(ForwardRefTypeIds.begin()->first) +
"'");
324 bool LLParser::parseTargetDefinitions() {
328 if (parseTargetDefinition())
332 if (parseSourceFileName())
341 bool LLParser::parseTopLevelEntities() {
349 if (parseSummaryEntry())
353 if (parseSourceFileName())
365 return tokError(
"expected top-level entity");
376 if (parseModuleAsm())
380 if (parseUnnamedType())
384 if (parseNamedType())
388 if (parseUnnamedGlobal())
392 if (parseNamedGlobal())
397 if (parseStandaloneMetadata())
401 if (parseSummaryEntry())
405 if (parseNamedMetadata())
409 if (parseUnnamedAttrGrp())
413 if (parseUseListOrder())
417 if (parseUseListOrderBB())
426 bool LLParser::parseModuleAsm() {
432 parseStringConstant(AsmStr))
442 bool LLParser::parseTargetDefinition() {
447 return tokError(
"unknown target property");
450 if (parseToken(
lltok::equal,
"expected '=' after target triple") ||
451 parseStringConstant(Str))
457 if (parseToken(
lltok::equal,
"expected '=' after target datalayout") ||
458 parseStringConstant(Str))
467 bool LLParser::parseSourceFileName() {
470 if (parseToken(
lltok::equal,
"expected '=' after source_filename") ||
471 parseStringConstant(SourceFileName))
480 bool LLParser::parseUnnamedType() {
485 if (parseToken(
lltok::equal,
"expected '=' after name") ||
490 if (parseStructDefinition(TypeLoc,
"", NumberedTypes[
TypeID], Result))
493 if (!isa<StructType>(Result)) {
494 std::pair<Type*, LocTy> &Entry = NumberedTypes[
TypeID];
496 return error(TypeLoc,
"non-struct types may not be recursive");
498 Entry.second =
SMLoc();
506 bool LLParser::parseNamedType() {
511 if (parseToken(
lltok::equal,
"expected '=' after name") ||
516 if (parseStructDefinition(NameLoc,
Name, NamedTypes[
Name], Result))
519 if (!isa<StructType>(Result)) {
520 std::pair<Type*, LocTy> &Entry = NamedTypes[
Name];
522 return error(NameLoc,
"non-struct types may not be recursive");
524 Entry.second =
SMLoc();
532 bool LLParser::parseDeclare() {
536 std::vector<std::pair<unsigned, MDNode *>> MDs;
540 if (parseMetadataAttachment(MDK,
N))
542 MDs.push_back({MDK,
N});
546 if (parseFunctionHeader(
F,
false))
549 F->addMetadata(MD.first, *MD.second);
555 bool LLParser::parseDefine() {
560 return parseFunctionHeader(
F,
true) || parseOptionalFunctionMetadata(*
F) ||
561 parseFunctionBody(*
F);
567 bool LLParser::parseGlobalType(
bool &IsConstant) {
574 return tokError(
"expected 'global' or 'constant'");
580 bool LLParser::parseOptionalUnnamedAddr(
601 bool LLParser::parseUnnamedGlobal() {
602 unsigned VarID = NumberedVals.size();
609 return error(Lex.
getLoc(),
610 "variable expected to be numbered '%" +
Twine(VarID) +
"'");
613 if (parseToken(
lltok::equal,
"expected '=' after name"))
618 unsigned Linkage, Visibility, DLLStorageClass;
622 if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
624 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
629 return parseGlobal(
Name, NameLoc, Linkage, HasLinkage, Visibility,
630 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
633 return parseAliasOrIFunc(
Name, NameLoc, Linkage, Visibility,
634 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
643 bool LLParser::parseNamedGlobal() {
650 unsigned Linkage, Visibility, DLLStorageClass;
654 if (parseToken(
lltok::equal,
"expected '=' in global variable") ||
655 parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
657 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
662 return parseGlobal(
Name, NameLoc, Linkage, HasLinkage, Visibility,
663 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
666 return parseAliasOrIFunc(
Name, NameLoc, Linkage, Visibility,
667 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
671 bool LLParser::parseComdat() {
681 return tokError(
"expected comdat type");
686 return tokError(
"unknown selection kind");
708 if (
I != ComdatSymTab.
end() && !ForwardRefComdats.erase(
Name))
709 return error(NameLoc,
"redefinition of comdat '$" +
Name +
"'");
712 if (
I != ComdatSymTab.
end())
723 bool LLParser::parseMDString(
MDString *&Result) {
725 if (parseStringConstant(Str))
733 bool LLParser::parseMDNodeID(
MDNode *&Result) {
737 if (parseUInt32(MID))
741 if (NumberedMetadata.count(MID)) {
742 Result = NumberedMetadata[MID];
747 auto &FwdRef = ForwardRefMDNodes[MID];
750 Result = FwdRef.first.get();
751 NumberedMetadata[MID].reset(Result);
757 bool LLParser::parseNamedMetadata() {
776 if (parseDIExpression(
N,
false))
782 return tokError(
"found DIArgList outside of function");
790 return parseToken(
lltok::rbrace,
"expected end of metadata node");
795 bool LLParser::parseStandaloneMetadata() {
798 unsigned MetadataID = 0;
801 if (parseUInt32(MetadataID) || parseToken(
lltok::equal,
"expected '=' here"))
806 return tokError(
"unexpected type in metadata definition");
810 if (parseSpecializedMDNode(
Init, IsDistinct))
813 parseMDTuple(
Init, IsDistinct))
817 auto FI = ForwardRefMDNodes.find(MetadataID);
818 if (FI != ForwardRefMDNodes.end()) {
819 FI->second.first->replaceAllUsesWith(
Init);
820 ForwardRefMDNodes.erase(FI);
822 assert(NumberedMetadata[MetadataID] ==
Init &&
"Tracking VH didn't work");
824 if (NumberedMetadata.count(MetadataID))
825 return tokError(
"Metadata id is already used");
826 NumberedMetadata[MetadataID].reset(
Init);
833 bool LLParser::skipModuleSummaryEntry() {
843 "Expected 'gv', 'module', 'typeid', 'flags' or 'blockcount' at the "
844 "start of summary entry");
846 return parseSummaryIndexFlags();
848 return parseBlockCount();
850 if (parseToken(
lltok::colon,
"expected ':' at start of summary entry") ||
851 parseToken(
lltok::lparen,
"expected '(' at start of summary entry"))
855 unsigned NumOpenParen = 1;
865 return tokError(
"found end of file while parsing summary entry");
871 }
while (NumOpenParen > 0);
877 bool LLParser::parseSummaryEntry() {
891 return skipModuleSummaryEntry();
908 result = parseSummaryIndexFlags();
911 result = parseBlockCount();
914 result = error(Lex.
getLoc(),
"unexpected summary kind");
935 std::string ErrString;
937 ErrOS << Message <<
" (" << *Ty1 <<
" vs " << *Ty2 <<
")";
955 bool LLParser::parseAliasOrIFunc(
const std::string &
Name, LocTy NameLoc,
956 unsigned L,
unsigned Visibility,
957 unsigned DLLStorageClass,
bool DSOLocal,
972 return error(NameLoc,
"invalid linkage type for alias");
975 return error(NameLoc,
976 "symbol with local linkage must have default visibility");
981 parseToken(
lltok::comma,
"expected comma after alias or ifunc's type"))
990 if (parseGlobalTypeAndValue(Aliasee))
995 if (parseValID(
ID,
nullptr))
998 return error(AliaseeLoc,
"invalid aliasee");
999 Aliasee =
ID.ConstantVal;
1003 auto *PTy = dyn_cast<PointerType>(AliaseeType);
1005 return error(AliaseeLoc,
"An alias or ifunc must have pointer type");
1006 unsigned AddrSpace = PTy->getAddressSpace();
1009 if (!PTy->isOpaqueOrPointeeTypeMatches(Ty))
1013 "explicit pointee type doesn't match operand's pointee type", Ty,
1014 PTy->getNonOpaquePointerElementType()));
1016 if (!PTy->isOpaque() &&
1017 !PTy->getNonOpaquePointerElementType()->isFunctionTy())
1018 return error(ExplicitTypeLoc,
1019 "explicit pointee type should be a function type");
1026 if (!
Name.empty()) {
1027 auto I = ForwardRefVals.find(
Name);
1028 if (
I != ForwardRefVals.end()) {
1029 GVal =
I->second.first;
1030 ForwardRefVals.erase(
Name);
1032 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1035 auto I = ForwardRefValIDs.find(NumberedVals.size());
1036 if (
I != ForwardRefValIDs.end()) {
1037 GVal =
I->second.first;
1038 ForwardRefValIDs.erase(
I);
1043 std::unique_ptr<GlobalAlias> GA;
1044 std::unique_ptr<GlobalIFunc> GI;
1074 return tokError(
"unknown alias or ifunc property!");
1079 NumberedVals.push_back(GV);
1086 "forward reference and definition of alias have different types");
1117 bool LLParser::parseGlobal(
const std::string &
Name, LocTy NameLoc,
1118 unsigned Linkage,
bool HasLinkage,
1119 unsigned Visibility,
unsigned DLLStorageClass,
1123 return error(NameLoc,
1124 "symbol with local linkage must have default visibility");
1128 LocTy IsExternallyInitializedLoc;
1132 if (parseOptionalAddrSpace(AddrSpace) ||
1134 IsExternallyInitialized,
1135 &IsExternallyInitializedLoc) ||
1136 parseGlobalType(IsConstant) || parseType(Ty, TyLoc))
1145 if (parseGlobalValue(Ty,
Init))
1150 return error(TyLoc,
"invalid type for global variable");
1155 if (!
Name.empty()) {
1156 auto I = ForwardRefVals.find(
Name);
1157 if (
I != ForwardRefVals.end()) {
1158 GVal =
I->second.first;
1159 ForwardRefVals.erase(
I);
1161 return error(NameLoc,
"redefinition of global '@" +
Name +
"'");
1164 auto I = ForwardRefValIDs.find(NumberedVals.size());
1165 if (
I != ForwardRefValIDs.end()) {
1166 GVal =
I->second.first;
1167 ForwardRefValIDs.erase(
I);
1176 NumberedVals.push_back(GV);
1194 "forward reference and definition of global have different types");
1214 }
else if (Lex.
getKind() == lltok::kw_align) {
1216 if (parseOptionalAlignment(Alignment))
1220 if (parseGlobalObjectMetadataAttachment(*GV))
1224 if (parseOptionalComdat(
Name,
C))
1229 return tokError(
"unknown global variable property!");
1235 std::vector<unsigned> FwdRefAttrGrps;
1236 if (parseFnAttributeValuePairs(
Attrs, FwdRefAttrGrps,
false, BuiltinLoc))
1238 if (
Attrs.hasAttributes() || !FwdRefAttrGrps.
empty()) {
1240 ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
1248 bool LLParser::parseUnnamedAttrGrp() {
1254 return tokError(
"expected attribute group id");
1257 std::vector<unsigned> unused;
1265 auto R = NumberedAttrBuilders.find(VarID);
1266 if (R == NumberedAttrBuilders.end())
1269 if (parseFnAttributeValuePairs(
R->second, unused,
true, BuiltinLoc) ||
1270 parseToken(
lltok::rbrace,
"expected end of attribute group"))
1273 if (!
R->second.hasAttributes())
1274 return error(AttrGrpLoc,
"attribute group has no attributes");
1281 #define GET_ATTR_NAMES
1282 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
1283 case lltok::kw_##DISPLAY_NAME: \
1284 return Attribute::ENUM_NAME;
1285 #include "llvm/IR/Attributes.inc"
1294 return parseRequiredTypeAttr(
B, Lex.
getKind(), Attr);
1297 case Attribute::Alignment: {
1306 if (parseOptionalAlignment(Alignment,
true))
1309 B.addAlignmentAttr(Alignment);
1312 case Attribute::StackAlignment: {
1317 parseUInt32(Alignment))
1320 if (parseOptionalStackAlignment(Alignment))
1323 B.addStackAlignmentAttr(Alignment);
1326 case Attribute::AllocSize: {
1327 unsigned ElemSizeArg;
1329 if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
1331 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1334 case Attribute::VScaleRange: {
1335 unsigned MinValue, MaxValue;
1336 if (parseVScaleRangeArguments(MinValue, MaxValue))
1338 B.addVScaleRangeAttr(MinValue,
1342 case Attribute::Dereferenceable: {
1344 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1346 B.addDereferenceableAttr(Bytes);
1349 case Attribute::DereferenceableOrNull: {
1351 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1353 B.addDereferenceableOrNullAttr(Bytes);
1356 case Attribute::UWTable: {
1358 if (parseOptionalUWTableKind(
Kind))
1360 B.addUWTableAttr(
Kind);
1364 B.addAttribute(Attr);
1372 bool LLParser::parseFnAttributeValuePairs(
AttrBuilder &
B,
1373 std::vector<unsigned> &FwdRefAttrGrps,
1374 bool InAttrGrp, LocTy &BuiltinLoc) {
1375 bool HaveError =
false;
1385 if (parseStringAttribute(
B))
1397 "cannot have an attribute group reference in an attribute group");
1407 if (Token == lltok::kw_builtin)
1414 return error(Lex.
getLoc(),
"unterminated attribute group");
1417 if (parseEnumAttribute(Attr,
B, InAttrGrp))
1424 HaveError |= error(Loc,
"this attribute does not apply to functions");
1442 if (
auto *FT = dyn_cast<FunctionType>(ElemTy))
1457 error(Loc,
"'" +
Name +
"' is not a basic block");
1459 error(Loc,
"'" +
Name +
"' defined with type '" +
1472 error(Loc,
"global variable reference must have pointer type");
1483 auto I = ForwardRefVals.find(
Name);
1484 if (
I != ForwardRefVals.end())
1485 Val =
I->second.first;
1490 return cast_or_null<GlobalValue>(
1491 checkValidVariableType(Loc,
"@" +
Name, Ty, Val));
1495 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
1502 error(Loc,
"global variable reference must have pointer type");
1506 GlobalValue *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
1511 auto I = ForwardRefValIDs.find(
ID);
1512 if (
I != ForwardRefValIDs.end())
1513 Val =
I->second.first;
1518 return cast_or_null<GlobalValue>(
1519 checkValidVariableType(Loc,
"@" +
Twine(
ID), Ty, Val));
1523 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
1531 Comdat *LLParser::getComdat(
const std::string &
Name, LocTy Loc) {
1535 if (
I != ComdatSymTab.
end())
1540 ForwardRefComdats[
Name] = Loc;
1550 bool LLParser::parseToken(
lltok::Kind T,
const char *ErrMsg) {
1552 return tokError(ErrMsg);
1559 bool LLParser::parseStringConstant(std::string &Result) {
1561 return tokError(
"expected string constant");
1569 bool LLParser::parseUInt32(
uint32_t &Val) {
1571 return tokError(
"expected integer");
1573 if (Val64 !=
unsigned(Val64))
1574 return tokError(
"expected 32-bit integer (too large)");
1582 bool LLParser::parseUInt64(
uint64_t &Val) {
1584 return tokError(
"expected integer");
1597 return tokError(
"expected localdynamic, initialexec or localexec");
1625 return parseTLSModel(TLM) ||
1626 parseToken(
lltok::rparen,
"expected ')' after thread local model");
1634 bool LLParser::parseOptionalAddrSpace(
unsigned &AddrSpace,
unsigned DefaultAS) {
1635 AddrSpace = DefaultAS;
1638 return parseToken(
lltok::lparen,
"expected '(' in address space") ||
1639 parseUInt32(AddrSpace) ||
1650 if (EatIfPresent(
lltok::equal) && parseStringConstant(Val))
1652 B.addAttribute(Attr, Val);
1657 bool LLParser::parseOptionalParamOrReturnAttrs(
AttrBuilder &
B,
bool IsParam) {
1658 bool HaveError =
false;
1665 if (parseStringAttribute(
B))
1675 if (parseEnumAttribute(Attr,
B,
false))
1679 HaveError |= error(Loc,
"this attribute does not apply to parameters");
1681 HaveError |= error(Loc,
"this attribute does not apply to return values");
1729 bool LLParser::parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
1730 unsigned &Visibility,
1731 unsigned &DLLStorageClass,
bool &DSOLocal) {
1735 parseOptionalDSOLocal(DSOLocal);
1736 parseOptionalVisibility(Visibility);
1737 parseOptionalDLLStorageClass(DLLStorageClass);
1740 return error(Lex.
getLoc(),
"dso_location and DLL-StorageClass mismatch");
1746 void LLParser::parseOptionalDSOLocal(
bool &DSOLocal) {
1768 void LLParser::parseOptionalVisibility(
unsigned &Res) {
1791 void LLParser::parseOptionalDLLStorageClass(
unsigned &Res) {
1853 bool LLParser::parseOptionalCallingConv(
unsigned &CC) {
1905 return parseUInt32(CC);
1915 bool LLParser::parseMetadataAttachment(
unsigned &
Kind,
MDNode *&MD) {
1922 return parseMDNode(MD);
1927 bool LLParser::parseInstructionMetadata(
Instruction &Inst) {
1930 return tokError(
"expected metadata after comma");
1934 if (parseMetadataAttachment(MDK,
N))
1938 if (MDK == LLVMContext::MD_tbaa)
1939 InstsWithTBAATag.push_back(&Inst);
1948 bool LLParser::parseGlobalObjectMetadataAttachment(
GlobalObject &GO) {
1951 if (parseMetadataAttachment(MDK,
N))
1960 bool LLParser::parseOptionalFunctionMetadata(
Function &
F) {
1962 if (parseGlobalObjectMetadataAttachment(
F))
1970 bool LLParser::parseOptionalAlignment(
MaybeAlign &Alignment,
bool AllowParens) {
1972 if (!EatIfPresent(lltok::kw_align))
1978 bool HaveParens =
false;
1984 if (parseUInt64(
Value))
1988 return error(ParenLoc,
"expected ')'");
1991 return error(AlignLoc,
"alignment is not a power of two");
1993 return error(AlignLoc,
"huge alignments are not supported yet");
2003 bool LLParser::parseOptionalDerefAttrBytes(
lltok::Kind AttrKind,
2005 assert((AttrKind == lltok::kw_dereferenceable ||
2006 AttrKind == lltok::kw_dereferenceable_or_null) &&
2010 if (!EatIfPresent(AttrKind))
2014 return error(ParenLoc,
"expected '('");
2016 if (parseUInt64(Bytes))
2020 return error(ParenLoc,
"expected ')'");
2022 return error(DerefLoc,
"dereferenceable bytes must be non-zero");
2037 return error(KindLoc,
"expected unwind table kind");
2048 bool LLParser::parseOptionalCommaAlign(
MaybeAlign &Alignment,
2049 bool &AteExtraComma) {
2050 AteExtraComma =
false;
2054 AteExtraComma =
true;
2058 if (Lex.
getKind() != lltok::kw_align)
2059 return error(Lex.
getLoc(),
"expected metadata or 'align'");
2061 if (parseOptionalAlignment(Alignment))
2074 bool LLParser::parseOptionalCommaAddrSpace(
unsigned &AddrSpace, LocTy &Loc,
2075 bool &AteExtraComma) {
2076 AteExtraComma =
false;
2080 AteExtraComma =
true;
2086 return error(Lex.
getLoc(),
"expected metadata or 'addrspace'");
2088 if (parseOptionalAddrSpace(AddrSpace))
2095 bool LLParser::parseAllocSizeArguments(
unsigned &BaseSizeArg,
2099 auto StartParen = Lex.
getLoc();
2101 return error(StartParen,
"expected '('");
2103 if (parseUInt32(BaseSizeArg))
2107 auto HowManyAt = Lex.
getLoc();
2109 if (parseUInt32(HowMany))
2111 if (HowMany == BaseSizeArg)
2112 return error(HowManyAt,
2113 "'allocsize' indices can't refer to the same parameter");
2114 HowManyArg = HowMany;
2118 auto EndParen = Lex.
getLoc();
2120 return error(EndParen,
"expected ')'");
2124 bool LLParser::parseVScaleRangeArguments(
unsigned &MinValue,
2125 unsigned &MaxValue) {
2128 auto StartParen = Lex.
getLoc();
2130 return error(StartParen,
"expected '('");
2132 if (parseUInt32(MinValue))
2136 if (parseUInt32(MaxValue))
2139 MaxValue = MinValue;
2141 auto EndParen = Lex.
getLoc();
2143 return error(EndParen,
"expected ')'");
2152 bool LLParser::parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
2157 return parseScope(SSID) || parseOrdering(Ordering);
2167 auto StartParenAt = Lex.
getLoc();
2169 return error(StartParenAt,
"Expected '(' in syncscope");
2172 auto SSNAt = Lex.
getLoc();
2173 if (parseStringConstant(SSN))
2174 return error(SSNAt,
"Expected synchronization scope name");
2176 auto EndParenAt = Lex.
getLoc();
2178 return error(EndParenAt,
"Expected ')' in syncscope");
2193 return tokError(
"Expected ordering on atomic instruction");
2212 bool LLParser::parseOptionalStackAlignment(
unsigned &Alignment) {
2214 if (!EatIfPresent(lltok::kw_alignstack))
2218 return error(ParenLoc,
"expected '('");
2220 if (parseUInt32(Alignment))
2224 return error(ParenLoc,
"expected ')'");
2226 return error(AlignLoc,
"stack alignment is not a power of two");
2240 bool &AteExtraComma) {
2241 AteExtraComma =
false;
2244 return tokError(
"expected ',' as start of index list");
2248 if (Indices.empty())
2249 return tokError(
"expected index");
2250 AteExtraComma =
true;
2254 if (parseUInt32(Idx))
2256 Indices.push_back(Idx);
2267 bool LLParser::parseType(
Type *&Result,
const Twine &
Msg,
bool AllowVoid) {
2271 return tokError(
Msg);
2280 if (
Result->isOpaquePointerTy()) {
2282 if (parseOptionalAddrSpace(AddrSpace))
2288 return tokError(
"ptr* is invalid - use ptr instead");
2299 if (parseAnonStructType(Result,
false))
2305 if (parseArrayVectorType(Result,
false))
2312 if (parseAnonStructType(Result,
true) ||
2313 parseToken(
lltok::greater,
"expected '>' at end of packed struct"))
2315 }
else if (parseArrayVectorType(Result,
true))
2320 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.
getStrVal()];
2326 Entry.second = Lex.
getLoc();
2335 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.
getUIntVal()];
2341 Entry.second = Lex.
getLoc();
2354 if (!AllowVoid &&
Result->isVoidTy())
2355 return error(TypeLoc,
"void type only allowed for function results");
2361 return tokError(
"basic block pointers are invalid");
2363 return tokError(
"pointers to void are invalid - use i8* instead");
2365 return tokError(
"pointer to this type is invalid");
2373 return tokError(
"basic block pointers are invalid");
2375 return tokError(
"pointers to void are invalid; use i8* instead");
2377 return tokError(
"pointer to this type is invalid");
2379 if (parseOptionalAddrSpace(AddrSpace) ||
2380 parseToken(
lltok::star,
"expected '*' in address space"))
2389 if (parseFunctionType(Result))
2402 PerFunctionState &PFS,
bool IsMustTailCall,
2403 bool InVarArgsFunc) {
2409 if (!ArgList.empty() &&
2410 parseToken(
lltok::comma,
"expected ',' in argument list"))
2415 const char *
Msg =
"unexpected ellipsis in argument list for ";
2416 if (!IsMustTailCall)
2417 return tokError(
Twine(
Msg) +
"non-musttail call");
2419 return tokError(
Twine(
Msg) +
"musttail call in non-varargs function");
2421 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
2426 Type *ArgTy =
nullptr;
2428 if (parseType(ArgTy, ArgLoc))
2434 if (parseMetadataAsValue(V, PFS))
2438 if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
2441 ArgList.push_back(ParamInfo(
2445 if (IsMustTailCall && InVarArgsFunc)
2446 return tokError(
"expected '...' at end of argument list for musttail call "
2447 "in varargs function");
2458 if (!EatIfPresent(AttrToken))
2461 return error(Lex.
getLoc(),
"expected '('");
2465 return error(Lex.
getLoc(),
"expected ')'");
2467 B.addTypeAttr(AttrKind, Ty);
2480 bool LLParser::parseOptionalOperandBundles(
2488 if (!BundleList.empty() &&
2489 parseToken(
lltok::comma,
"expected ',' in input list"))
2493 if (parseStringConstant(Tag))
2496 if (parseToken(
lltok::lparen,
"expected '(' in operand bundle"))
2499 std::vector<Value *> Inputs;
2502 if (!Inputs.empty() &&
2503 parseToken(
lltok::comma,
"expected ',' in input list"))
2508 if (parseType(Ty) || parseValue(Ty, Input, PFS))
2510 Inputs.push_back(Input);
2518 if (BundleList.empty())
2519 return error(BeginLoc,
"operand bundle set must not be empty");
2536 unsigned CurValID = 0;
2548 Type *ArgTy =
nullptr;
2552 if (parseType(ArgTy) || parseOptionalParamAttrs(
Attrs))
2556 return error(TypeLoc,
"argument can not have void type");
2563 return error(TypeLoc,
"argument expected to be numbered '%" +
2564 Twine(CurValID) +
"'");
2570 return error(TypeLoc,
"invalid type for function argument");
2585 if (parseType(ArgTy) || parseOptionalParamAttrs(
Attrs))
2589 return error(TypeLoc,
"argument can not have void type");
2597 return error(TypeLoc,
"argument expected to be numbered '%" +
2598 Twine(CurValID) +
"'");
2606 return error(TypeLoc,
"invalid type for function argument");
2614 return parseToken(
lltok::rparen,
"expected ')' at end of argument list");
2619 bool LLParser::parseFunctionType(
Type *&Result) {
2623 return tokError(
"invalid function return type");
2627 if (parseArgumentList(ArgList, IsVarArg))
2631 for (
unsigned i = 0,
e = ArgList.size();
i !=
e; ++
i) {
2632 if (!ArgList[
i].
Name.empty())
2633 return error(ArgList[
i].Loc,
"argument name invalid in function type");
2634 if (ArgList[
i].
Attrs.hasAttributes())
2635 return error(ArgList[
i].Loc,
2636 "argument attributes invalid in function type");
2640 for (
unsigned i = 0,
e = ArgList.size();
i !=
e; ++
i)
2641 ArgListTy.push_back(ArgList[
i].Ty);
2649 bool LLParser::parseAnonStructType(
Type *&Result,
bool Packed) {
2651 if (parseStructBody(Elts))
2660 std::pair<Type *, LocTy> &Entry,
2663 if (Entry.first && !Entry.second.isValid())
2664 return error(TypeLoc,
"redefinition of type");
2670 Entry.second =
SMLoc();
2675 ResultTy = Entry.first;
2687 return error(TypeLoc,
"forward references to non-struct type");
2691 return parseArrayVectorType(ResultTy,
true);
2692 return parseType(ResultTy);
2696 Entry.second =
SMLoc();
2702 StructType *STy = cast<StructType>(Entry.first);
2705 if (parseStructBody(Body) ||
2706 (isPacked && parseToken(
lltok::greater,
"expected '>' in packed struct")))
2735 return error(EltTyLoc,
"invalid element type for struct");
2743 return error(EltTyLoc,
"invalid element type for struct");
2748 return parseToken(
lltok::rbrace,
"expected '}' at end of struct");
2757 bool LLParser::parseArrayVectorType(
Type *&Result,
bool IsVector) {
2758 bool Scalable =
false;
2762 if (parseToken(
lltok::kw_x,
"expected 'x' after vscale"))
2770 return tokError(
"expected number in address space");
2776 if (parseToken(
lltok::kw_x,
"expected 'x' after element count"))
2780 Type *EltTy =
nullptr;
2781 if (parseType(EltTy))
2785 "expected end of sequential type"))
2790 return error(SizeLoc,
"zero element vector is illegal");
2791 if ((
unsigned)Size != Size)
2792 return error(SizeLoc,
"size too large for vector");
2794 return error(TypeLoc,
"invalid vector element type");
2798 return error(TypeLoc,
"invalid array element type");
2810 :
P(
p),
F(
f), FunctionNumber(functionNumber) {
2815 NumberedVals.push_back(&
A);
2818 LLParser::PerFunctionState::~PerFunctionState() {
2821 for (
const auto &
P : ForwardRefVals) {
2822 if (isa<BasicBlock>(
P.second.first))
2824 P.second.first->replaceAllUsesWith(
2826 P.second.first->deleteValue();
2829 for (
const auto &
P : ForwardRefValIDs) {
2830 if (isa<BasicBlock>(
P.second.first))
2832 P.second.first->replaceAllUsesWith(
2834 P.second.first->deleteValue();
2838 bool LLParser::PerFunctionState::finishFunction() {
2839 if (!ForwardRefVals.empty())
2840 return P.error(ForwardRefVals.begin()->second.second,
2841 "use of undefined value '%" + ForwardRefVals.begin()->first +
2843 if (!ForwardRefValIDs.empty())
2844 return P.error(ForwardRefValIDs.begin()->second.second,
2845 "use of undefined value '%" +
2846 Twine(ForwardRefValIDs.begin()->first) +
"'");
2856 Value *Val =
F.getValueSymbolTable()->lookup(
Name);
2861 auto I = ForwardRefVals.find(
Name);
2862 if (
I != ForwardRefVals.end())
2863 Val =
I->second.first;
2868 return P.checkValidVariableType(Loc,
"%" +
Name, Ty, Val);
2872 P.error(Loc,
"invalid use of a non-first-class type");
2879 FwdVal = BasicBlock::Create(
F.getContext(),
Name, &
F);
2884 ForwardRefVals[
Name] = std::make_pair(FwdVal, Loc);
2890 Value *Val =
ID < NumberedVals.size() ? NumberedVals[
ID] :
nullptr;
2895 auto I = ForwardRefValIDs.find(
ID);
2896 if (
I != ForwardRefValIDs.end())
2897 Val =
I->second.first;
2902 return P.checkValidVariableType(Loc,
"%" +
Twine(
ID), Ty, Val);
2905 P.error(Loc,
"invalid use of a non-first-class type");
2912 FwdVal = BasicBlock::Create(
F.getContext(),
"", &
F);
2917 ForwardRefValIDs[
ID] = std::make_pair(FwdVal, Loc);
2923 bool LLParser::PerFunctionState::setInstName(
int NameID,
2924 const std::string &NameStr,
2928 if (NameID != -1 || !NameStr.empty())
2929 return P.error(NameLoc,
"instructions returning void cannot have a name");
2935 if (NameStr.empty()) {
2938 NameID = NumberedVals.size();
2940 if (
unsigned(NameID) != NumberedVals.size())
2941 return P.error(NameLoc,
"instruction expected to be numbered '%" +
2942 Twine(NumberedVals.size()) +
"'");
2944 auto FI = ForwardRefValIDs.find(NameID);
2945 if (FI != ForwardRefValIDs.end()) {
2946 Value *Sentinel = FI->second.first;
2948 return P.error(NameLoc,
"instruction forward referenced with type '" +
2954 ForwardRefValIDs.erase(FI);
2957 NumberedVals.push_back(Inst);
2962 auto FI = ForwardRefVals.find(NameStr);
2963 if (FI != ForwardRefVals.end()) {
2964 Value *Sentinel = FI->second.first;
2966 return P.error(NameLoc,
"instruction forward referenced with type '" +
2972 ForwardRefVals.erase(FI);
2978 if (Inst->
getName() != NameStr)
2979 return P.error(NameLoc,
"multiple definition of local value named '" +
2986 BasicBlock *LLParser::PerFunctionState::getBB(
const std::string &
Name,
2988 return dyn_cast_or_null<BasicBlock>(
2989 getVal(
Name, Type::getLabelTy(
F.getContext()), Loc));
2992 BasicBlock *LLParser::PerFunctionState::getBB(
unsigned ID, LocTy Loc) {
2993 return dyn_cast_or_null<BasicBlock>(
2994 getVal(
ID, Type::getLabelTy(
F.getContext()), Loc));
3000 BasicBlock *LLParser::PerFunctionState::defineBB(
const std::string &
Name,
3001 int NameID, LocTy Loc) {
3004 if (NameID != -1 &&
unsigned(NameID) != NumberedVals.size()) {
3005 P.error(Loc,
"label expected to be numbered '" +
3006 Twine(NumberedVals.size()) +
"'");
3009 BB = getBB(NumberedVals.size(), Loc);
3011 P.error(Loc,
"unable to create block numbered '" +
3012 Twine(NumberedVals.size()) +
"'");
3018 P.error(Loc,
"unable to create block named '" +
Name +
"'");
3025 F.getBasicBlockList().splice(
F.end(),
F.getBasicBlockList(),
BB);
3029 ForwardRefValIDs.erase(NumberedVals.size());
3030 NumberedVals.push_back(
BB);
3033 ForwardRefVals.erase(
Name);
3050 bool LLParser::parseValID(
ValID &
ID, PerFunctionState *PFS,
Type *ExpectedTy) {
3054 return tokError(
"expected value token");
3097 if (parseGlobalValueVector(Elts) ||
3098 parseToken(
lltok::rbrace,
"expected end of struct constant"))
3101 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.size());
3102 ID.UIntVal = Elts.size();
3103 memcpy(
ID.ConstantStructElts.get(), Elts.data(),
3104 Elts.size() *
sizeof(Elts[0]));
3116 if (parseGlobalValueVector(Elts) ||
3118 parseToken(
lltok::rbrace,
"expected end of packed struct")) ||
3122 if (isPackedStruct) {
3123 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.size());
3124 memcpy(
ID.ConstantStructElts.get(), Elts.data(),
3125 Elts.size() *
sizeof(Elts[0]));
3126 ID.UIntVal = Elts.size();
3132 return error(
ID.Loc,
"constant vector must not be empty");
3134 if (!Elts[0]->
getType()->isIntegerTy() &&
3135 !Elts[0]->
getType()->isFloatingPointTy() &&
3136 !Elts[0]->
getType()->isPointerTy())
3139 "vector elements must have integer, pointer or floating point type");
3142 for (
unsigned i = 1,
e = Elts.size();
i !=
e; ++
i)
3144 return error(FirstEltLoc,
"vector element #" +
Twine(
i) +
3145 " is not of type '" +
3156 if (parseGlobalValueVector(Elts) ||
3168 if (!Elts[0]->
getType()->isFirstClassType())
3169 return error(FirstEltLoc,
"invalid array element type: " +
3175 for (
unsigned i = 0,
e = Elts.size();
i !=
e; ++
i) {
3177 return error(FirstEltLoc,
"array element #" +
Twine(
i) +
3178 " is not of type '" +
3198 bool HasSideEffect, AlignStack, AsmDialect, CanThrow;
3201 parseOptionalToken(lltok::kw_alignstack, AlignStack) ||
3204 parseStringConstant(
ID.StrVal) ||
3205 parseToken(
lltok::comma,
"expected comma in inline asm expression") ||
3209 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack) << 1) |
3210 (
unsigned(AsmDialect) << 2) | (
unsigned(CanThrow) << 3);
3221 if (parseToken(
lltok::lparen,
"expected '(' in block address expression") ||
3222 parseValID(Fn, PFS) ||
3224 "expected comma in block address expression") ||
3225 parseValID(Label, PFS) ||
3226 parseToken(
lltok::rparen,
"expected ')' in block address expression"))
3230 return error(Fn.
Loc,
"expected function name in blockaddress");
3232 return error(
Label.Loc,
"expected basic block name in blockaddress");
3237 if (Fn.
UIntVal < NumberedVals.size())
3238 GV = NumberedVals[Fn.
UIntVal];
3239 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3245 if (!isa<Function>(GV))
3246 return error(Fn.
Loc,
"expected function name in blockaddress");
3247 F = cast<Function>(GV);
3248 if (
F->isDeclaration())
3249 return error(Fn.
Loc,
"cannot take blockaddress inside a declaration");
3255 ForwardRefBlockAddresses.insert(std::make_pair(
3257 std::map<ValID, GlobalValue *>()))
3258 .first->second.insert(std::make_pair(
std::move(Label),
nullptr))
3266 return error(
ID.Loc,
3267 "type of blockaddress must be a pointer and not '" +
3272 FwdDeclAS = PFS->getFunction().getAddressSpace();
3281 ID.ConstantVal = FwdRef;
3289 if (BlockAddressPFS &&
F == &BlockAddressPFS->getFunction()) {
3295 return error(
Label.Loc,
"referenced value is not a basic block");
3298 return error(
Label.Loc,
"cannot take address of numeric label after "
3299 "the function is defined");
3300 BB = dyn_cast_or_null<BasicBlock>(
3301 F->getValueSymbolTable()->lookup(
Label.StrVal));
3303 return error(
Label.Loc,
"referenced value is not a basic block");
3317 if (parseValID(Fn, PFS))
3321 return error(Fn.
Loc,
3322 "expected global value name in dso_local_equivalent");
3327 if (Fn.
UIntVal < NumberedVals.size())
3328 GV = NumberedVals[Fn.
UIntVal];
3329 }
else if (!ForwardRefVals.count(Fn.
StrVal)) {
3333 assert(GV &&
"Could not find a corresponding global variable");
3336 return error(Fn.
Loc,
"expected a function, alias to function, or ifunc "
3337 "in dso_local_equivalent");
3348 if (parseValID(
ID, PFS))
3352 return error(
ID.Loc,
"expected global value name in no_cfi");
3372 Type *DestTy =
nullptr;
3375 if (parseToken(
lltok::lparen,
"expected '(' after constantexpr cast") ||
3376 parseGlobalTypeAndValue(SrcVal) ||
3377 parseToken(
lltok::kw_to,
"expected 'to' in constantexpr cast") ||
3378 parseType(DestTy) ||
3379 parseToken(
lltok::rparen,
"expected ')' at end of constantexpr cast"))
3382 return error(
ID.Loc,
"invalid cast opcode for cast from '" +
3395 "expected '(' in extractvalue constantexpr") ||
3396 parseGlobalTypeAndValue(Val) || parseIndexList(Indices) ||
3397 parseToken(
lltok::rparen,
"expected ')' in extractvalue constantexpr"))
3401 return error(
ID.Loc,
"extractvalue operand must be aggregate type");
3403 return error(
ID.Loc,
"invalid indices for extractvalue");
3412 if (parseToken(
lltok::lparen,
"expected '(' in insertvalue constantexpr") ||
3413 parseGlobalTypeAndValue(Val0) ||
3415 "expected comma in insertvalue constantexpr") ||
3416 parseGlobalTypeAndValue(Val1) || parseIndexList(Indices) ||
3417 parseToken(
lltok::rparen,
"expected ')' in insertvalue constantexpr"))
3420 return error(
ID.Loc,
"insertvalue operand must be aggregate type");
3424 return error(
ID.Loc,
"invalid indices for insertvalue");
3425 if (IndexedType != Val1->
getType())
3426 return error(
ID.Loc,
"insertvalue operand and field disagree in type: '" +
3439 if (parseCmpPredicate(PredVal, Opc) ||
3440 parseToken(
lltok::lparen,
"expected '(' in compare constantexpr") ||
3441 parseGlobalTypeAndValue(Val0) ||
3442 parseToken(
lltok::comma,
"expected comma in compare constantexpr") ||
3443 parseGlobalTypeAndValue(Val1) ||
3444 parseToken(
lltok::rparen,
"expected ')' in compare constantexpr"))
3448 return error(
ID.Loc,
"compare operands must have the same type");
3452 if (Opc == Instruction::FCmp) {
3454 return error(
ID.Loc,
"fcmp requires floating point operands");
3457 assert(Opc == Instruction::ICmp &&
"Unexpected opcode for CmpInst!");
3460 return error(
ID.Loc,
"icmp requires pointer or integer operands");
3472 if (parseToken(
lltok::lparen,
"expected '(' in unary constantexpr") ||
3473 parseGlobalTypeAndValue(Val) ||
3474 parseToken(
lltok::rparen,
"expected ')' in unary constantexpr"))
3479 case Instruction::FNeg:
3481 return error(
ID.Loc,
"constexpr requires fp operands");
3522 }
else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
3523 Opc == Instruction::LShr || Opc == Instruction::AShr) {
3527 if (parseToken(
lltok::lparen,
"expected '(' in binary constantexpr") ||
3528 parseGlobalTypeAndValue(Val0) ||
3529 parseToken(
lltok::comma,
"expected comma in binary constantexpr") ||
3530 parseGlobalTypeAndValue(Val1) ||
3531 parseToken(
lltok::rparen,
"expected ')' in binary constantexpr"))
3534 return error(
ID.Loc,
"operands of constexpr must have same type");
3538 case Instruction::Sub:
3540 case Instruction::UDiv:
3541 case Instruction::SDiv:
3542 case Instruction::URem:
3543 case Instruction::SRem:
3544 case Instruction::Shl:
3545 case Instruction::AShr:
3546 case Instruction::LShr:
3548 return error(
ID.Loc,
"constexpr requires integer operands");
3550 case Instruction::FAdd:
3551 case Instruction::FSub:
3552 case Instruction::FMul:
3553 case Instruction::FDiv:
3554 case Instruction::FRem:
3556 return error(
ID.Loc,
"constexpr requires fp operands");
3577 if (parseToken(
lltok::lparen,
"expected '(' in logical constantexpr") ||
3578 parseGlobalTypeAndValue(Val0) ||
3579 parseToken(
lltok::comma,
"expected comma in logical constantexpr") ||
3580 parseGlobalTypeAndValue(Val1) ||
3581 parseToken(
lltok::rparen,
"expected ')' in logical constantexpr"))
3584 return error(
ID.Loc,
"operands of constexpr must have same type");
3586 return error(
ID.Loc,
3587 "constexpr requires integer or integer vector operands");
3600 bool InBounds =
false;
3604 if (Opc == Instruction::GetElementPtr)
3607 if (parseToken(
lltok::lparen,
"expected '(' in constantexpr"))
3611 if (Opc == Instruction::GetElementPtr) {
3612 if (parseType(Ty) ||
3613 parseToken(
lltok::comma,
"expected comma after getelementptr's type"))
3618 if (parseGlobalValueVector(
3619 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp :
nullptr) ||
3623 if (Opc == Instruction::GetElementPtr) {
3624 if (Elts.size() == 0 ||
3625 !Elts[0]->getType()->isPtrOrPtrVectorTy())
3626 return error(
ID.Loc,
"base of getelementptr must be a pointer");
3629 auto *BasePointerType = cast<PointerType>(
BaseType->getScalarType());
3630 if (!BasePointerType->isOpaqueOrPointeeTypeMatches(Ty)) {
3634 "explicit pointee type doesn't match operand's pointee type",
3635 Ty, BasePointerType->getNonOpaquePointerElementType()));
3640 ? cast<FixedVectorType>(
BaseType)->getNumElements()
3647 return error(
ID.Loc,
"getelementptr index must be an integer");
3648 if (
auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
3649 unsigned ValNumEl = cast<FixedVectorType>(ValVTy)->getNumElements();
3650 if (GEPWidth && (ValNumEl != GEPWidth))
3653 "getelementptr vector index has a wrong number of elements");
3656 GEPWidth = ValNumEl;
3661 if (!Indices.empty() && !Ty->
isSized(&Visited))
3662 return error(
ID.Loc,
"base element of getelementptr must be sized");
3665 return error(
ID.Loc,
"invalid getelementptr indices");
3668 if (*InRangeOp == 0)
3669 return error(
ID.Loc,
3670 "inrange keyword may not appear on pointer operand");
3675 InBounds, InRangeOp);
3677 if (Elts.size() != 3)
3678 return error(
ID.Loc,
"expected three operands to select");
3681 return error(
ID.Loc, Reason);
3683 }
else if (Opc == Instruction::ShuffleVector) {
3684 if (Elts.size() != 3)
3685 return error(
ID.Loc,
"expected three operands to shufflevector");
3687 return error(
ID.Loc,
"invalid operands to shufflevector");
3691 }
else if (Opc == Instruction::ExtractElement) {
3692 if (Elts.size() != 2)
3693 return error(
ID.Loc,
"expected two operands to extractelement");
3695 return error(
ID.Loc,
"invalid extractelement operands");
3698 assert(Opc == Instruction::InsertElement &&
"Unknown opcode");
3699 if (Elts.size() != 3)
3700 return error(
ID.Loc,
"expected three operands to insertelement");
3702 return error(
ID.Loc,
"invalid insertelement operands");
3721 bool Parsed = parseValID(
ID,
nullptr, Ty) ||
3722 convertValIDToValue(Ty,
ID, V,
nullptr);
3723 if (V && !(
C = dyn_cast<Constant>(V)))
3724 return error(
ID.Loc,
"global values must be constants");
3728 bool LLParser::parseGlobalTypeAndValue(
Constant *&V) {
3730 return parseType(Ty) || parseGlobalValue(Ty, V);
3742 return tokError(
"expected comdat variable");
3745 if (parseToken(
lltok::rparen,
"expected ')' after comdat var"))
3748 if (GlobalName.
empty())
3749 return tokError(
"comdat cannot be unnamed");
3750 C = getComdat(std::string(GlobalName), KwLoc);
3770 *InRangeOp = Elts.size();
3773 if (parseGlobalTypeAndValue(
C))
3781 bool LLParser::parseMDTuple(
MDNode *&MD,
bool IsDistinct) {
3783 if (parseMDNodeVector(Elts))
3794 bool LLParser::parseMDNode(
MDNode *&
N) {
3796 return parseSpecializedMDNode(
N);
3798 return parseToken(
lltok::exclaim,
"expected '!' here") || parseMDNodeTail(
N);
3801 bool LLParser::parseMDNodeTail(
MDNode *&
N) {
3804 return parseMDTuple(
N);
3807 return parseMDNodeID(
N);
3813 template <
class FieldTy>
struct MDFieldImpl {
3814 typedef MDFieldImpl ImplTy;
3818 void assign(FieldTy Val) {
3823 explicit MDFieldImpl(FieldTy Default)
3831 template <
class FieldTypeA,
class FieldTypeB>
struct MDEitherFieldImpl {
3832 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
3843 void assign(FieldTypeA A) {
3849 void assign(FieldTypeB
B) {
3855 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
3857 WhatIs(IsInvalid) {}
3860 struct MDUnsignedField :
public MDFieldImpl<uint64_t> {
3867 struct LineField :
public MDUnsignedField {
3868 LineField() : MDUnsignedField(0, UINT32_MAX) {}
3871 struct ColumnField :
public MDUnsignedField {
3872 ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
3875 struct DwarfTagField :
public MDUnsignedField {
3881 struct DwarfMacinfoTypeField :
public MDUnsignedField {
3887 struct DwarfAttEncodingField :
public MDUnsignedField {
3888 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::
DW_ATE_hi_user) {}
3891 struct DwarfVirtualityField :
public MDUnsignedField {
3895 struct DwarfLangField :
public MDUnsignedField {
3899 struct DwarfCCField :
public MDUnsignedField {
3900 DwarfCCField() : MDUnsignedField(0, dwarf::
DW_CC_hi_user) {}
3903 struct EmissionKindField :
public MDUnsignedField {
3904 EmissionKindField() : MDUnsignedField(0,
DICompileUnit::LastEmissionKind) {}
3907 struct NameTableKindField :
public MDUnsignedField {
3908 NameTableKindField()
3911 DICompileUnit::DebugNameTableKind::LastDebugNameTableKind) {}
3914 struct DIFlagField :
public MDFieldImpl<DINode::DIFlags> {
3915 DIFlagField() : MDFieldImpl(
DINode::FlagZero) {}
3918 struct DISPFlagField :
public MDFieldImpl<DISubprogram::DISPFlags> {
3919 DISPFlagField() : MDFieldImpl(
DISubprogram::SPFlagZero) {}
3922 struct MDAPSIntField :
public MDFieldImpl<APSInt> {
3923 MDAPSIntField() : ImplTy(
APSInt()) {}
3926 struct MDSignedField :
public MDFieldImpl<int64_t> {
3930 MDSignedField(int64_t Default = 0)
3932 MDSignedField(int64_t Default, int64_t Min, int64_t Max)
3936 struct MDBoolField :
public MDFieldImpl<bool> {
3937 MDBoolField(
bool Default =
false) : ImplTy(
Default) {}
3940 struct MDField :
public MDFieldImpl<Metadata *> {
3943 MDField(
bool AllowNull =
true) : ImplTy(nullptr), AllowNull(AllowNull) {}
3946 struct MDStringField :
public MDFieldImpl<MDString *> {
3948 MDStringField(
bool AllowEmpty =
true)
3949 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
3952 struct MDFieldList :
public MDFieldImpl<SmallVector<Metadata *, 4>> {
3956 struct ChecksumKindField :
public MDFieldImpl<DIFile::ChecksumKind> {
3960 struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
3961 MDSignedOrMDField(int64_t Default = 0,
bool AllowNull =
true)
3962 : ImplTy(MDSignedField(
Default), MDField(AllowNull)) {}
3964 MDSignedOrMDField(int64_t Default, int64_t Min, int64_t Max,
3965 bool AllowNull =
true)
3966 : ImplTy(MDSignedField(
Default, Min,
Max), MDField(AllowNull)) {}
3968 bool isMDSignedField()
const {
return WhatIs == IsTypeA; }
3969 bool isMDField()
const {
return WhatIs == IsTypeB; }
3970 int64_t getMDSignedValue()
const {
3971 assert(isMDSignedField() &&
"Wrong field type");
3974 Metadata *getMDFieldValue()
const {
3975 assert(isMDField() &&
"Wrong field type");
3987 return tokError(
"expected integer");
3996 MDUnsignedField &Result) {
3998 return tokError(
"expected unsigned integer");
4001 if (U.ugt(Result.Max))
4002 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4004 Result.assign(U.getZExtValue());
4005 assert(Result.Val <= Result.Max &&
"Expected value in range");
4012 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4016 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4022 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4025 return tokError(
"expected DWARF tag");
4029 return tokError(
"invalid DWARF tag" +
Twine(
" '") + Lex.
getStrVal() +
"'");
4030 assert(Tag <= Result.Max &&
"Expected valid DWARF tag");
4039 DwarfMacinfoTypeField &Result) {
4041 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4044 return tokError(
"expected DWARF macinfo type");
4048 return tokError(
"invalid DWARF macinfo type" +
Twine(
" '") +
4050 assert(Macinfo <= Result.Max &&
"Expected valid DWARF macinfo type");
4052 Result.assign(Macinfo);
4059 DwarfVirtualityField &Result) {
4061 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4064 return tokError(
"expected DWARF virtuality code");
4068 return tokError(
"invalid DWARF virtuality code" +
Twine(
" '") +
4070 assert(Virtuality <= Result.Max &&
"Expected valid DWARF virtuality code");
4071 Result.assign(Virtuality);
4079 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4082 return tokError(
"expected DWARF language");
4086 return tokError(
"invalid DWARF language" +
Twine(
" '") + Lex.
getStrVal() +
4088 assert(Lang <= Result.Max &&
"Expected valid DWARF language");
4089 Result.assign(Lang);
4097 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4100 return tokError(
"expected DWARF calling convention");
4104 return tokError(
"invalid DWARF calling convention" +
Twine(
" '") +
4106 assert(CC <= Result.Max &&
"Expected valid DWARF calling convention");
4114 EmissionKindField &Result) {
4116 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4119 return tokError(
"expected emission kind");
4123 return tokError(
"invalid emission kind" +
Twine(
" '") + Lex.
getStrVal() +
4125 assert(*
Kind <= Result.Max &&
"Expected valid emission kind");
4126 Result.assign(*
Kind);
4133 NameTableKindField &Result) {
4135 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4138 return tokError(
"expected nameTable kind");
4142 return tokError(
"invalid nameTable kind" +
Twine(
" '") + Lex.
getStrVal() +
4144 assert(((
unsigned)*
Kind) <= Result.Max &&
"Expected valid nameTable kind");
4145 Result.assign((
unsigned)*
Kind);
4152 DwarfAttEncodingField &Result) {
4154 return parseMDField(Loc,
Name,
static_cast<MDUnsignedField &
>(Result));
4157 return tokError(
"expected DWARF type attribute encoding");
4161 return tokError(
"invalid DWARF type attribute encoding" +
Twine(
" '") +
4163 assert(Encoding <= Result.Max &&
"Expected valid DWARF language");
4164 Result.assign(Encoding);
4180 bool Res = parseUInt32(TempVal);
4186 return tokError(
"expected debug info flag");
4190 return tokError(
Twine(
"invalid debug info flag '") + Lex.
getStrVal() +
4205 Result.assign(Combined);
4220 bool Res = parseUInt32(TempVal);
4226 return tokError(
"expected debug info flag");
4230 return tokError(
Twine(
"invalid subprogram debug info flag '") +
4245 Result.assign(Combined);
4252 return tokError(
"expected signed integer");
4256 return tokError(
"value for '" +
Name +
"' too small, limit is " +
4259 return tokError(
"value for '" +
Name +
"' too large, limit is " +
4261 Result.assign(
S.getExtValue());
4262 assert(Result.Val >= Result.Min &&
"Expected value in range");
4263 assert(Result.Val <= Result.Max &&
"Expected value in range");
4272 return tokError(
"expected 'true' or 'false'");
4274 Result.assign(
true);
4277 Result.assign(
false);
4287 if (!Result.AllowNull)
4288 return tokError(
"'" +
Name +
"' cannot be null");
4290 Result.assign(
nullptr);
4295 if (parseMetadata(MD,
nullptr))
4304 MDSignedOrMDField &Result) {
4307 MDSignedField Res = Result.A;
4308 if (!parseMDField(Loc,
Name, Res)) {
4316 MDField Res = Result.B;
4317 if (!parseMDField(Loc,
Name, Res)) {
4329 if (parseStringConstant(
S))
4332 if (!Result.AllowEmpty &&
S.empty())
4333 return error(ValueLoc,
"'" +
Name +
"' cannot be empty");
4342 if (parseMDNodeVector(MDs))
4351 ChecksumKindField &Result) {
4356 return tokError(
"invalid checksum kind" +
Twine(
" '") + Lex.
getStrVal() +
4359 Result.assign(*CSKind);
4366 template <
class ParserTy>
4367 bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
4370 return tokError(
"expected field label here");
4379 template <
class ParserTy>
4380 bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) {
4387 if (parseMDFieldsImplBody(ParseField))
4390 ClosingLoc = Lex.
getLoc();
4394 template <
class FieldTy>
4395 bool LLParser::parseMDField(
StringRef Name, FieldTy &Result) {
4397 return tokError(
"field '" +
Name +
"' cannot be specified more than once");
4401 return parseMDField(Loc,
Name, Result);
4404 bool LLParser::parseSpecializedMDNode(
MDNode *&
N,
bool IsDistinct) {
4407 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4408 if (Lex.getStrVal() == #CLASS) \
4409 return parse##CLASS(N, IsDistinct);
4410 #include "llvm/IR/Metadata.def"
4412 return tokError(
"expected metadata type");
4415 #define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4416 #define NOP_FIELD(NAME, TYPE, INIT)
4417 #define REQUIRE_FIELD(NAME, TYPE, INIT) \
4419 return error(ClosingLoc, "missing required field '" #NAME "'");
4420 #define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4421 if (Lex.getStrVal() == #NAME) \
4422 return parseMDField(#NAME, NAME);
4423 #define PARSE_MD_FIELDS() \
4424 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4427 if (parseMDFieldsImpl( \
4429 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4430 return tokError(Twine("invalid field '") + Lex.getStrVal() + \
4435 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4437 #define GET_OR_DISTINCT(CLASS, ARGS) \
4438 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4443 bool LLParser::parseDILocation(
MDNode *&Result,
bool IsDistinct) {
4444 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4445 OPTIONAL(line, LineField, ); \
4446 OPTIONAL(column, ColumnField, ); \
4447 REQUIRED(scope, MDField, ( false)); \
4448 OPTIONAL(inlinedAt, MDField, ); \
4449 OPTIONAL(isImplicitCode, MDBoolField, (false));
4451 #undef VISIT_MD_FIELDS
4455 inlinedAt.Val, isImplicitCode.Val));
4461 bool LLParser::parseGenericDINode(
MDNode *&Result,
bool IsDistinct) {
4462 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4463 REQUIRED(tag, DwarfTagField, ); \
4464 OPTIONAL(header, MDStringField, ); \
4465 OPTIONAL(operands, MDFieldList, );
4467 #undef VISIT_MD_FIELDS
4470 (Context, tag.Val, header.Val, operands.Val));
4478 bool LLParser::parseDISubrange(
MDNode *&Result,
bool IsDistinct) {
4479 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4480 OPTIONAL(count, MDSignedOrMDField, (-1, -1, INT64_MAX, false)); \
4481 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4482 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4483 OPTIONAL(stride, MDSignedOrMDField, );
4485 #undef VISIT_MD_FIELDS
4492 auto convToMetadata = [&](MDSignedOrMDField Bound) ->
Metadata * {
4493 if (Bound.isMDSignedField())
4496 if (Bound.isMDField())
4497 return Bound.getMDFieldValue();
4501 Count = convToMetadata(
count);
4502 LowerBound = convToMetadata(lowerBound);
4503 UpperBound = convToMetadata(upperBound);
4504 Stride = convToMetadata(stride);
4507 (Context, Count, LowerBound, UpperBound, Stride));
4515 bool LLParser::parseDIGenericSubrange(
MDNode *&Result,
bool IsDistinct) {
4516 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4517 OPTIONAL(count, MDSignedOrMDField, ); \
4518 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4519 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4520 OPTIONAL(stride, MDSignedOrMDField, );
4522 #undef VISIT_MD_FIELDS
4524 auto ConvToMetadata = [&](MDSignedOrMDField Bound) ->
Metadata * {
4525 if (Bound.isMDSignedField())
4527 Context, {dwarf::DW_OP_consts,
4528 static_cast<uint64_t>(Bound.getMDSignedValue())});
4529 if (Bound.isMDField())
4530 return Bound.getMDFieldValue();
4535 Metadata *LowerBound = ConvToMetadata(lowerBound);
4536 Metadata *UpperBound = ConvToMetadata(upperBound);
4537 Metadata *Stride = ConvToMetadata(stride);
4540 (Context, Count, LowerBound, UpperBound, Stride));
4547 bool LLParser::parseDIEnumerator(
MDNode *&Result,
bool IsDistinct) {
4548 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4549 REQUIRED(name, MDStringField, ); \
4550 REQUIRED(value, MDAPSIntField, ); \
4551 OPTIONAL(isUnsigned, MDBoolField, (false));
4553 #undef VISIT_MD_FIELDS
4555 if (isUnsigned.Val && value.Val.isNegative())
4556 return tokError(
"unsigned enumerator with negative value");
4561 if (!isUnsigned.Val && value.Val.isUnsigned() && value.Val.isSignBitSet())
4573 bool LLParser::parseDIBasicType(
MDNode *&Result,
bool IsDistinct) {
4574 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4575 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
4576 OPTIONAL(name, MDStringField, ); \
4577 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4578 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4579 OPTIONAL(encoding, DwarfAttEncodingField, ); \
4580 OPTIONAL(flags, DIFlagField, );
4582 #undef VISIT_MD_FIELDS
4585 align.Val, encoding.Val, flags.Val));
4591 bool LLParser::parseDIStringType(
MDNode *&Result,
bool IsDistinct) {
4592 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4593 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_string_type)); \
4594 OPTIONAL(name, MDStringField, ); \
4595 OPTIONAL(stringLength, MDField, ); \
4596 OPTIONAL(stringLengthExpression, MDField, ); \
4597 OPTIONAL(stringLocationExpression, MDField, ); \
4598 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4599 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4600 OPTIONAL(encoding, DwarfAttEncodingField, );
4602 #undef VISIT_MD_FIELDS
4606 (Context, tag.Val,
name.Val, stringLength.Val, stringLengthExpression.Val,
4607 stringLocationExpression.Val,
size.Val,
align.Val, encoding.Val));
4616 bool LLParser::parseDIDerivedType(
MDNode *&Result,
bool IsDistinct) {
4617 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4618 REQUIRED(tag, DwarfTagField, ); \
4619 OPTIONAL(name, MDStringField, ); \
4620 OPTIONAL(file, MDField, ); \
4621 OPTIONAL(line, LineField, ); \
4622 OPTIONAL(scope, MDField, ); \
4623 REQUIRED(baseType, MDField, ); \
4624 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4625 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4626 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
4627 OPTIONAL(flags, DIFlagField, ); \
4628 OPTIONAL(extraData, MDField, ); \
4629 OPTIONAL(dwarfAddressSpace, MDUnsignedField, (UINT32_MAX, UINT32_MAX)); \
4630 OPTIONAL(annotations, MDField, );
4632 #undef VISIT_MD_FIELDS
4635 if (dwarfAddressSpace.Val != UINT32_MAX)
4636 DWARFAddressSpace = dwarfAddressSpace.Val;
4639 (Context, tag.Val,
name.Val,
file.Val, line.Val,
4640 scope.Val, baseType.Val,
size.Val,
align.Val,
4641 offset.Val, DWARFAddressSpace, flags.Val,
4642 extraData.Val, annotations.Val));
4646 bool LLParser::parseDICompositeType(
MDNode *&Result,
bool IsDistinct) {
4647 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4648 REQUIRED(tag, DwarfTagField, ); \
4649 OPTIONAL(name, MDStringField, ); \
4650 OPTIONAL(file, MDField, ); \
4651 OPTIONAL(line, LineField, ); \
4652 OPTIONAL(scope, MDField, ); \
4653 OPTIONAL(baseType, MDField, ); \
4654 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4655 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4656 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
4657 OPTIONAL(flags, DIFlagField, ); \
4658 OPTIONAL(elements, MDField, ); \
4659 OPTIONAL(runtimeLang, DwarfLangField, ); \
4660 OPTIONAL(vtableHolder, MDField, ); \
4661 OPTIONAL(templateParams, MDField, ); \
4662 OPTIONAL(identifier, MDStringField, ); \
4663 OPTIONAL(discriminator, MDField, ); \
4664 OPTIONAL(dataLocation, MDField, ); \
4665 OPTIONAL(associated, MDField, ); \
4666 OPTIONAL(allocated, MDField, ); \
4667 OPTIONAL(rank, MDSignedOrMDField, ); \
4668 OPTIONAL(annotations, MDField, );
4670 #undef VISIT_MD_FIELDS
4673 if (
rank.isMDSignedField())
4676 else if (
rank.isMDField())
4677 Rank =
rank.getMDFieldValue();
4682 Context, *identifier.Val, tag.Val,
name.Val,
file.Val, line.Val,
4683 scope.Val, baseType.Val,
size.Val,
align.Val, offset.Val, flags.Val,
4684 elements.Val, runtimeLang.Val, vtableHolder.Val, templateParams.Val,
4685 discriminator.Val, dataLocation.Val, associated.Val, allocated.Val,
4686 Rank, annotations.Val)) {
4695 (Context, tag.Val,
name.Val,
file.Val, line.Val, scope.Val, baseType.Val,
4697 runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val,
4698 discriminator.Val, dataLocation.Val, associated.Val, allocated.Val, Rank,
4703 bool LLParser::parseDISubroutineType(
MDNode *&Result,
bool IsDistinct) {
4704 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4705 OPTIONAL(flags, DIFlagField, ); \
4706 OPTIONAL(cc, DwarfCCField, ); \
4707 REQUIRED(types, MDField, );
4709 #undef VISIT_MD_FIELDS
4712 (Context, flags.Val, cc.Val, types.Val));
4721 bool LLParser::parseDIFile(
MDNode *&Result,
bool IsDistinct) {
4725 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4726 REQUIRED(filename, MDStringField, ); \
4727 REQUIRED(directory, MDStringField, ); \
4728 OPTIONAL(checksumkind, ChecksumKindField, (DIFile::CSK_MD5)); \
4729 OPTIONAL(checksum, MDStringField, ); \
4730 OPTIONAL(source, MDStringField, );
4732 #undef VISIT_MD_FIELDS
4735 if (checksumkind.Seen && checksum.Seen)
4736 OptChecksum.
emplace(checksumkind.Val, checksum.Val);
4737 else if (checksumkind.Seen || checksum.Seen)
4738 return Lex.
Error(
"'checksumkind' and 'checksum' must be provided together");
4742 OptSource = source.Val;
4744 OptChecksum, OptSource));
4755 bool LLParser::parseDICompileUnit(
MDNode *&Result,
bool IsDistinct) {
4757 return Lex.
Error(
"missing 'distinct', required for !DICompileUnit");
4759 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4760 REQUIRED(language, DwarfLangField, ); \
4761 REQUIRED(file, MDField, ( false)); \
4762 OPTIONAL(producer, MDStringField, ); \
4763 OPTIONAL(isOptimized, MDBoolField, ); \
4764 OPTIONAL(flags, MDStringField, ); \
4765 OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX)); \
4766 OPTIONAL(splitDebugFilename, MDStringField, ); \
4767 OPTIONAL(emissionKind, EmissionKindField, ); \
4768 OPTIONAL(enums, MDField, ); \
4769 OPTIONAL(retainedTypes, MDField, ); \
4770 OPTIONAL(globals, MDField, ); \
4771 OPTIONAL(imports, MDField, ); \
4772 OPTIONAL(macros, MDField, ); \
4773 OPTIONAL(dwoId, MDUnsignedField, ); \
4774 OPTIONAL(splitDebugInlining, MDBoolField, = true); \
4775 OPTIONAL(debugInfoForProfiling, MDBoolField, = false); \
4776 OPTIONAL(nameTableKind, NameTableKindField, ); \
4777 OPTIONAL(rangesBaseAddress, MDBoolField, = false); \
4778 OPTIONAL(sysroot, MDStringField, ); \
4779 OPTIONAL(sdk, MDStringField, );
4781 #undef VISIT_MD_FIELDS
4784 Context, language.Val,
file.Val, producer.Val, isOptimized.Val, flags.Val,
4785 runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
4786 retainedTypes.Val,
globals.Val, imports.Val, macros.Val, dwoId.Val,
4787 splitDebugInlining.Val, debugInfoForProfiling.Val, nameTableKind.Val,
4788 rangesBaseAddress.Val, sysroot.Val, sdk.Val);
4801 bool LLParser::parseDISubprogram(
MDNode *&Result,
bool IsDistinct) {
4803 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4804 OPTIONAL(scope, MDField, ); \
4805 OPTIONAL(name, MDStringField, ); \
4806 OPTIONAL(linkageName, MDStringField, ); \
4807 OPTIONAL(file, MDField, ); \
4808 OPTIONAL(line, LineField, ); \
4809 OPTIONAL(type, MDField, ); \
4810 OPTIONAL(isLocal, MDBoolField, ); \
4811 OPTIONAL(isDefinition, MDBoolField, (true)); \
4812 OPTIONAL(scopeLine, LineField, ); \
4813 OPTIONAL(containingType, MDField, ); \
4814 OPTIONAL(virtuality, DwarfVirtualityField, ); \
4815 OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX)); \
4816 OPTIONAL(thisAdjustment, MDSignedField, (0, INT32_MIN, INT32_MAX)); \
4817 OPTIONAL(flags, DIFlagField, ); \
4818 OPTIONAL(spFlags, DISPFlagField, ); \
4819 OPTIONAL(isOptimized, MDBoolField, ); \
4820 OPTIONAL(unit, MDField, ); \
4821 OPTIONAL(templateParams, MDField, ); \
4822 OPTIONAL(declaration, MDField, ); \
4823 OPTIONAL(retainedNodes, MDField, ); \
4824 OPTIONAL(thrownTypes, MDField, ); \
4825 OPTIONAL(annotations, MDField, ); \
4826 OPTIONAL(targetFuncName, MDStringField, );
4828 #undef VISIT_MD_FIELDS
4833 spFlags.Seen ? spFlags.Val
4835 isOptimized.Val, virtuality.Val);
4836 if ((SPFlags & DISubprogram::SPFlagDefinition) && !IsDistinct)
4839 "missing 'distinct', required for !DISubprogram that is a Definition");
4842 (Context, scope.Val,
name.Val, linkageName.Val,
file.Val, line.Val,
4843 type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
4844 thisAdjustment.Val, flags.Val, SPFlags,
unit.Val, templateParams.Val,
4845 declaration.Val, retainedNodes.Val, thrownTypes.Val, annotations.Val,
4846 targetFuncName.Val));
4852 bool LLParser::parseDILexicalBlock(
MDNode *&Result,
bool IsDistinct) {
4853 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4854 REQUIRED(scope, MDField, ( false)); \
4855 OPTIONAL(file, MDField, ); \
4856 OPTIONAL(line, LineField, ); \
4857 OPTIONAL(column, ColumnField, );
4859 #undef VISIT_MD_FIELDS
4868 bool LLParser::parseDILexicalBlockFile(
MDNode *&Result,
bool IsDistinct) {
4869 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4870 REQUIRED(scope, MDField, ( false)); \
4871 OPTIONAL(file, MDField, ); \
4872 REQUIRED(discriminator, MDUnsignedField, (0, UINT32_MAX));
4874 #undef VISIT_MD_FIELDS
4877 (Context, scope.Val,
file.Val, discriminator.Val));
4883 bool LLParser::parseDICommonBlock(
MDNode *&Result,
bool IsDistinct) {
4884 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4885 REQUIRED(scope, MDField, ); \
4886 OPTIONAL(declaration, MDField, ); \
4887 OPTIONAL(name, MDStringField, ); \
4888 OPTIONAL(file, MDField, ); \
4889 OPTIONAL(line, LineField, );
4891 #undef VISIT_MD_FIELDS
4894 (Context, scope.Val, declaration.Val,
name.Val,
4895 file.Val, line.Val));
4901 bool LLParser::parseDINamespace(
MDNode *&Result,
bool IsDistinct) {
4902 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4903 REQUIRED(scope, MDField, ); \
4904 OPTIONAL(name, MDStringField, ); \
4905 OPTIONAL(exportSymbols, MDBoolField, );
4907 #undef VISIT_MD_FIELDS
4910 (Context, scope.Val,
name.Val, exportSymbols.Val));
4917 bool LLParser::parseDIMacro(
MDNode *&Result,
bool IsDistinct) {
4918 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4919 REQUIRED(type, DwarfMacinfoTypeField, ); \
4920 OPTIONAL(line, LineField, ); \
4921 REQUIRED(name, MDStringField, ); \
4922 OPTIONAL(value, MDStringField, );
4924 #undef VISIT_MD_FIELDS
4927 (Context,
type.Val, line.Val,
name.Val, value.Val));
4933 bool LLParser::parseDIMacroFile(
MDNode *&Result,
bool IsDistinct) {
4934 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4935 OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file)); \
4936 OPTIONAL(line, LineField, ); \
4937 REQUIRED(file, MDField, ); \
4938 OPTIONAL(nodes, MDField, );
4940 #undef VISIT_MD_FIELDS
4951 bool LLParser::parseDIModule(
MDNode *&Result,
bool IsDistinct) {
4952 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4953 REQUIRED(scope, MDField, ); \
4954 REQUIRED(name, MDStringField, ); \
4955 OPTIONAL(configMacros, MDStringField, ); \
4956 OPTIONAL(includePath, MDStringField, ); \
4957 OPTIONAL(apinotes, MDStringField, ); \
4958 OPTIONAL(file, MDField, ); \
4959 OPTIONAL(line, LineField, ); \
4960 OPTIONAL(isDecl, MDBoolField, );
4962 #undef VISIT_MD_FIELDS
4965 configMacros.Val, includePath.Val,
4966 apinotes.Val, line.Val, isDecl.Val));
4972 bool LLParser::parseDITemplateTypeParameter(
MDNode *&Result,
bool IsDistinct) {
4973 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4974 OPTIONAL(name, MDStringField, ); \
4975 REQUIRED(type, MDField, ); \
4976 OPTIONAL(defaulted, MDBoolField, );
4978 #undef VISIT_MD_FIELDS
4981 (Context,
name.Val,
type.Val, defaulted.Val));
4989 bool LLParser::parseDITemplateValueParameter(
MDNode *&Result,
bool IsDistinct) {
4990 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4991 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter)); \
4992 OPTIONAL(name, MDStringField, ); \
4993 OPTIONAL(type, MDField, ); \
4994 OPTIONAL(defaulted, MDBoolField, ); \
4995 REQUIRED(value, MDField, );
4998 #undef VISIT_MD_FIELDS
5002 (Context, tag.Val,
name.Val,
type.Val, defaulted.Val, value.Val));
5011 bool LLParser::parseDIGlobalVariable(
MDNode *&Result,
bool IsDistinct) {
5012 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5013 REQUIRED(name, MDStringField, ( false)); \
5014 OPTIONAL(scope, MDField, ); \
5015 OPTIONAL(linkageName, MDStringField, ); \
5016 OPTIONAL(file, MDField, ); \
5017 OPTIONAL(line, LineField, ); \
5018 OPTIONAL(type, MDField, ); \
5019 OPTIONAL(isLocal, MDBoolField, ); \
5020 OPTIONAL(isDefinition, MDBoolField, (true)); \
5021 OPTIONAL(templateParams, MDField, ); \
5022 OPTIONAL(declaration, MDField, ); \
5023 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
5024 OPTIONAL(annotations, MDField, );
5026 #undef VISIT_MD_FIELDS
5030 (Context, scope.Val,
name.Val, linkageName.Val,
file.Val,
5031 line.Val,
type.Val, isLocal.Val, isDefinition.Val,
5032 declaration.Val, templateParams.Val,
align.Val,
5044 bool LLParser::parseDILocalVariable(
MDNode *&Result,
bool IsDistinct) {
5045 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5046 REQUIRED(scope, MDField, ( false)); \
5047 OPTIONAL(name, MDStringField, ); \
5048 OPTIONAL(arg, MDUnsignedField, (0, UINT16_MAX)); \
5049 OPTIONAL(file, MDField, ); \
5050 OPTIONAL(line, LineField, ); \
5051 OPTIONAL(type, MDField, ); \
5052 OPTIONAL(flags, DIFlagField, ); \
5053 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
5054 OPTIONAL(annotations, MDField, );
5056 #undef VISIT_MD_FIELDS
5059 (Context, scope.Val,
name.Val,
file.Val, line.Val,
5060 type.Val, arg.Val, flags.Val,
align.Val,
5067 bool LLParser::parseDILabel(
MDNode *&Result,
bool IsDistinct) {
5068 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5069 REQUIRED(scope, MDField, ( false)); \
5070 REQUIRED(name, MDStringField, ); \
5071 REQUIRED(file, MDField, ); \
5072 REQUIRED(line, LineField, );
5074 #undef VISIT_MD_FIELDS
5077 (Context, scope.Val,
name.Val,
file.Val, line.Val));
5083 bool LLParser::parseDIExpression(
MDNode *&Result,
bool IsDistinct) {
5096 Elements.push_back(
Op);
5099 return tokError(
Twine(
"invalid DWARF op '") + Lex.
getStrVal() +
"'");
5105 Elements.push_back(
Op);
5108 return tokError(
Twine(
"invalid DWARF attribute encoding '") +
5113 return tokError(
"expected unsigned integer");
5118 Elements.push_back(U.getZExtValue());
5129 bool LLParser::parseDIArgList(
MDNode *&Result,
bool IsDistinct) {
5130 return parseDIArgList(Result, IsDistinct,
nullptr);
5134 bool LLParser::parseDIArgList(
MDNode *&Result,
bool IsDistinct,
5135 PerFunctionState *PFS) {
5136 assert(PFS &&
"Expected valid function state");
5147 if (parseValueAsMetadata(MD,
"expected value-as-metadata operand", PFS))
5149 Args.push_back(dyn_cast<ValueAsMetadata>(MD));
5161 bool LLParser::parseDIGlobalVariableExpression(
MDNode *&Result,
5163 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5164 REQUIRED(var, MDField, ); \
5165 REQUIRED(expr, MDField, );
5167 #undef VISIT_MD_FIELDS
5177 bool LLParser::parseDIObjCProperty(
MDNode *&Result,
bool IsDistinct) {
5178 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5179 OPTIONAL(name, MDStringField, ); \
5180 OPTIONAL(file, MDField, ); \
5181 OPTIONAL(line, LineField, ); \
5182 OPTIONAL(setter, MDStringField, ); \
5183 OPTIONAL(getter, MDStringField, ); \
5184 OPTIONAL(attributes, MDUnsignedField, (0, UINT32_MAX)); \
5185 OPTIONAL(type, MDField, );
5187 #undef VISIT_MD_FIELDS
5190 (Context,
name.Val,
file.Val, line.Val, setter.Val,
5198 bool LLParser::parseDIImportedEntity(
MDNode *&Result,
bool IsDistinct) {
5199 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5200 REQUIRED(tag, DwarfTagField, ); \
5201 REQUIRED(scope, MDField, ); \
5202 OPTIONAL(entity, MDField, ); \
5203 OPTIONAL(file, MDField, ); \
5204 OPTIONAL(line, LineField, ); \
5205 OPTIONAL(name, MDStringField, ); \
5206 OPTIONAL(elements, MDField, );
5208 #undef VISIT_MD_FIELDS
5211 (Context, tag.Val, scope.Val, entity.Val,
file.Val,
5216 #undef PARSE_MD_FIELD
5218 #undef REQUIRE_FIELD
5219 #undef DECLARE_FIELD
5228 bool LLParser::parseMetadataAsValue(
Value *&V, PerFunctionState &PFS) {
5231 if (parseMetadata(MD, &PFS))
5242 bool LLParser::parseValueAsMetadata(
Metadata *&MD,
const Twine &TypeMsg,
5243 PerFunctionState *PFS) {
5246 if (parseType(Ty, TypeMsg, Loc))
5249 return error(Loc,
"invalid metadata-value-metadata roundtrip");
5252 if (parseValue(Ty, V, PFS))
5267 bool LLParser::parseMetadata(
Metadata *&MD, PerFunctionState *PFS) {
5273 if (parseDIArgList(
N,
false, PFS))
5275 }
else if (parseSpecializedMDNode(
N)) {
5285 return parseValueAsMetadata(MD,
"expected metadata operand", PFS);
5295 if (parseMDString(
S))
5305 if (parseMDNodeTail(
N))