summaryrefslogtreecommitdiff
path: root/lib/AsmParser
diff options
context:
space:
mode:
Diffstat (limited to 'lib/AsmParser')
-rw-r--r--lib/AsmParser/LLLexer.cpp28
-rw-r--r--lib/AsmParser/LLParser.cpp577
-rw-r--r--lib/AsmParser/LLParser.h37
-rw-r--r--lib/AsmParser/LLToken.h554
-rw-r--r--lib/AsmParser/Makefile14
-rw-r--r--lib/AsmParser/Parser.cpp29
-rw-r--r--lib/AsmParser/module.modulemap1
7 files changed, 818 insertions, 422 deletions
diff --git a/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp
index 26eca230bb31b..507e7e76ecd28 100644
--- a/lib/AsmParser/LLLexer.cpp
+++ b/lib/AsmParser/LLLexer.cpp
@@ -513,6 +513,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(hidden);
KEYWORD(protected);
KEYWORD(unnamed_addr);
+ KEYWORD(local_unnamed_addr);
KEYWORD(externally_initialized);
KEYWORD(extern_weak);
KEYWORD(external);
@@ -533,6 +534,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(notail);
KEYWORD(target);
KEYWORD(triple);
+ KEYWORD(source_filename);
KEYWORD(unwind);
KEYWORD(deplibs); // FIXME: Remove in 4.0.
KEYWORD(datalayout);
@@ -559,6 +561,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(addrspace);
KEYWORD(section);
KEYWORD(alias);
+ KEYWORD(ifunc);
KEYWORD(module);
KEYWORD(asm);
KEYWORD(sideeffect);
@@ -579,6 +582,8 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(arm_aapcscc);
KEYWORD(arm_aapcs_vfpcc);
KEYWORD(msp430_intrcc);
+ KEYWORD(avr_intrcc);
+ KEYWORD(avr_signalcc);
KEYWORD(ptx_kernel);
KEYWORD(ptx_device);
KEYWORD(spir_kernel);
@@ -587,6 +592,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(x86_64_sysvcc);
KEYWORD(x86_64_win64cc);
KEYWORD(webkit_jscc);
+ KEYWORD(swiftcc);
KEYWORD(anyregcc);
KEYWORD(preserve_mostcc);
KEYWORD(preserve_allcc);
@@ -595,6 +601,11 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(hhvmcc);
KEYWORD(hhvm_ccc);
KEYWORD(cxx_fast_tlscc);
+ KEYWORD(amdgpu_vs);
+ KEYWORD(amdgpu_gs);
+ KEYWORD(amdgpu_ps);
+ KEYWORD(amdgpu_cs);
+ KEYWORD(amdgpu_kernel);
KEYWORD(cc);
KEYWORD(c);
@@ -602,6 +613,7 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(attributes);
KEYWORD(alwaysinline);
+ KEYWORD(allocsize);
KEYWORD(argmemonly);
KEYWORD(builtin);
KEYWORD(byval);
@@ -645,7 +657,10 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(sanitize_address);
KEYWORD(sanitize_thread);
KEYWORD(sanitize_memory);
+ KEYWORD(swifterror);
+ KEYWORD(swiftself);
KEYWORD(uwtable);
+ KEYWORD(writeonly);
KEYWORD(zeroext);
KEYWORD(type);
@@ -780,14 +795,19 @@ lltok::Kind LLLexer::LexIdentifier() {
DWKEYWORD(ATE, DwarfAttEncoding);
DWKEYWORD(VIRTUALITY, DwarfVirtuality);
DWKEYWORD(LANG, DwarfLang);
+ DWKEYWORD(CC, DwarfCC);
DWKEYWORD(OP, DwarfOp);
DWKEYWORD(MACINFO, DwarfMacinfo);
#undef DWKEYWORD
-
if (Keyword.startswith("DIFlag")) {
StrVal.assign(Keyword.begin(), Keyword.end());
return lltok::DIFlag;
}
+ if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
+ Keyword == "LineTablesOnly") {
+ StrVal.assign(Keyword.begin(), Keyword.end());
+ return lltok::EmissionKind;
+ }
// Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
// the CFE to avoid forcing it to deal with 64-bit numbers.
@@ -941,7 +961,8 @@ lltok::Kind LLLexer::LexDigitOrNegative() {
}
}
- APFloatVal = APFloat(std::atof(TokStart));
+ APFloatVal = APFloat(APFloat::IEEEdouble,
+ StringRef(TokStart, CurPtr - TokStart));
return lltok::APFloat;
}
@@ -977,6 +998,7 @@ lltok::Kind LLLexer::LexPositive() {
}
}
- APFloatVal = APFloat(std::atof(TokStart));
+ APFloatVal = APFloat(APFloat::IEEEdouble,
+ StringRef(TokStart, CurPtr - TokStart));
return lltok::APFloat;
}
diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index 3471a2dbd05cd..a2fcbf41204d5 100644
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -14,19 +14,23 @@
#include "LLParser.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
#include "llvm/AsmParser/SlotMapping.h"
#include "llvm/IR/AutoUpgrade.h"
#include "llvm/IR/CallingConv.h"
+#include "llvm/IR/CallSite.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/ValueSymbolTable.h"
+#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SaveAndRestore.h"
@@ -45,6 +49,11 @@ bool LLParser::Run() {
// Prime the lexer.
Lex.Lex();
+ if (Context.shouldDiscardValueNames())
+ return Error(
+ Lex.getLoc(),
+ "Can't read textual IR with a Context that discards named Values");
+
return ParseTopLevelEntities() ||
ValidateEndOfModule();
}
@@ -62,6 +71,22 @@ bool LLParser::parseStandaloneConstantValue(Constant *&C,
return false;
}
+bool LLParser::parseTypeAtBeginning(Type *&Ty, unsigned &Read,
+ const SlotMapping *Slots) {
+ restoreParsingState(Slots);
+ Lex.Lex();
+
+ Read = 0;
+ SMLoc Start = Lex.getLoc();
+ Ty = nullptr;
+ if (ParseType(Ty))
+ return true;
+ SMLoc End = Lex.getLoc();
+ Read = End.getPointer() - Start.getPointer();
+
+ return false;
+}
+
void LLParser::restoreParsingState(const SlotMapping *Slots) {
if (!Slots)
return;
@@ -78,9 +103,6 @@ void LLParser::restoreParsingState(const SlotMapping *Slots) {
/// ValidateEndOfModule - Do final validity and sanity checks at the end of the
/// module.
bool LLParser::ValidateEndOfModule() {
- for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
- UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
-
// Handle any function attribute group forward references.
for (std::map<Value*, std::vector<unsigned> >::iterator
I = ForwardRefAttrGroups.begin(), E = ForwardRefAttrGroups.end();
@@ -183,12 +205,28 @@ bool LLParser::ValidateEndOfModule() {
N.second->resolveCycles();
}
+ for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
+ UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
+
// Look for intrinsic functions and CallInst that need to be upgraded
for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
UpgradeCallsToIntrinsic(&*FI++); // must be post-increment, as we remove
+ // Some types could be renamed during loading if several modules are
+ // loaded in the same LLVMContext (LTO scenario). In this case we should
+ // remangle intrinsics names as well.
+ for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) {
+ Function *F = &*FI++;
+ if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) {
+ F->replaceAllUsesWith(Remangled.getValue());
+ F->eraseFromParent();
+ }
+ }
+
UpgradeDebugInfo(*M);
+ UpgradeModuleFlags(*M);
+
if (!Slots)
return false;
// Initialize the slot mapping.
@@ -217,6 +255,10 @@ bool LLParser::ParseTopLevelEntities() {
case lltok::kw_define: if (ParseDefine()) return true; break;
case lltok::kw_module: if (ParseModuleAsm()) return true; break;
case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
+ case lltok::kw_source_filename:
+ if (ParseSourceFileName())
+ return true;
+ break;
case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
case lltok::LocalVar: if (ParseNamedType()) return true; break;
@@ -225,46 +267,6 @@ bool LLParser::ParseTopLevelEntities() {
case lltok::ComdatVar: if (parseComdat()) return true; break;
case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break;
case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
-
- // The Global variable production with no name can have many different
- // optional leading prefixes, the production is:
- // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
- // OptionalThreadLocal OptionalAddrSpace OptionalUnnamedAddr
- // ('constant'|'global') ...
- case lltok::kw_private: // OptionalLinkage
- case lltok::kw_internal: // OptionalLinkage
- case lltok::kw_weak: // OptionalLinkage
- case lltok::kw_weak_odr: // OptionalLinkage
- case lltok::kw_linkonce: // OptionalLinkage
- case lltok::kw_linkonce_odr: // OptionalLinkage
- case lltok::kw_appending: // OptionalLinkage
- case lltok::kw_common: // OptionalLinkage
- case lltok::kw_extern_weak: // OptionalLinkage
- case lltok::kw_external: // OptionalLinkage
- case lltok::kw_default: // OptionalVisibility
- case lltok::kw_hidden: // OptionalVisibility
- case lltok::kw_protected: // OptionalVisibility
- case lltok::kw_dllimport: // OptionalDLLStorageClass
- case lltok::kw_dllexport: // OptionalDLLStorageClass
- case lltok::kw_thread_local: // OptionalThreadLocal
- case lltok::kw_addrspace: // OptionalAddrSpace
- case lltok::kw_constant: // GlobalType
- case lltok::kw_global: { // GlobalType
- unsigned Linkage, Visibility, DLLStorageClass;
- bool UnnamedAddr;
- GlobalVariable::ThreadLocalMode TLM;
- bool HasLinkage;
- if (ParseOptionalLinkage(Linkage, HasLinkage) ||
- ParseOptionalVisibility(Visibility) ||
- ParseOptionalDLLStorageClass(DLLStorageClass) ||
- ParseOptionalThreadLocal(TLM) ||
- parseOptionalUnnamedAddr(UnnamedAddr) ||
- ParseGlobal("", SMLoc(), Linkage, HasLinkage, Visibility,
- DLLStorageClass, TLM, UnnamedAddr))
- return true;
- break;
- }
-
case lltok::kw_attributes: if (ParseUnnamedAttrGrp()) return true; break;
case lltok::kw_uselistorder: if (ParseUseListOrder()) return true; break;
case lltok::kw_uselistorder_bb:
@@ -314,6 +316,19 @@ bool LLParser::ParseTargetDefinition() {
}
/// toplevelentity
+/// ::= 'source_filename' '=' STRINGCONSTANT
+bool LLParser::ParseSourceFileName() {
+ assert(Lex.getKind() == lltok::kw_source_filename);
+ std::string Str;
+ Lex.Lex();
+ if (ParseToken(lltok::equal, "expected '=' after source_filename") ||
+ ParseStringConstant(Str))
+ return true;
+ M->setSourceFileName(Str);
+ return false;
+}
+
+/// toplevelentity
/// ::= 'deplibs' '=' '[' ']'
/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
/// FIXME: Remove in 4.0. Currently parse, but ignore.
@@ -395,8 +410,21 @@ bool LLParser::ParseDeclare() {
assert(Lex.getKind() == lltok::kw_declare);
Lex.Lex();
+ std::vector<std::pair<unsigned, MDNode *>> MDs;
+ while (Lex.getKind() == lltok::MetadataVar) {
+ unsigned MDK;
+ MDNode *N;
+ if (ParseMetadataAttachment(MDK, N))
+ return true;
+ MDs.push_back({MDK, N});
+ }
+
Function *F;
- return ParseFunctionHeader(F, false);
+ if (ParseFunctionHeader(F, false))
+ return true;
+ for (auto &MD : MDs)
+ F->addMetadata(MD.first, *MD.second);
+ return false;
}
/// toplevelentity
@@ -427,11 +455,22 @@ bool LLParser::ParseGlobalType(bool &IsConstant) {
return false;
}
+bool LLParser::ParseOptionalUnnamedAddr(
+ GlobalVariable::UnnamedAddr &UnnamedAddr) {
+ if (EatIfPresent(lltok::kw_unnamed_addr))
+ UnnamedAddr = GlobalValue::UnnamedAddr::Global;
+ else if (EatIfPresent(lltok::kw_local_unnamed_addr))
+ UnnamedAddr = GlobalValue::UnnamedAddr::Local;
+ else
+ UnnamedAddr = GlobalValue::UnnamedAddr::None;
+ return false;
+}
+
/// ParseUnnamedGlobal:
-/// OptionalVisibility ALIAS ...
+/// OptionalVisibility (ALIAS | IFUNC) ...
/// OptionalLinkage OptionalVisibility OptionalDLLStorageClass
/// ... -> global variable
-/// GlobalID '=' OptionalVisibility ALIAS ...
+/// GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
/// GlobalID '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
/// ... -> global variable
bool LLParser::ParseUnnamedGlobal() {
@@ -453,23 +492,21 @@ bool LLParser::ParseUnnamedGlobal() {
bool HasLinkage;
unsigned Linkage, Visibility, DLLStorageClass;
GlobalVariable::ThreadLocalMode TLM;
- bool UnnamedAddr;
- if (ParseOptionalLinkage(Linkage, HasLinkage) ||
- ParseOptionalVisibility(Visibility) ||
- ParseOptionalDLLStorageClass(DLLStorageClass) ||
- ParseOptionalThreadLocal(TLM) ||
- parseOptionalUnnamedAddr(UnnamedAddr))
+ GlobalVariable::UnnamedAddr UnnamedAddr;
+ if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+ ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
return true;
- if (Lex.getKind() != lltok::kw_alias)
+ if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
DLLStorageClass, TLM, UnnamedAddr);
- return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
- UnnamedAddr);
+
+ return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
+ DLLStorageClass, TLM, UnnamedAddr);
}
/// ParseNamedGlobal:
-/// GlobalVar '=' OptionalVisibility ALIAS ...
+/// GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
/// GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
/// ... -> global variable
bool LLParser::ParseNamedGlobal() {
@@ -481,21 +518,18 @@ bool LLParser::ParseNamedGlobal() {
bool HasLinkage;
unsigned Linkage, Visibility, DLLStorageClass;
GlobalVariable::ThreadLocalMode TLM;
- bool UnnamedAddr;
+ GlobalVariable::UnnamedAddr UnnamedAddr;
if (ParseToken(lltok::equal, "expected '=' in global variable") ||
- ParseOptionalLinkage(Linkage, HasLinkage) ||
- ParseOptionalVisibility(Visibility) ||
- ParseOptionalDLLStorageClass(DLLStorageClass) ||
- ParseOptionalThreadLocal(TLM) ||
- parseOptionalUnnamedAddr(UnnamedAddr))
+ ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+ ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
return true;
- if (Lex.getKind() != lltok::kw_alias)
+ if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
DLLStorageClass, TLM, UnnamedAddr);
- return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
- UnnamedAddr);
+ return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
+ DLLStorageClass, TLM, UnnamedAddr);
}
bool LLParser::parseComdat() {
@@ -553,7 +587,6 @@ bool LLParser::parseComdat() {
bool LLParser::ParseMDString(MDString *&Result) {
std::string Str;
if (ParseStringConstant(Str)) return true;
- llvm::UpgradeMDStringConstant(Str);
Result = MDString::get(Context, Str);
return false;
}
@@ -562,6 +595,7 @@ bool LLParser::ParseMDString(MDString *&Result) {
// ::= '!' MDNodeNumber
bool LLParser::ParseMDNodeID(MDNode *&Result) {
// !{ ..., !42, ... }
+ LocTy IDLoc = Lex.getLoc();
unsigned MID = 0;
if (ParseUInt32(MID))
return true;
@@ -574,7 +608,7 @@ bool LLParser::ParseMDNodeID(MDNode *&Result) {
// Otherwise, create MDNode forward reference.
auto &FwdRef = ForwardRefMDNodes[MID];
- FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), Lex.getLoc());
+ FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), IDLoc);
Result = FwdRef.first.get();
NumberedMetadata[MID].reset(Result);
@@ -652,26 +686,32 @@ static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
(GlobalValue::VisibilityTypes)V == GlobalValue::DefaultVisibility;
}
-/// ParseAlias:
+/// parseIndirectSymbol:
/// ::= GlobalVar '=' OptionalLinkage OptionalVisibility
/// OptionalDLLStorageClass OptionalThreadLocal
-/// OptionalUnnamedAddr 'alias' Aliasee
+/// OptionalUnnamedAddr 'alias|ifunc' IndirectSymbol
///
-/// Aliasee
+/// IndirectSymbol
/// ::= TypeAndValue
///
/// Everything through OptionalUnnamedAddr has already been parsed.
///
-bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
- unsigned Visibility, unsigned DLLStorageClass,
- GlobalVariable::ThreadLocalMode TLM,
- bool UnnamedAddr) {
- assert(Lex.getKind() == lltok::kw_alias);
+bool LLParser::parseIndirectSymbol(
+ const std::string &Name, LocTy NameLoc, unsigned L, unsigned Visibility,
+ unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM,
+ GlobalVariable::UnnamedAddr UnnamedAddr) {
+ bool IsAlias;
+ if (Lex.getKind() == lltok::kw_alias)
+ IsAlias = true;
+ else if (Lex.getKind() == lltok::kw_ifunc)
+ IsAlias = false;
+ else
+ llvm_unreachable("Not an alias or ifunc!");
Lex.Lex();
GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
- if(!GlobalAlias::isValidLinkage(Linkage))
+ if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
return Error(NameLoc, "invalid linkage type for alias");
if (!isValidVisibilityForLinkage(Visibility, L))
@@ -681,7 +721,7 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
Type *Ty;
LocTy ExplicitTypeLoc = Lex.getLoc();
if (ParseType(Ty) ||
- ParseToken(lltok::comma, "expected comma after alias's type"))
+ ParseToken(lltok::comma, "expected comma after alias or ifunc's type"))
return true;
Constant *Aliasee;
@@ -705,14 +745,19 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
Type *AliaseeType = Aliasee->getType();
auto *PTy = dyn_cast<PointerType>(AliaseeType);
if (!PTy)
- return Error(AliaseeLoc, "An alias must have pointer type");
+ return Error(AliaseeLoc, "An alias or ifunc must have pointer type");
unsigned AddrSpace = PTy->getAddressSpace();
- if (Ty != PTy->getElementType())
+ if (IsAlias && Ty != PTy->getElementType())
return Error(
ExplicitTypeLoc,
"explicit pointee type doesn't match operand's pointee type");
+ if (!IsAlias && !PTy->getElementType()->isFunctionTy())
+ return Error(
+ ExplicitTypeLoc,
+ "explicit pointee type should be a function type");
+
GlobalValue *GVal = nullptr;
// See if the alias was forward referenced, if so, prepare to replace the
@@ -732,9 +777,15 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
}
// Okay, create the alias but do not insert it into the module yet.
- std::unique_ptr<GlobalAlias> GA(
- GlobalAlias::create(Ty, AddrSpace, (GlobalValue::LinkageTypes)Linkage,
- Name, Aliasee, /*Parent*/ nullptr));
+ std::unique_ptr<GlobalIndirectSymbol> GA;
+ if (IsAlias)
+ GA.reset(GlobalAlias::create(Ty, AddrSpace,
+ (GlobalValue::LinkageTypes)Linkage, Name,
+ Aliasee, /*Parent*/ nullptr));
+ else
+ GA.reset(GlobalIFunc::create(Ty, AddrSpace,
+ (GlobalValue::LinkageTypes)Linkage, Name,
+ Aliasee, /*Parent*/ nullptr));
GA->setThreadLocalMode(TLM);
GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
@@ -757,7 +808,10 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
}
// Insert into the module, we know its name won't collide now.
- M->getAliasList().push_back(GA.get());
+ if (IsAlias)
+ M->getAliasList().push_back(cast<GlobalAlias>(GA.get()));
+ else
+ M->getIFuncList().push_back(cast<GlobalIFunc>(GA.get()));
assert(GA->getName() == Name && "Should not be a name conflict!");
// The module owns this now
@@ -781,7 +835,7 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
unsigned Linkage, bool HasLinkage,
unsigned Visibility, unsigned DLLStorageClass,
GlobalVariable::ThreadLocalMode TLM,
- bool UnnamedAddr) {
+ GlobalVariable::UnnamedAddr UnnamedAddr) {
if (!isValidVisibilityForLinkage(Visibility, Linkage))
return Error(NameLoc,
"symbol with local linkage must have default visibility");
@@ -803,8 +857,9 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
// If the linkage is specified and is external, then no initializer is
// present.
Constant *Init = nullptr;
- if (!HasLinkage || (Linkage != GlobalValue::ExternalWeakLinkage &&
- Linkage != GlobalValue::ExternalLinkage)) {
+ if (!HasLinkage ||
+ !GlobalValue::isValidDeclarationLinkage(
+ (GlobalValue::LinkageTypes)Linkage)) {
if (ParseGlobalValue(Ty, Init))
return true;
}
@@ -872,6 +927,9 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
unsigned Alignment;
if (ParseOptionalAlignment(Alignment)) return true;
GV->setAlignment(Alignment);
+ } else if (Lex.getKind() == lltok::MetadataVar) {
+ if (ParseGlobalObjectMetadataAttachment(*GV))
+ return true;
} else {
Comdat *C;
if (parseOptionalComdat(Name, C))
@@ -990,6 +1048,15 @@ bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
B.addStackAlignmentAttr(Alignment);
continue;
}
+ case lltok::kw_allocsize: {
+ unsigned ElemSizeArg;
+ Optional<unsigned> NumElemsArg;
+ // inAttrGrp doesn't matter; we only support allocsize(a[, b])
+ if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
+ return true;
+ B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
+ continue;
+ }
case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
case lltok::kw_argmemonly: B.addAttribute(Attribute::ArgMemOnly); break;
case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
@@ -1031,6 +1098,7 @@ bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
case lltok::kw_sanitize_memory:
B.addAttribute(Attribute::SanitizeMemory); break;
case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
+ case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
// Error handling.
case lltok::kw_inreg:
@@ -1050,6 +1118,8 @@ bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
case lltok::kw_nonnull:
case lltok::kw_returned:
case lltok::kw_sret:
+ case lltok::kw_swifterror:
+ case lltok::kw_swiftself:
HaveError |=
Error(Lex.getLoc(),
"invalid use of parameter-only attribute on a function");
@@ -1323,6 +1393,9 @@ bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
case lltok::kw_returned: B.addAttribute(Attribute::Returned); break;
case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break;
+ case lltok::kw_swifterror: B.addAttribute(Attribute::SwiftError); break;
+ case lltok::kw_swiftself: B.addAttribute(Attribute::SwiftSelf); break;
+ case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
case lltok::kw_alignstack:
@@ -1410,6 +1483,8 @@ bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
case lltok::kw_nocapture:
case lltok::kw_returned:
case lltok::kw_sret:
+ case lltok::kw_swifterror:
+ case lltok::kw_swiftself:
HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
break;
@@ -1453,6 +1528,37 @@ bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
}
}
+static unsigned parseOptionalLinkageAux(lltok::Kind Kind, bool &HasLinkage) {
+ HasLinkage = true;
+ switch (Kind) {
+ default:
+ HasLinkage = false;
+ return GlobalValue::ExternalLinkage;
+ case lltok::kw_private:
+ return GlobalValue::PrivateLinkage;
+ case lltok::kw_internal:
+ return GlobalValue::InternalLinkage;
+ case lltok::kw_weak:
+ return GlobalValue::WeakAnyLinkage;
+ case lltok::kw_weak_odr:
+ return GlobalValue::WeakODRLinkage;
+ case lltok::kw_linkonce:
+ return GlobalValue::LinkOnceAnyLinkage;
+ case lltok::kw_linkonce_odr:
+ return GlobalValue::LinkOnceODRLinkage;
+ case lltok::kw_available_externally:
+ return GlobalValue::AvailableExternallyLinkage;
+ case lltok::kw_appending:
+ return GlobalValue::AppendingLinkage;
+ case lltok::kw_common:
+ return GlobalValue::CommonLinkage;
+ case lltok::kw_extern_weak:
+ return GlobalValue::ExternalWeakLinkage;
+ case lltok::kw_external:
+ return GlobalValue::ExternalLinkage;
+ }
+}
+
/// ParseOptionalLinkage
/// ::= /*empty*/
/// ::= 'private'
@@ -1466,26 +1572,14 @@ bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
/// ::= 'common'
/// ::= 'extern_weak'
/// ::= 'external'
-bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
- HasLinkage = false;
- switch (Lex.getKind()) {
- default: Res=GlobalValue::ExternalLinkage; return false;
- case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
- case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
- case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
- case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;
- case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;
- case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;
- case lltok::kw_available_externally:
- Res = GlobalValue::AvailableExternallyLinkage;
- break;
- case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;
- case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
- case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;
- case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;
- }
- Lex.Lex();
- HasLinkage = true;
+bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
+ unsigned &Visibility,
+ unsigned &DLLStorageClass) {
+ Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
+ if (HasLinkage)
+ Lex.Lex();
+ ParseOptionalVisibility(Visibility);
+ ParseOptionalDLLStorageClass(DLLStorageClass);
return false;
}
@@ -1495,15 +1589,22 @@ bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
/// ::= 'hidden'
/// ::= 'protected'
///
-bool LLParser::ParseOptionalVisibility(unsigned &Res) {
+void LLParser::ParseOptionalVisibility(unsigned &Res) {
switch (Lex.getKind()) {
- default: Res = GlobalValue::DefaultVisibility; return false;
- case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break;
- case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break;
- case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
+ default:
+ Res = GlobalValue::DefaultVisibility;
+ return;
+ case lltok::kw_default:
+ Res = GlobalValue::DefaultVisibility;
+ break;
+ case lltok::kw_hidden:
+ Res = GlobalValue::HiddenVisibility;
+ break;
+ case lltok::kw_protected:
+ Res = GlobalValue::ProtectedVisibility;
+ break;
}
Lex.Lex();
- return false;
}
/// ParseOptionalDLLStorageClass
@@ -1511,14 +1612,19 @@ bool LLParser::ParseOptionalVisibility(unsigned &Res) {
/// ::= 'dllimport'
/// ::= 'dllexport'
///
-bool LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
+void LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
switch (Lex.getKind()) {
- default: Res = GlobalValue::DefaultStorageClass; return false;
- case lltok::kw_dllimport: Res = GlobalValue::DLLImportStorageClass; break;
- case lltok::kw_dllexport: Res = GlobalValue::DLLExportStorageClass; break;
+ default:
+ Res = GlobalValue::DefaultStorageClass;
+ return;
+ case lltok::kw_dllimport:
+ Res = GlobalValue::DLLImportStorageClass;
+ break;
+ case lltok::kw_dllexport:
+ Res = GlobalValue::DLLExportStorageClass;
+ break;
}
Lex.Lex();
- return false;
}
/// ParseOptionalCallingConv
@@ -1535,6 +1641,8 @@ bool LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
/// ::= 'arm_aapcscc'
/// ::= 'arm_aapcs_vfpcc'
/// ::= 'msp430_intrcc'
+/// ::= 'avr_intrcc'
+/// ::= 'avr_signalcc'
/// ::= 'ptx_kernel'
/// ::= 'ptx_device'
/// ::= 'spir_func'
@@ -1546,10 +1654,18 @@ bool LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
/// ::= 'preserve_mostcc'
/// ::= 'preserve_allcc'
/// ::= 'ghccc'
+/// ::= 'swiftcc'
/// ::= 'x86_intrcc'
/// ::= 'hhvmcc'
/// ::= 'hhvm_ccc'
/// ::= 'cxx_fast_tlscc'
+/// ::= 'amdgpu_vs'
+/// ::= 'amdgpu_tcs'
+/// ::= 'amdgpu_tes'
+/// ::= 'amdgpu_gs'
+/// ::= 'amdgpu_ps'
+/// ::= 'amdgpu_cs'
+/// ::= 'amdgpu_kernel'
/// ::= 'cc' UINT
///
bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
@@ -1566,6 +1682,8 @@ bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
+ case lltok::kw_avr_intrcc: CC = CallingConv::AVR_INTR; break;
+ case lltok::kw_avr_signalcc: CC = CallingConv::AVR_SIGNAL; break;
case lltok::kw_ptx_kernel: CC = CallingConv::PTX_Kernel; break;
case lltok::kw_ptx_device: CC = CallingConv::PTX_Device; break;
case lltok::kw_spir_kernel: CC = CallingConv::SPIR_KERNEL; break;
@@ -1578,10 +1696,16 @@ bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
case lltok::kw_preserve_mostcc:CC = CallingConv::PreserveMost; break;
case lltok::kw_preserve_allcc: CC = CallingConv::PreserveAll; break;
case lltok::kw_ghccc: CC = CallingConv::GHC; break;
+ case lltok::kw_swiftcc: CC = CallingConv::Swift; break;
case lltok::kw_x86_intrcc: CC = CallingConv::X86_INTR; break;
case lltok::kw_hhvmcc: CC = CallingConv::HHVM; break;
case lltok::kw_hhvm_ccc: CC = CallingConv::HHVM_C; break;
case lltok::kw_cxx_fast_tlscc: CC = CallingConv::CXX_FAST_TLS; break;
+ case lltok::kw_amdgpu_vs: CC = CallingConv::AMDGPU_VS; break;
+ case lltok::kw_amdgpu_gs: CC = CallingConv::AMDGPU_GS; break;
+ case lltok::kw_amdgpu_ps: CC = CallingConv::AMDGPU_PS; break;
+ case lltok::kw_amdgpu_cs: CC = CallingConv::AMDGPU_CS; break;
+ case lltok::kw_amdgpu_kernel: CC = CallingConv::AMDGPU_KERNEL; break;
case lltok::kw_cc: {
Lex.Lex();
return ParseUInt32(CC);
@@ -1625,17 +1749,24 @@ bool LLParser::ParseInstructionMetadata(Instruction &Inst) {
return false;
}
+/// ParseGlobalObjectMetadataAttachment
+/// ::= !dbg !57
+bool LLParser::ParseGlobalObjectMetadataAttachment(GlobalObject &GO) {
+ unsigned MDK;
+ MDNode *N;
+ if (ParseMetadataAttachment(MDK, N))
+ return true;
+
+ GO.addMetadata(MDK, *N);
+ return false;
+}
+
/// ParseOptionalFunctionMetadata
/// ::= (!dbg !57)*
bool LLParser::ParseOptionalFunctionMetadata(Function &F) {
- while (Lex.getKind() == lltok::MetadataVar) {
- unsigned MDK;
- MDNode *N;
- if (ParseMetadataAttachment(MDK, N))
+ while (Lex.getKind() == lltok::MetadataVar)
+ if (ParseGlobalObjectMetadataAttachment(F))
return true;
-
- F.setMetadata(MDK, N);
- }
return false;
}
@@ -1707,6 +1838,35 @@ bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
return false;
}
+bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
+ Optional<unsigned> &HowManyArg) {
+ Lex.Lex();
+
+ auto StartParen = Lex.getLoc();
+ if (!EatIfPresent(lltok::lparen))
+ return Error(StartParen, "expected '('");
+
+ if (ParseUInt32(BaseSizeArg))
+ return true;
+
+ if (EatIfPresent(lltok::comma)) {
+ auto HowManyAt = Lex.getLoc();
+ unsigned HowMany;
+ if (ParseUInt32(HowMany))
+ return true;
+ if (HowMany == BaseSizeArg)
+ return Error(HowManyAt,
+ "'allocsize' indices can't refer to the same parameter");
+ HowManyArg = HowMany;
+ } else
+ HowManyArg = None;
+
+ auto EndParen = Lex.getLoc();
+ if (!EatIfPresent(lltok::rparen))
+ return Error(EndParen, "expected ')'");
+ return false;
+}
+
/// ParseScopeAndOrdering
/// if isAtomic: ::= 'singlethread'? AtomicOrdering
/// else: ::=
@@ -1731,12 +1891,16 @@ bool LLParser::ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
bool LLParser::ParseOrdering(AtomicOrdering &Ordering) {
switch (Lex.getKind()) {
default: return TokError("Expected ordering on atomic instruction");
- case lltok::kw_unordered: Ordering = Unordered; break;
- case lltok::kw_monotonic: Ordering = Monotonic; break;
- case lltok::kw_acquire: Ordering = Acquire; break;
- case lltok::kw_release: Ordering = Release; break;
- case lltok::kw_acq_rel: Ordering = AcquireRelease; break;
- case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break;
+ case lltok::kw_unordered: Ordering = AtomicOrdering::Unordered; break;
+ case lltok::kw_monotonic: Ordering = AtomicOrdering::Monotonic; break;
+ // Not specified yet:
+ // case lltok::kw_consume: Ordering = AtomicOrdering::Consume; break;
+ case lltok::kw_acquire: Ordering = AtomicOrdering::Acquire; break;
+ case lltok::kw_release: Ordering = AtomicOrdering::Release; break;
+ case lltok::kw_acq_rel: Ordering = AtomicOrdering::AcquireRelease; break;
+ case lltok::kw_seq_cst:
+ Ordering = AtomicOrdering::SequentiallyConsistent;
+ break;
}
Lex.Lex();
return false;
@@ -3215,6 +3379,12 @@ struct DwarfVirtualityField : public MDUnsignedField {
struct DwarfLangField : public MDUnsignedField {
DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
};
+struct DwarfCCField : public MDUnsignedField {
+ DwarfCCField() : MDUnsignedField(0, dwarf::DW_CC_hi_user) {}
+};
+struct EmissionKindField : public MDUnsignedField {
+ EmissionKindField() : MDUnsignedField(0, DICompileUnit::LastEmissionKind) {}
+};
struct DIFlagField : public MDUnsignedField {
DIFlagField() : MDUnsignedField(0, UINT32_MAX) {}
@@ -3327,7 +3497,7 @@ bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
return TokError("expected DWARF virtuality code");
unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
- if (!Virtuality)
+ if (Virtuality == dwarf::DW_VIRTUALITY_invalid)
return TokError("invalid DWARF virtuality code" + Twine(" '") +
Lex.getStrVal() + "'");
assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
@@ -3355,6 +3525,42 @@ bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
}
template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
+ if (Lex.getKind() == lltok::APSInt)
+ return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+
+ if (Lex.getKind() != lltok::DwarfCC)
+ return TokError("expected DWARF calling convention");
+
+ unsigned CC = dwarf::getCallingConvention(Lex.getStrVal());
+ if (!CC)
+ return TokError("invalid DWARF calling convention" + Twine(" '") + Lex.getStrVal() +
+ "'");
+ assert(CC <= Result.Max && "Expected valid DWARF calling convention");
+ Result.assign(CC);
+ Lex.Lex();
+ return false;
+}
+
+template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name, EmissionKindField &Result) {
+ if (Lex.getKind() == lltok::APSInt)
+ return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
+
+ if (Lex.getKind() != lltok::EmissionKind)
+ return TokError("expected emission kind");
+
+ auto Kind = DICompileUnit::getEmissionKind(Lex.getStrVal());
+ if (!Kind)
+ return TokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() +
+ "'");
+ assert(*Kind <= Result.Max && "Expected valid emission kind");
+ Result.assign(*Kind);
+ Lex.Lex();
+ return false;
+}
+
+template <>
bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
DwarfAttEncodingField &Result) {
if (Lex.getKind() == lltok::APSInt)
@@ -3692,6 +3898,19 @@ bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
PARSE_MD_FIELDS();
#undef VISIT_MD_FIELDS
+ // If this has an identifier try to build an ODR type.
+ if (identifier.Val)
+ if (auto *CT = DICompositeType::buildODRType(
+ Context, *identifier.Val, tag.Val, name.Val, file.Val, line.Val,
+ scope.Val, baseType.Val, size.Val, align.Val, offset.Val, flags.Val,
+ elements.Val, runtimeLang.Val, vtableHolder.Val,
+ templateParams.Val)) {
+ Result = CT;
+ return false;
+ }
+
+ // Create a new node, and save it in the context if it belongs in the type
+ // map.
Result = GET_OR_DISTINCT(
DICompositeType,
(Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,
@@ -3703,11 +3922,13 @@ bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
OPTIONAL(flags, DIFlagField, ); \
+ OPTIONAL(cc, DwarfCCField, ); \
REQUIRED(types, MDField, );
PARSE_MD_FIELDS();
#undef VISIT_MD_FIELDS
- Result = GET_OR_DISTINCT(DISubroutineType, (Context, flags.Val, types.Val));
+ Result = GET_OR_DISTINCT(DISubroutineType,
+ (Context, flags.Val, cc.Val, types.Val));
return false;
}
@@ -3727,8 +3948,8 @@ bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
/// ParseDICompileUnit:
/// ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
/// isOptimized: true, flags: "-O2", runtimeVersion: 1,
-/// splitDebugFilename: "abc.debug", emissionKind: 1,
-/// enums: !1, retainedTypes: !2, subprograms: !3,
+/// splitDebugFilename: "abc.debug",
+/// emissionKind: FullDebug, enums: !1, retainedTypes: !2,
/// globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd)
bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
if (!IsDistinct)
@@ -3742,10 +3963,9 @@ bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
OPTIONAL(flags, MDStringField, ); \
OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX)); \
OPTIONAL(splitDebugFilename, MDStringField, ); \
- OPTIONAL(emissionKind, MDUnsignedField, (0, UINT32_MAX)); \
+ OPTIONAL(emissionKind, EmissionKindField, ); \
OPTIONAL(enums, MDField, ); \
OPTIONAL(retainedTypes, MDField, ); \
- OPTIONAL(subprograms, MDField, ); \
OPTIONAL(globals, MDField, ); \
OPTIONAL(imports, MDField, ); \
OPTIONAL(macros, MDField, ); \
@@ -3756,8 +3976,7 @@ bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
Result = DICompileUnit::getDistinct(
Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
- retainedTypes.Val, subprograms.Val, globals.Val, imports.Val, macros.Val,
- dwoId.Val);
+ retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val);
return false;
}
@@ -3766,7 +3985,7 @@ bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
/// file: !1, line: 7, type: !2, isLocal: false,
/// isDefinition: true, scopeLine: 8, containingType: !3,
/// virtuality: DW_VIRTUALTIY_pure_virtual,
-/// virtualIndex: 10, flags: 11,
+/// virtualIndex: 10, thisAdjustment: 4, flags: 11,
/// isOptimized: false, templateParams: !4, declaration: !5,
/// variables: !6)
bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
@@ -3784,8 +4003,10 @@ bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
OPTIONAL(containingType, MDField, ); \
OPTIONAL(virtuality, DwarfVirtualityField, ); \
OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX)); \
+ OPTIONAL(thisAdjustment, MDSignedField, (0, INT32_MIN, INT32_MAX)); \
OPTIONAL(flags, DIFlagField, ); \
OPTIONAL(isOptimized, MDBoolField, ); \
+ OPTIONAL(unit, MDField, ); \
OPTIONAL(templateParams, MDField, ); \
OPTIONAL(declaration, MDField, ); \
OPTIONAL(variables, MDField, );
@@ -3798,11 +4019,12 @@ bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
"missing 'distinct', required for !DISubprogram when 'isDefinition'");
Result = GET_OR_DISTINCT(
- DISubprogram,
- (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,
- type.Val, isLocal.Val, isDefinition.Val, scopeLine.Val,
- containingType.Val, virtuality.Val, virtualIndex.Val, flags.Val,
- isOptimized.Val, templateParams.Val, declaration.Val, variables.Val));
+ DISubprogram, (Context, scope.Val, name.Val, linkageName.Val, file.Val,
+ line.Val, type.Val, isLocal.Val, isDefinition.Val,
+ scopeLine.Val, containingType.Val, virtuality.Val,
+ virtualIndex.Val, thisAdjustment.Val, flags.Val,
+ isOptimized.Val, unit.Val, templateParams.Val,
+ declaration.Val, variables.Val));
return false;
}
@@ -4332,13 +4554,11 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
unsigned DLLStorageClass;
AttrBuilder RetAttrs;
unsigned CC;
+ bool HasLinkage;
Type *RetType = nullptr;
LocTy RetTypeLoc = Lex.getLoc();
- if (ParseOptionalLinkage(Linkage) ||
- ParseOptionalVisibility(Visibility) ||
- ParseOptionalDLLStorageClass(DLLStorageClass) ||
- ParseOptionalCallingConv(CC) ||
- ParseOptionalReturnAttrs(RetAttrs) ||
+ if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+ ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
ParseType(RetType, RetTypeLoc, true /*void allowed*/))
return true;
@@ -4400,7 +4620,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
std::string Section;
unsigned Alignment;
std::string GC;
- bool UnnamedAddr;
+ GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
LocTy UnnamedAddrLoc;
Constant *Prefix = nullptr;
Constant *Prologue = nullptr;
@@ -4408,8 +4628,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
Comdat *C;
if (ParseArgumentList(ArgList, isVarArg) ||
- ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
- &UnnamedAddrLoc) ||
+ ParseOptionalUnnamedAddr(UnnamedAddr) ||
ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
BuiltinLoc) ||
(EatIfPresent(lltok::kw_section) &&
@@ -4521,7 +4740,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
Fn->setSection(Section);
Fn->setComdat(C);
Fn->setPersonalityFn(PersonalityFn);
- if (!GC.empty()) Fn->setGC(GC.c_str());
+ if (!GC.empty()) Fn->setGC(GC);
Fn->setPrefixData(Prefix);
Fn->setPrologueData(Prologue);
ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
@@ -5735,7 +5954,8 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
//===----------------------------------------------------------------------===//
/// ParseAlloc
-/// ::= 'alloca' 'inalloca'? Type (',' TypeAndValue)? (',' 'align' i32)?
+/// ::= 'alloca' 'inalloca'? 'swifterror'? Type (',' TypeAndValue)?
+/// (',' 'align' i32)?
int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
Value *Size = nullptr;
LocTy SizeLoc, TyLoc;
@@ -5743,6 +5963,7 @@ int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
Type *Ty = nullptr;
bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
+ bool IsSwiftError = EatIfPresent(lltok::kw_swifterror);
if (ParseType(Ty, TyLoc)) return true;
@@ -5767,6 +5988,7 @@ int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
AllocaInst *AI = new AllocaInst(Ty, Size, Alignment);
AI->setUsedWithInAlloca(IsInAlloca);
+ AI->setSwiftError(IsSwiftError);
Inst = AI;
return AteExtraComma ? InstExtraComma : InstNormal;
}
@@ -5780,7 +6002,7 @@ int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
unsigned Alignment = 0;
bool AteExtraComma = false;
bool isAtomic = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (Lex.getKind() == lltok::kw_atomic) {
@@ -5807,7 +6029,8 @@ int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
return Error(Loc, "load operand must be a pointer to a first class type");
if (isAtomic && !Alignment)
return Error(Loc, "atomic load must have explicit non-zero alignment");
- if (Ordering == Release || Ordering == AcquireRelease)
+ if (Ordering == AtomicOrdering::Release ||
+ Ordering == AtomicOrdering::AcquireRelease)
return Error(Loc, "atomic load cannot use Release ordering");
if (Ty != cast<PointerType>(Val->getType())->getElementType())
@@ -5828,7 +6051,7 @@ int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) {
unsigned Alignment = 0;
bool AteExtraComma = false;
bool isAtomic = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (Lex.getKind() == lltok::kw_atomic) {
@@ -5857,7 +6080,8 @@ int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) {
return Error(Loc, "stored value and pointer type do not match");
if (isAtomic && !Alignment)
return Error(Loc, "atomic store must have explicit non-zero alignment");
- if (Ordering == Acquire || Ordering == AcquireRelease)
+ if (Ordering == AtomicOrdering::Acquire ||
+ Ordering == AtomicOrdering::AcquireRelease)
return Error(Loc, "atomic store cannot use Acquire ordering");
Inst = new StoreInst(Val, Ptr, isVolatile, Alignment, Ordering, Scope);
@@ -5870,8 +6094,8 @@ int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) {
int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
bool AteExtraComma = false;
- AtomicOrdering SuccessOrdering = NotAtomic;
- AtomicOrdering FailureOrdering = NotAtomic;
+ AtomicOrdering SuccessOrdering = AtomicOrdering::NotAtomic;
+ AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
bool isVolatile = false;
bool isWeak = false;
@@ -5891,25 +6115,24 @@ int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
ParseOrdering(FailureOrdering))
return true;
- if (SuccessOrdering == Unordered || FailureOrdering == Unordered)
+ if (SuccessOrdering == AtomicOrdering::Unordered ||
+ FailureOrdering == AtomicOrdering::Unordered)
return TokError("cmpxchg cannot be unordered");
- if (SuccessOrdering < FailureOrdering)
- return TokError("cmpxchg must be at least as ordered on success as failure");
- if (FailureOrdering == Release || FailureOrdering == AcquireRelease)
- return TokError("cmpxchg failure ordering cannot include release semantics");
+ if (isStrongerThan(FailureOrdering, SuccessOrdering))
+ return TokError("cmpxchg failure argument shall be no stronger than the "
+ "success argument");
+ if (FailureOrdering == AtomicOrdering::Release ||
+ FailureOrdering == AtomicOrdering::AcquireRelease)
+ return TokError(
+ "cmpxchg failure ordering cannot include release semantics");
if (!Ptr->getType()->isPointerTy())
return Error(PtrLoc, "cmpxchg operand must be a pointer");
if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
return Error(CmpLoc, "compare value and pointer type do not match");
if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
return Error(NewLoc, "new value and pointer type do not match");
- if (!New->getType()->isIntegerTy())
- return Error(NewLoc, "cmpxchg operand must be an integer");
- unsigned Size = New->getType()->getPrimitiveSizeInBits();
- if (Size < 8 || (Size & (Size - 1)))
- return Error(NewLoc, "cmpxchg operand must be power-of-two byte-sized"
- " integer");
-
+ if (!New->getType()->isFirstClassType())
+ return Error(NewLoc, "cmpxchg operand must be a first class value");
AtomicCmpXchgInst *CXI = new AtomicCmpXchgInst(
Ptr, Cmp, New, SuccessOrdering, FailureOrdering, Scope);
CXI->setVolatile(isVolatile);
@@ -5924,7 +6147,7 @@ int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
bool AteExtraComma = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
bool isVolatile = false;
AtomicRMWInst::BinOp Operation;
@@ -5954,7 +6177,7 @@ int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
return true;
- if (Ordering == Unordered)
+ if (Ordering == AtomicOrdering::Unordered)
return TokError("atomicrmw cannot be unordered");
if (!Ptr->getType()->isPointerTy())
return Error(PtrLoc, "atomicrmw operand must be a pointer");
@@ -5977,14 +6200,14 @@ int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
/// ParseFence
/// ::= 'fence' 'singlethread'? AtomicOrdering
int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) {
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
return true;
- if (Ordering == Unordered)
+ if (Ordering == AtomicOrdering::Unordered)
return TokError("fence cannot be unordered");
- if (Ordering == Monotonic)
+ if (Ordering == AtomicOrdering::Monotonic)
return TokError("fence cannot be monotonic");
Inst = new FenceInst(Context, Ordering, Scope);
diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h
index f61a5e5e3a38b..479ff96bc8a35 100644
--- a/lib/AsmParser/LLParser.h
+++ b/lib/AsmParser/LLParser.h
@@ -15,7 +15,7 @@
#define LLVM_LIB_ASMPARSER_LLPARSER_H
#include "LLLexer.h"
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/Instructions.h"
@@ -148,6 +148,9 @@ namespace llvm {
bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
+ bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
+ const SlotMapping *Slots);
+
LLVMContext &getContext() { return Context; }
private:
@@ -223,18 +226,14 @@ namespace llvm {
bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
- bool parseOptionalUnnamedAddr(bool &UnnamedAddr) {
- return ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr);
- }
+ bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
bool ParseOptionalAddrSpace(unsigned &AddrSpace);
bool ParseOptionalParamAttrs(AttrBuilder &B);
bool ParseOptionalReturnAttrs(AttrBuilder &B);
- bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage);
- bool ParseOptionalLinkage(unsigned &Linkage) {
- bool HasLinkage; return ParseOptionalLinkage(Linkage, HasLinkage);
- }
- bool ParseOptionalVisibility(unsigned &Visibility);
- bool ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
+ bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage,
+ unsigned &Visibility, unsigned &DLLStorageClass);
+ void ParseOptionalVisibility(unsigned &Visibility);
+ void ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
bool ParseOptionalCallingConv(unsigned &CC);
bool ParseOptionalAlignment(unsigned &Alignment);
bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
@@ -244,7 +243,10 @@ namespace llvm {
bool ParseOptionalStackAlignment(unsigned &Alignment);
bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
- bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,bool &AteExtraComma);
+ bool parseAllocSizeArguments(unsigned &ElemSizeArg,
+ Optional<unsigned> &HowManyArg);
+ bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,
+ bool &AteExtraComma);
bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
bool AteExtraComma;
if (ParseIndexList(Indices, AteExtraComma)) return true;
@@ -258,6 +260,7 @@ namespace llvm {
bool ValidateEndOfModule();
bool ParseTargetDefinition();
bool ParseModuleAsm();
+ bool ParseSourceFileName();
bool ParseDepLibs(); // FIXME: Remove in 4.0.
bool ParseUnnamedType();
bool ParseNamedType();
@@ -270,10 +273,13 @@ namespace llvm {
bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
bool HasLinkage, unsigned Visibility,
unsigned DLLStorageClass,
- GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr);
- bool ParseAlias(const std::string &Name, LocTy Loc, unsigned Linkage,
- unsigned Visibility, unsigned DLLStorageClass,
- GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr);
+ GlobalVariable::ThreadLocalMode TLM,
+ GlobalVariable::UnnamedAddr UnnamedAddr);
+ bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
+ unsigned Linkage, unsigned Visibility,
+ unsigned DLLStorageClass,
+ GlobalVariable::ThreadLocalMode TLM,
+ GlobalVariable::UnnamedAddr UnnamedAddr);
bool parseComdat();
bool ParseStandaloneMetadata();
bool ParseNamedMetadata();
@@ -417,6 +423,7 @@ namespace llvm {
bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &MDs);
bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
bool ParseInstructionMetadata(Instruction &Inst);
+ bool ParseGlobalObjectMetadataAttachment(GlobalObject &GO);
bool ParseOptionalFunctionMetadata(Function &F);
template <class FieldTy>
diff --git a/lib/AsmParser/LLToken.h b/lib/AsmParser/LLToken.h
index 29a7f16d3c209..37998e879503d 100644
--- a/lib/AsmParser/LLToken.h
+++ b/lib/AsmParser/LLToken.h
@@ -16,218 +16,348 @@
namespace llvm {
namespace lltok {
- enum Kind {
- // Markers
- Eof, Error,
-
- // Tokens with no info.
- dotdotdot, // ...
- equal, comma, // = ,
- star, // *
- lsquare, rsquare, // [ ]
- lbrace, rbrace, // { }
- less, greater, // < >
- lparen, rparen, // ( )
- exclaim, // !
- bar, // |
-
- kw_x,
- kw_true, kw_false,
- kw_declare, kw_define,
- kw_global, kw_constant,
-
- kw_private,
- kw_internal,
- kw_linkonce, kw_linkonce_odr,
- kw_weak, // Used as a linkage, and a modifier for "cmpxchg".
- kw_weak_odr, kw_appending,
- kw_dllimport, kw_dllexport, kw_common, kw_available_externally,
- kw_default, kw_hidden, kw_protected,
- kw_unnamed_addr,
- kw_externally_initialized,
- kw_extern_weak,
- kw_external, kw_thread_local,
- kw_localdynamic, kw_initialexec, kw_localexec,
- kw_zeroinitializer,
- kw_undef, kw_null, kw_none,
- kw_to,
- kw_caller,
- kw_within,
- kw_from,
- kw_tail,
- kw_musttail,
- kw_notail,
- kw_target,
- kw_triple,
- kw_unwind,
- kw_deplibs, // FIXME: Remove in 4.0
- kw_datalayout,
- kw_volatile,
- kw_atomic,
- kw_unordered, kw_monotonic, kw_acquire, kw_release, kw_acq_rel, kw_seq_cst,
- kw_singlethread,
- kw_nnan,
- kw_ninf,
- kw_nsz,
- kw_arcp,
- kw_fast,
- kw_nuw,
- kw_nsw,
- kw_exact,
- kw_inbounds,
- kw_align,
- kw_addrspace,
- kw_section,
- kw_alias,
- kw_module,
- kw_asm,
- kw_sideeffect,
- kw_alignstack,
- kw_inteldialect,
- kw_gc,
- kw_prefix,
- kw_prologue,
- kw_c,
-
- kw_cc, kw_ccc, kw_fastcc, kw_coldcc,
- kw_intel_ocl_bicc,
- kw_x86_stdcallcc, kw_x86_fastcallcc, kw_x86_thiscallcc, kw_x86_vectorcallcc,
- kw_arm_apcscc, kw_arm_aapcscc, kw_arm_aapcs_vfpcc,
- kw_msp430_intrcc,
- kw_ptx_kernel, kw_ptx_device,
- kw_spir_kernel, kw_spir_func,
- kw_x86_64_sysvcc, kw_x86_64_win64cc,
- kw_webkit_jscc, kw_anyregcc,
- kw_preserve_mostcc, kw_preserve_allcc,
- kw_ghccc,
- kw_x86_intrcc,
- kw_hhvmcc, kw_hhvm_ccc,
- kw_cxx_fast_tlscc,
-
- // Attributes:
- kw_attributes,
- kw_alwaysinline,
- kw_argmemonly,
- kw_sanitize_address,
- kw_builtin,
- kw_byval,
- kw_inalloca,
- kw_cold,
- kw_convergent,
- kw_dereferenceable,
- kw_dereferenceable_or_null,
- kw_inaccessiblememonly,
- kw_inaccessiblemem_or_argmemonly,
- kw_inlinehint,
- kw_inreg,
- kw_jumptable,
- kw_minsize,
- kw_naked,
- kw_nest,
- kw_noalias,
- kw_nobuiltin,
- kw_nocapture,
- kw_noduplicate,
- kw_noimplicitfloat,
- kw_noinline,
- kw_norecurse,
- kw_nonlazybind,
- kw_nonnull,
- kw_noredzone,
- kw_noreturn,
- kw_nounwind,
- kw_optnone,
- kw_optsize,
- kw_readnone,
- kw_readonly,
- kw_returned,
- kw_returns_twice,
- kw_signext,
- kw_ssp,
- kw_sspreq,
- kw_sspstrong,
- kw_safestack,
- kw_sret,
- kw_sanitize_thread,
- kw_sanitize_memory,
- kw_uwtable,
- kw_zeroext,
-
- kw_type,
- kw_opaque,
-
- kw_comdat,
-
- // Comdat types
- kw_any,
- kw_exactmatch,
- kw_largest,
- kw_noduplicates,
- kw_samesize,
-
- kw_eq, kw_ne, kw_slt, kw_sgt, kw_sle, kw_sge, kw_ult, kw_ugt, kw_ule,
- kw_uge, kw_oeq, kw_one, kw_olt, kw_ogt, kw_ole, kw_oge, kw_ord, kw_uno,
- kw_ueq, kw_une,
-
- // atomicrmw operations that aren't also instruction keywords.
- kw_xchg, kw_nand, kw_max, kw_min, kw_umax, kw_umin,
-
- // Instruction Opcodes (Opcode in UIntVal).
- kw_add, kw_fadd, kw_sub, kw_fsub, kw_mul, kw_fmul,
- kw_udiv, kw_sdiv, kw_fdiv,
- kw_urem, kw_srem, kw_frem, kw_shl, kw_lshr, kw_ashr,
- kw_and, kw_or, kw_xor, kw_icmp, kw_fcmp,
-
- kw_phi, kw_call,
- kw_trunc, kw_zext, kw_sext, kw_fptrunc, kw_fpext, kw_uitofp, kw_sitofp,
- kw_fptoui, kw_fptosi, kw_inttoptr, kw_ptrtoint, kw_bitcast,
- kw_addrspacecast,
- kw_select, kw_va_arg,
-
- kw_landingpad, kw_personality, kw_cleanup, kw_catch, kw_filter,
-
- kw_ret, kw_br, kw_switch, kw_indirectbr, kw_invoke, kw_resume,
- kw_unreachable, kw_cleanupret, kw_catchswitch, kw_catchret, kw_catchpad,
- kw_cleanuppad,
-
- kw_alloca, kw_load, kw_store, kw_fence, kw_cmpxchg, kw_atomicrmw,
- kw_getelementptr,
-
- kw_extractelement, kw_insertelement, kw_shufflevector,
- kw_extractvalue, kw_insertvalue, kw_blockaddress,
-
- // Metadata types.
- kw_distinct,
-
- // Use-list order directives.
- kw_uselistorder, kw_uselistorder_bb,
-
- // Unsigned Valued tokens (UIntVal).
- GlobalID, // @42
- LocalVarID, // %42
- AttrGrpID, // #42
-
- // String valued tokens (StrVal).
- LabelStr, // foo:
- GlobalVar, // @foo @"foo"
- ComdatVar, // $foo
- LocalVar, // %foo %"foo"
- MetadataVar, // !foo
- StringConstant, // "foo"
- DwarfTag, // DW_TAG_foo
- DwarfAttEncoding, // DW_ATE_foo
- DwarfVirtuality, // DW_VIRTUALITY_foo
- DwarfLang, // DW_LANG_foo
- DwarfOp, // DW_OP_foo
- DIFlag, // DIFlagFoo
- DwarfMacinfo, // DW_MACINFO_foo
-
- // Type valued tokens (TyVal).
- Type,
-
- APFloat, // APFloatVal
- APSInt // APSInt
- };
+enum Kind {
+ // Markers
+ Eof,
+ Error,
+
+ // Tokens with no info.
+ dotdotdot, // ...
+ equal,
+ comma, // = ,
+ star, // *
+ lsquare,
+ rsquare, // [ ]
+ lbrace,
+ rbrace, // { }
+ less,
+ greater, // < >
+ lparen,
+ rparen, // ( )
+ exclaim, // !
+ bar, // |
+
+ kw_x,
+ kw_true,
+ kw_false,
+ kw_declare,
+ kw_define,
+ kw_global,
+ kw_constant,
+
+ kw_private,
+ kw_internal,
+ kw_linkonce,
+ kw_linkonce_odr,
+ kw_weak, // Used as a linkage, and a modifier for "cmpxchg".
+ kw_weak_odr,
+ kw_appending,
+ kw_dllimport,
+ kw_dllexport,
+ kw_common,
+ kw_available_externally,
+ kw_default,
+ kw_hidden,
+ kw_protected,
+ kw_unnamed_addr,
+ kw_local_unnamed_addr,
+ kw_externally_initialized,
+ kw_extern_weak,
+ kw_external,
+ kw_thread_local,
+ kw_localdynamic,
+ kw_initialexec,
+ kw_localexec,
+ kw_zeroinitializer,
+ kw_undef,
+ kw_null,
+ kw_none,
+ kw_to,
+ kw_caller,
+ kw_within,
+ kw_from,
+ kw_tail,
+ kw_musttail,
+ kw_notail,
+ kw_target,
+ kw_triple,
+ kw_source_filename,
+ kw_unwind,
+ kw_deplibs, // FIXME: Remove in 4.0
+ kw_datalayout,
+ kw_volatile,
+ kw_atomic,
+ kw_unordered,
+ kw_monotonic,
+ kw_acquire,
+ kw_release,
+ kw_acq_rel,
+ kw_seq_cst,
+ kw_singlethread,
+ kw_nnan,
+ kw_ninf,
+ kw_nsz,
+ kw_arcp,
+ kw_fast,
+ kw_nuw,
+ kw_nsw,
+ kw_exact,
+ kw_inbounds,
+ kw_align,
+ kw_addrspace,
+ kw_section,
+ kw_alias,
+ kw_ifunc,
+ kw_module,
+ kw_asm,
+ kw_sideeffect,
+ kw_alignstack,
+ kw_inteldialect,
+ kw_gc,
+ kw_prefix,
+ kw_prologue,
+ kw_c,
+
+ kw_cc,
+ kw_ccc,
+ kw_fastcc,
+ kw_coldcc,
+ kw_intel_ocl_bicc,
+ kw_x86_stdcallcc,
+ kw_x86_fastcallcc,
+ kw_x86_thiscallcc,
+ kw_x86_vectorcallcc,
+ kw_arm_apcscc,
+ kw_arm_aapcscc,
+ kw_arm_aapcs_vfpcc,
+ kw_msp430_intrcc,
+ kw_avr_intrcc,
+ kw_avr_signalcc,
+ kw_ptx_kernel,
+ kw_ptx_device,
+ kw_spir_kernel,
+ kw_spir_func,
+ kw_x86_64_sysvcc,
+ kw_x86_64_win64cc,
+ kw_webkit_jscc,
+ kw_anyregcc,
+ kw_swiftcc,
+ kw_preserve_mostcc,
+ kw_preserve_allcc,
+ kw_ghccc,
+ kw_x86_intrcc,
+ kw_hhvmcc,
+ kw_hhvm_ccc,
+ kw_cxx_fast_tlscc,
+ kw_amdgpu_vs,
+ kw_amdgpu_gs,
+ kw_amdgpu_ps,
+ kw_amdgpu_cs,
+ kw_amdgpu_kernel,
+
+ // Attributes:
+ kw_attributes,
+ kw_allocsize,
+ kw_alwaysinline,
+ kw_argmemonly,
+ kw_sanitize_address,
+ kw_builtin,
+ kw_byval,
+ kw_inalloca,
+ kw_cold,
+ kw_convergent,
+ kw_dereferenceable,
+ kw_dereferenceable_or_null,
+ kw_inaccessiblememonly,
+ kw_inaccessiblemem_or_argmemonly,
+ kw_inlinehint,
+ kw_inreg,
+ kw_jumptable,
+ kw_minsize,
+ kw_naked,
+ kw_nest,
+ kw_noalias,
+ kw_nobuiltin,
+ kw_nocapture,
+ kw_noduplicate,
+ kw_noimplicitfloat,
+ kw_noinline,
+ kw_norecurse,
+ kw_nonlazybind,
+ kw_nonnull,
+ kw_noredzone,
+ kw_noreturn,
+ kw_nounwind,
+ kw_optnone,
+ kw_optsize,
+ kw_readnone,
+ kw_readonly,
+ kw_returned,
+ kw_returns_twice,
+ kw_signext,
+ kw_ssp,
+ kw_sspreq,
+ kw_sspstrong,
+ kw_safestack,
+ kw_sret,
+ kw_sanitize_thread,
+ kw_sanitize_memory,
+ kw_swifterror,
+ kw_swiftself,
+ kw_uwtable,
+ kw_writeonly,
+ kw_zeroext,
+
+ kw_type,
+ kw_opaque,
+
+ kw_comdat,
+
+ // Comdat types
+ kw_any,
+ kw_exactmatch,
+ kw_largest,
+ kw_noduplicates,
+ kw_samesize,
+
+ kw_eq,
+ kw_ne,
+ kw_slt,
+ kw_sgt,
+ kw_sle,
+ kw_sge,
+ kw_ult,
+ kw_ugt,
+ kw_ule,
+ kw_uge,
+ kw_oeq,
+ kw_one,
+ kw_olt,
+ kw_ogt,
+ kw_ole,
+ kw_oge,
+ kw_ord,
+ kw_uno,
+ kw_ueq,
+ kw_une,
+
+ // atomicrmw operations that aren't also instruction keywords.
+ kw_xchg,
+ kw_nand,
+ kw_max,
+ kw_min,
+ kw_umax,
+ kw_umin,
+
+ // Instruction Opcodes (Opcode in UIntVal).
+ kw_add,
+ kw_fadd,
+ kw_sub,
+ kw_fsub,
+ kw_mul,
+ kw_fmul,
+ kw_udiv,
+ kw_sdiv,
+ kw_fdiv,
+ kw_urem,
+ kw_srem,
+ kw_frem,
+ kw_shl,
+ kw_lshr,
+ kw_ashr,
+ kw_and,
+ kw_or,
+ kw_xor,
+ kw_icmp,
+ kw_fcmp,
+
+ kw_phi,
+ kw_call,
+ kw_trunc,
+ kw_zext,
+ kw_sext,
+ kw_fptrunc,
+ kw_fpext,
+ kw_uitofp,
+ kw_sitofp,
+ kw_fptoui,
+ kw_fptosi,
+ kw_inttoptr,
+ kw_ptrtoint,
+ kw_bitcast,
+ kw_addrspacecast,
+ kw_select,
+ kw_va_arg,
+
+ kw_landingpad,
+ kw_personality,
+ kw_cleanup,
+ kw_catch,
+ kw_filter,
+
+ kw_ret,
+ kw_br,
+ kw_switch,
+ kw_indirectbr,
+ kw_invoke,
+ kw_resume,
+ kw_unreachable,
+ kw_cleanupret,
+ kw_catchswitch,
+ kw_catchret,
+ kw_catchpad,
+ kw_cleanuppad,
+
+ kw_alloca,
+ kw_load,
+ kw_store,
+ kw_fence,
+ kw_cmpxchg,
+ kw_atomicrmw,
+ kw_getelementptr,
+
+ kw_extractelement,
+ kw_insertelement,
+ kw_shufflevector,
+ kw_extractvalue,
+ kw_insertvalue,
+ kw_blockaddress,
+
+ // Metadata types.
+ kw_distinct,
+
+ // Use-list order directives.
+ kw_uselistorder,
+ kw_uselistorder_bb,
+
+ // Unsigned Valued tokens (UIntVal).
+ GlobalID, // @42
+ LocalVarID, // %42
+ AttrGrpID, // #42
+
+ // String valued tokens (StrVal).
+ LabelStr, // foo:
+ GlobalVar, // @foo @"foo"
+ ComdatVar, // $foo
+ LocalVar, // %foo %"foo"
+ MetadataVar, // !foo
+ StringConstant, // "foo"
+ DwarfTag, // DW_TAG_foo
+ DwarfAttEncoding, // DW_ATE_foo
+ DwarfVirtuality, // DW_VIRTUALITY_foo
+ DwarfLang, // DW_LANG_foo
+ DwarfCC, // DW_CC_foo
+ EmissionKind, // lineTablesOnly
+ DwarfOp, // DW_OP_foo
+ DIFlag, // DIFlagFoo
+ DwarfMacinfo, // DW_MACINFO_foo
+
+ // Type valued tokens (TyVal).
+ Type,
+
+ APFloat, // APFloatVal
+ APSInt // APSInt
+};
} // end namespace lltok
} // end namespace llvm
diff --git a/lib/AsmParser/Makefile b/lib/AsmParser/Makefile
deleted file mode 100644
index 995bb0e130e2b..0000000000000
--- a/lib/AsmParser/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-##===- lib/AsmParser/Makefile ------------------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-LEVEL = ../..
-LIBRARYNAME := LLVMAsmParser
-BUILD_ARCHIVE = 1
-
-include $(LEVEL)/Makefile.common
diff --git a/lib/AsmParser/Parser.cpp b/lib/AsmParser/Parser.cpp
index 4e55e62ecf5c4..bee07ad9e0a52 100644
--- a/lib/AsmParser/Parser.cpp
+++ b/lib/AsmParser/Parser.cpp
@@ -78,3 +78,32 @@ Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
return nullptr;
return C;
}
+
+Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
+ const SlotMapping *Slots) {
+ unsigned Read;
+ Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
+ if (!Ty)
+ return nullptr;
+ if (Read != Asm.size()) {
+ SourceMgr SM;
+ std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
+ SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+ Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
+ SourceMgr::DK_Error, "expected end of string");
+ return nullptr;
+ }
+ return Ty;
+}
+Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read,
+ SMDiagnostic &Err, const Module &M,
+ const SlotMapping *Slots) {
+ SourceMgr SM;
+ std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
+ SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+ Type *Ty;
+ if (LLParser(Asm, SM, Err, const_cast<Module *>(&M))
+ .parseTypeAtBeginning(Ty, Read, Slots))
+ return nullptr;
+ return Ty;
+}
diff --git a/lib/AsmParser/module.modulemap b/lib/AsmParser/module.modulemap
deleted file mode 100644
index cc300060b3f55..0000000000000
--- a/lib/AsmParser/module.modulemap
+++ /dev/null
@@ -1 +0,0 @@
-module AsmParser { requires cplusplus umbrella "." module * { export * } }
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-18 09:59:59 +0000