X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FAsmParser%2FLLParser.cpp;h=5dd65691a3d1f2449624a6bf6fffd117c72e3dbf;hp=295329bf970e026611b9f91db6067a04aad7c6ef;hb=570a4a5d9ca31f276a67502d1e0533d59d331fea;hpb=f633a065de959b32892c51d741d4db010c5d25b1 diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index 295329bf970..5dd65691a3d 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -18,8 +18,6 @@ #include "llvm/DerivedTypes.h" #include "llvm/InlineAsm.h" #include "llvm/Instructions.h" -#include "llvm/LLVMContext.h" -#include "llvm/Metadata.h" #include "llvm/Module.h" #include "llvm/Operator.h" #include "llvm/ValueSymbolTable.h" @@ -29,34 +27,6 @@ #include "llvm/Support/raw_ostream.h" using namespace llvm; -namespace llvm { - /// ValID - Represents a reference of a definition of some sort with no type. - /// There are several cases where we have to parse the value but where the - /// type can depend on later context. This may either be a numeric reference - /// or a symbolic (%var) reference. This is just a discriminated union. - struct ValID { - enum { - t_LocalID, t_GlobalID, // ID in UIntVal. - t_LocalName, t_GlobalName, // Name in StrVal. - t_APSInt, t_APFloat, // Value in APSIntVal/APFloatVal. - t_Null, t_Undef, t_Zero, // No value. - t_EmptyArray, // No value: [] - t_Constant, // Value in ConstantVal. - t_InlineAsm, // Value in StrVal/StrVal2/UIntVal. - t_Metadata // Value in MetadataVal. - } Kind; - - LLParser::LocTy Loc; - unsigned UIntVal; - std::string StrVal, StrVal2; - APSInt APSIntVal; - APFloat APFloatVal; - Constant *ConstantVal; - MetadataBase *MetadataVal; - ValID() : APFloatVal(0.0) {} - }; -} - /// Run: module ::= toplevelentity* bool LLParser::Run() { // Prime the lexer. @@ -69,6 +39,48 @@ bool LLParser::Run() { /// ValidateEndOfModule - Do final validity and sanity checks at the end of the /// module. bool LLParser::ValidateEndOfModule() { + // Update auto-upgraded malloc calls to "malloc". + // FIXME: Remove in LLVM 3.0. + if (MallocF) { + MallocF->setName("malloc"); + // If setName() does not set the name to "malloc", then there is already a + // declaration of "malloc". In that case, iterate over all calls to MallocF + // and get them to call the declared "malloc" instead. + if (MallocF->getName() != "malloc") { + Constant *RealMallocF = M->getFunction("malloc"); + if (RealMallocF->getType() != MallocF->getType()) + RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType()); + MallocF->replaceAllUsesWith(RealMallocF); + MallocF->eraseFromParent(); + MallocF = NULL; + } + } + + + // If there are entries in ForwardRefBlockAddresses at this point, they are + // references after the function was defined. Resolve those now. + while (!ForwardRefBlockAddresses.empty()) { + // Okay, we are referencing an already-parsed function, resolve them now. + Function *TheFn = 0; + const ValID &Fn = ForwardRefBlockAddresses.begin()->first; + if (Fn.Kind == ValID::t_GlobalName) + TheFn = M->getFunction(Fn.StrVal); + else if (Fn.UIntVal < NumberedVals.size()) + TheFn = dyn_cast(NumberedVals[Fn.UIntVal]); + + if (TheFn == 0) + return Error(Fn.Loc, "unknown function referenced by blockaddress"); + + // Resolve all these references. + if (ResolveForwardRefBlockAddresses(TheFn, + ForwardRefBlockAddresses.begin()->second, + 0)) + return true; + + ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin()); + } + + if (!ForwardRefTypes.empty()) return Error(ForwardRefTypes.begin()->second.second, "use of undefined type named '" + @@ -77,32 +89,64 @@ bool LLParser::ValidateEndOfModule() { return Error(ForwardRefTypeIDs.begin()->second.second, "use of undefined type '%" + utostr(ForwardRefTypeIDs.begin()->first) + "'"); - + if (!ForwardRefVals.empty()) return Error(ForwardRefVals.begin()->second.second, "use of undefined value '@" + ForwardRefVals.begin()->first + "'"); - + if (!ForwardRefValIDs.empty()) return Error(ForwardRefValIDs.begin()->second.second, "use of undefined value '@" + utostr(ForwardRefValIDs.begin()->first) + "'"); - + if (!ForwardRefMDNodes.empty()) return Error(ForwardRefMDNodes.begin()->second.second, "use of undefined metadata '!" + utostr(ForwardRefMDNodes.begin()->first) + "'"); - + // 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 - + // Check debug info intrinsics. CheckDebugInfoIntrinsics(M); return false; } +bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn, + std::vector > &Refs, + PerFunctionState *PFS) { + // Loop over all the references, resolving them. + for (unsigned i = 0, e = Refs.size(); i != e; ++i) { + BasicBlock *Res; + if (PFS) { + if (Refs[i].first.Kind == ValID::t_LocalName) + Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc); + else + Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc); + } else if (Refs[i].first.Kind == ValID::t_LocalID) { + return Error(Refs[i].first.Loc, + "cannot take address of numeric label after the function is defined"); + } else { + Res = dyn_cast_or_null( + TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal)); + } + + if (Res == 0) + return Error(Refs[i].first.Loc, + "referenced value is not a basic block"); + + // Get the BlockAddress for this and update references to use it. + BlockAddress *BA = BlockAddress::get(TheFn, Res); + Refs[i].second->replaceAllUsesWith(BA); + Refs[i].second->eraseFromParent(); + } + return false; +} + + //===----------------------------------------------------------------------===// // Top-Level Entities //===----------------------------------------------------------------------===// @@ -124,8 +168,8 @@ bool LLParser::ParseTopLevelEntities() { case lltok::LocalVar: if (ParseNamedType()) return true; break; case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break; case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break; - case lltok::Metadata: if (ParseStandaloneMetadata()) return true; break; - case lltok::NamedMD: if (ParseNamedMetadata()) 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: @@ -160,7 +204,7 @@ bool LLParser::ParseTopLevelEntities() { return true; break; } - + case lltok::kw_thread_local: // OptionalThreadLocal case lltok::kw_addrspace: // OptionalAddrSpace case lltok::kw_constant: // GlobalType @@ -177,11 +221,11 @@ bool LLParser::ParseTopLevelEntities() { bool LLParser::ParseModuleAsm() { assert(Lex.getKind() == lltok::kw_module); Lex.Lex(); - - std::string AsmStr; + + std::string AsmStr; if (ParseToken(lltok::kw_asm, "expected 'module asm'") || ParseStringConstant(AsmStr)) return true; - + const std::string &AsmSoFar = M->getModuleInlineAsm(); if (AsmSoFar.empty()) M->setModuleInlineAsm(AsmStr); @@ -227,7 +271,7 @@ bool LLParser::ParseDepLibs() { if (EatIfPresent(lltok::rsquare)) return false; - + std::string Str; if (ParseStringConstant(Str)) return true; M->addLibrary(Str); @@ -263,21 +307,21 @@ bool LLParser::ParseUnnamedType() { PATypeHolder Ty(Type::getVoidTy(Context)); if (ParseType(Ty)) return true; - + // See if this type was previously referenced. std::map >::iterator FI = ForwardRefTypeIDs.find(TypeID); if (FI != ForwardRefTypeIDs.end()) { if (FI->second.first.get() == Ty) return Error(TypeLoc, "self referential type is invalid"); - + cast(FI->second.first.get())->refineAbstractTypeTo(Ty); Ty = FI->second.first.get(); ForwardRefTypeIDs.erase(FI); } - + NumberedTypes.push_back(Ty); - + return false; } @@ -287,14 +331,14 @@ bool LLParser::ParseNamedType() { std::string Name = Lex.getStrVal(); LocTy NameLoc = Lex.getLoc(); Lex.Lex(); // eat LocalVar. - + PATypeHolder Ty(Type::getVoidTy(Context)); - + if (ParseToken(lltok::equal, "expected '=' after name") || ParseToken(lltok::kw_type, "expected 'type' after name") || ParseType(Ty)) return true; - + // Set the type name, checking for conflicts as we do so. bool AlreadyExists = M->addTypeName(Name, Ty); if (!AlreadyExists) return false; @@ -311,16 +355,16 @@ bool LLParser::ParseNamedType() { Ty = FI->second.first.get(); ForwardRefTypes.erase(FI); } - + // Inserting a name that is already defined, get the existing name. const Type *Existing = M->getTypeByName(Name); assert(Existing && "Conflict but no matching type?!"); - + // Otherwise, this is an attempt to redefine a type. That's okay if // the redefinition is identical to the original. // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0 if (Existing == Ty) return false; - + // Any other kind of (non-equivalent) redefinition is an error. return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" + Ty->getDescription() + "'"); @@ -332,7 +376,7 @@ bool LLParser::ParseNamedType() { bool LLParser::ParseDeclare() { assert(Lex.getKind() == lltok::kw_declare); Lex.Lex(); - + Function *F; return ParseFunctionHeader(F, false); } @@ -342,7 +386,7 @@ bool LLParser::ParseDeclare() { bool LLParser::ParseDefine() { assert(Lex.getKind() == lltok::kw_define); Lex.Lex(); - + Function *F; return ParseFunctionHeader(F, true) || ParseFunctionBody(*F); @@ -390,7 +434,7 @@ bool LLParser::ParseUnnamedGlobal() { if (ParseOptionalLinkage(Linkage, HasLinkage) || ParseOptionalVisibility(Visibility)) return true; - + if (HasLinkage || Lex.getKind() != lltok::kw_alias) return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); return ParseAlias(Name, NameLoc, Visibility); @@ -404,14 +448,14 @@ bool LLParser::ParseNamedGlobal() { LocTy NameLoc = Lex.getLoc(); std::string Name = Lex.getStrVal(); Lex.Lex(); - + bool HasLinkage; unsigned Linkage, Visibility; if (ParseToken(lltok::equal, "expected '=' in global variable") || ParseOptionalLinkage(Linkage, HasLinkage) || ParseOptionalVisibility(Visibility)) return true; - + if (HasLinkage || Lex.getKind() != lltok::kw_alias) return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); return ParseAlias(Name, NameLoc, Visibility); @@ -419,69 +463,66 @@ bool LLParser::ParseNamedGlobal() { // MDString: // ::= '!' STRINGCONSTANT -bool LLParser::ParseMDString(MetadataBase *&MDS) { +bool LLParser::ParseMDString(MDString *&Result) { std::string Str; if (ParseStringConstant(Str)) return true; - MDS = MDString::get(Context, Str); + Result = MDString::get(Context, Str); return false; } // MDNode: // ::= '!' MDNodeNumber -bool LLParser::ParseMDNode(MetadataBase *&Node) { +bool LLParser::ParseMDNodeID(MDNode *&Result) { // !{ ..., !42, ... } unsigned MID = 0; - if (ParseUInt32(MID)) return true; - + if (ParseUInt32(MID)) return true; + // Check existing MDNode. - std::map::iterator I = MetadataCache.find(MID); - if (I != MetadataCache.end()) { - Node = I->second; + if (MID < NumberedMetadata.size() && NumberedMetadata[MID] != 0) { + Result = NumberedMetadata[MID]; return false; } - // Check known forward references. - std::map >::iterator - FI = ForwardRefMDNodes.find(MID); - if (FI != ForwardRefMDNodes.end()) { - Node = FI->second.first; - return false; - } + // Create MDNode forward reference. - // Create MDNode forward reference - SmallVector Elts; + // FIXME: This is not unique enough! std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID); - Elts.push_back(MDString::get(Context, FwdRefName)); - MDNode *FwdNode = MDNode::get(Context, Elts.data(), Elts.size()); + Value *V = MDString::get(Context, FwdRefName); + MDNode *FwdNode = MDNode::get(Context, &V, 1); ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc()); - Node = FwdNode; + + if (NumberedMetadata.size() <= MID) + NumberedMetadata.resize(MID+1); + NumberedMetadata[MID] = FwdNode; + Result = FwdNode; return false; -} +} -///ParseNamedMetadata: +/// ParseNamedMetadata: /// !foo = !{ !1, !2 } bool LLParser::ParseNamedMetadata() { - assert(Lex.getKind() == lltok::NamedMD); - Lex.Lex(); + assert(Lex.getKind() == lltok::MetadataVar); std::string Name = Lex.getStrVal(); + Lex.Lex(); - if (ParseToken(lltok::equal, "expected '=' here")) + if (ParseToken(lltok::equal, "expected '=' here") || + ParseToken(lltok::exclaim, "Expected '!' here") || + ParseToken(lltok::lbrace, "Expected '{' here")) return true; - if (Lex.getKind() != lltok::Metadata) - return TokError("Expected '!' here"); - Lex.Lex(); - - if (Lex.getKind() != lltok::lbrace) - return TokError("Expected '{' here"); - Lex.Lex(); - SmallVector Elts; + SmallVector Elts; do { - if (Lex.getKind() != lltok::Metadata) - return TokError("Expected '!' here"); - Lex.Lex(); - MetadataBase *N = 0; - if (ParseMDNode(N)) return true; + // Null is a special case since it is typeless. + if (EatIfPresent(lltok::kw_null)) { + Elts.push_back(0); + continue; + } + + if (ParseToken(lltok::exclaim, "Expected '!' here")) + return true; + + MDNode *N = 0; + if (ParseMDNodeID(N)) return true; Elts.push_back(N); } while (EatIfPresent(lltok::comma)); @@ -493,43 +534,41 @@ bool LLParser::ParseNamedMetadata() { } /// ParseStandaloneMetadata: -/// !42 = !{...} +/// !42 = !{...} bool LLParser::ParseStandaloneMetadata() { - assert(Lex.getKind() == lltok::Metadata); + assert(Lex.getKind() == lltok::exclaim); Lex.Lex(); unsigned MetadataID = 0; - if (ParseUInt32(MetadataID)) - return true; - if (MetadataCache.find(MetadataID) != MetadataCache.end()) - return TokError("Metadata id is already used"); - if (ParseToken(lltok::equal, "expected '=' here")) - return true; LocTy TyLoc; PATypeHolder Ty(Type::getVoidTy(Context)); - if (ParseType(Ty, TyLoc)) - return true; - - if (Lex.getKind() != lltok::Metadata) - return TokError("Expected metadata here"); - - Lex.Lex(); - if (Lex.getKind() != lltok::lbrace) - return TokError("Expected '{' here"); - SmallVector Elts; - if (ParseMDNodeVector(Elts) - || ParseToken(lltok::rbrace, "expected end of metadata node")) + if (ParseUInt32(MetadataID) || + ParseToken(lltok::equal, "expected '=' here") || + ParseType(Ty, TyLoc) || + ParseToken(lltok::exclaim, "Expected '!' here") || + ParseToken(lltok::lbrace, "Expected '{' here") || + ParseMDNodeVector(Elts, NULL) || + ParseToken(lltok::rbrace, "expected end of metadata node")) return true; MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size()); - MetadataCache[MetadataID] = Init; - std::map >::iterator + + // See if this was forward referenced, if so, handle it. + std::map, LocTy> >::iterator FI = ForwardRefMDNodes.find(MetadataID); if (FI != ForwardRefMDNodes.end()) { - MDNode *FwdNode = cast(FI->second.first); - FwdNode->replaceAllUsesWith(Init); + FI->second.first->replaceAllUsesWith(Init); ForwardRefMDNodes.erase(FI); + + assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work"); + } else { + if (MetadataID >= NumberedMetadata.size()) + NumberedMetadata.resize(MetadataID+1); + + if (NumberedMetadata[MetadataID] != 0) + return TokError("Metadata id is already used"); + NumberedMetadata[MetadataID] = Init; } return false; @@ -560,7 +599,7 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, Linkage != GlobalValue::PrivateLinkage && Linkage != GlobalValue::LinkerPrivateLinkage) return Error(LinkageLoc, "invalid linkage type for alias"); - + Constant *Aliasee; LocTy AliaseeLoc = Lex.getLoc(); if (Lex.getKind() != lltok::kw_bitcast && @@ -574,7 +613,7 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, return Error(AliaseeLoc, "invalid aliasee"); Aliasee = ID.ConstantVal; } - + if (!isa(Aliasee->getType())) return Error(AliaseeLoc, "alias must have pointer type"); @@ -583,11 +622,10 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, (GlobalValue::LinkageTypes)Linkage, Name, Aliasee); GA->setVisibility((GlobalValue::VisibilityTypes)Visibility); - + // See if this value already exists in the symbol table. If so, it is either // a redefinition or a definition of a forward reference. - if (GlobalValue *Val = - cast_or_null(M->getValueSymbolTable().lookup(Name))) { + if (GlobalValue *Val = M->getNamedValue(Name)) { // See if this was a redefinition. If so, there is no entry in // ForwardRefVals. std::map >::iterator @@ -600,18 +638,18 @@ bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, if (Val->getType() != GA->getType()) return Error(NameLoc, "forward reference and definition of alias have different types"); - + // If they agree, just RAUW the old value with the alias and remove the // forward ref info. Val->replaceAllUsesWith(GA); Val->eraseFromParent(); ForwardRefVals.erase(I); } - + // Insert into the module, we know its name won't collide now. M->getAliasList().push_back(GA); assert(GA->getNameStr() == Name && "Should not be a name conflict!"); - + return false; } @@ -629,14 +667,14 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned AddrSpace; bool ThreadLocal, IsConstant; LocTy TyLoc; - + PATypeHolder Ty(Type::getVoidTy(Context)); if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) || ParseOptionalAddrSpace(AddrSpace) || ParseGlobalType(IsConstant) || ParseType(Ty, TyLoc)) return true; - + // If the linkage is specified and is external, then no initializer is // present. Constant *Init = 0; @@ -647,16 +685,18 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, return true; } - if (isa(Ty) || Ty == Type::getLabelTy(Context)) + if (isa(Ty) || Ty->isLabelTy()) return Error(TyLoc, "invalid type for global variable"); - + GlobalVariable *GV = 0; // See if the global was forward referenced, if so, use the global. if (!Name.empty()) { - if ((GV = M->getGlobalVariable(Name, true)) && - !ForwardRefVals.erase(Name)) - return Error(NameLoc, "redefinition of global '@" + Name + "'"); + if (GlobalValue *GVal = M->getNamedValue(Name)) { + if (!ForwardRefVals.erase(Name) || !isa(GVal)) + return Error(NameLoc, "redefinition of global '@" + Name + "'"); + GV = cast(GVal); + } } else { std::map >::iterator I = ForwardRefValIDs.find(NumberedVals.size()); @@ -667,20 +707,20 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, } if (GV == 0) { - GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0, + GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0, Name, 0, false, AddrSpace); } else { if (GV->getType()->getElementType() != Ty) return Error(TyLoc, "forward reference and definition of global have different types"); - + // Move the forward-reference to the correct spot in the module. M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV); } if (Name.empty()) NumberedVals.push_back(GV); - + // Set the parsed properties on the global. if (Init) GV->setInitializer(Init); @@ -688,11 +728,11 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, GV->setLinkage((GlobalValue::LinkageTypes)Linkage); GV->setVisibility((GlobalValue::VisibilityTypes)Visibility); GV->setThreadLocal(ThreadLocal); - + // Parse attributes on the global. while (Lex.getKind() == lltok::comma) { Lex.Lex(); - + if (Lex.getKind() == lltok::kw_section) { Lex.Lex(); GV->setSection(Lex.getStrVal()); @@ -706,7 +746,7 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, TokError("unknown global variable property!"); } } - + return false; } @@ -725,11 +765,11 @@ GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, Error(Loc, "global variable reference must have pointer type"); return 0; } - + // Look this name up in the normal function symbol table. GlobalValue *Val = cast_or_null(M->getValueSymbolTable().lookup(Name)); - + // If this is a forward reference for the value, see if we already created a // forward ref record. if (Val == 0) { @@ -738,7 +778,7 @@ GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, if (I != ForwardRefVals.end()) Val = I->second.first; } - + // If we have the value in the symbol table or fwd-ref table, return it. if (Val) { if (Val->getType() == Ty) return Val; @@ -746,7 +786,7 @@ GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, Val->getType()->getDescription() + "'"); return 0; } - + // Otherwise, create a new forward reference for this value and remember it. GlobalValue *FwdVal; if (const FunctionType *FT = dyn_cast(PTy->getElementType())) { @@ -755,13 +795,13 @@ GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, Error(Loc, "function may not return opaque type"); return 0; } - + FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M); } else { FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, GlobalValue::ExternalWeakLinkage, 0, Name); } - + ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); return FwdVal; } @@ -772,9 +812,9 @@ GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { Error(Loc, "global variable reference must have pointer type"); return 0; } - + GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; - + // If this is a forward reference for the value, see if we already created a // forward ref record. if (Val == 0) { @@ -783,7 +823,7 @@ GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { if (I != ForwardRefValIDs.end()) Val = I->second.first; } - + // If we have the value in the symbol table or fwd-ref table, return it. if (Val) { if (Val->getType() == Ty) return Val; @@ -791,7 +831,7 @@ GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { Val->getType()->getDescription() + "'"); return 0; } - + // Otherwise, create a new forward reference for this value and remember it. GlobalValue *FwdVal; if (const FunctionType *FT = dyn_cast(PTy->getElementType())) { @@ -805,7 +845,7 @@ GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, GlobalValue::ExternalWeakLinkage, 0, ""); } - + ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); return FwdVal; } @@ -858,7 +898,7 @@ bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) { return ParseToken(lltok::lparen, "expected '(' in address space") || ParseUInt32(AddrSpace) || ParseToken(lltok::rparen, "expected ')' in address space"); -} +} /// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind /// indicates what kind of attribute list this is: 0: function arg, 1: result, @@ -867,7 +907,7 @@ bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) { bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { Attrs = Attribute::None; LocTy AttrLoc = Lex.getLoc(); - + while (1) { switch (Lex.getKind()) { case lltok::kw_sext: @@ -888,10 +928,10 @@ bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { default: // End of attributes. if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly)) return Error(AttrLoc, "invalid use of function-only attribute"); - + if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly)) return Error(AttrLoc, "invalid use of parameter-only attribute"); - + return false; case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break; case lltok::kw_signext: Attrs |= Attribute::SExt; break; @@ -915,7 +955,7 @@ bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break; case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break; case lltok::kw_naked: Attrs |= Attribute::Naked; break; - + case lltok::kw_align: { unsigned Alignment; if (ParseOptionalAlignment(Alignment)) @@ -974,7 +1014,7 @@ bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) { /// ::= 'default' /// ::= 'hidden' /// ::= 'protected' -/// +/// bool LLParser::ParseOptionalVisibility(unsigned &Res) { switch (Lex.getKind()) { default: Res = GlobalValue::DefaultVisibility; return false; @@ -996,6 +1036,7 @@ bool LLParser::ParseOptionalVisibility(unsigned &Res) { /// ::= 'arm_apcscc' /// ::= 'arm_aapcscc' /// ::= 'arm_aapcs_vfpcc' +/// ::= 'msp430_intrcc' /// ::= 'cc' UINT /// bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { @@ -1009,6 +1050,7 @@ bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break; 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_cc: { unsigned ArbitraryCC; Lex.Lex(); @@ -1020,30 +1062,33 @@ bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { } break; } - + Lex.Lex(); return false; } -/// ParseOptionalDbgInfo -/// ::= /* empty */ -/// ::= 'dbg' !42 -bool LLParser::ParseOptionalDbgInfo() { +/// ParseInstructionMetadata +/// ::= !dbg !42 (',' !dbg !57)* +bool LLParser:: +ParseInstructionMetadata(SmallVectorImpl > &Result){ + do { + if (Lex.getKind() != lltok::MetadataVar) + return TokError("expected metadata after comma"); - if (!EatIfPresent(lltok::kw_dbg)) - return false; - if (Lex.getKind() != lltok::Metadata) - return TokError("Expected '!' here"); - Lex.Lex(); - MetadataBase *Node; - if (ParseMDNode(Node)) return true; - - Metadata &TheMetadata = M->getContext().getMetadata(); - unsigned MDDbgKind = TheMetadata.getMDKind("dbg"); - if (!MDDbgKind) - MDDbgKind = TheMetadata.RegisterMDKind("dbg"); - MDsOnInst.push_back(std::make_pair(MDDbgKind, cast(Node))); - + std::string Name = Lex.getStrVal(); + Lex.Lex(); + + MDNode *Node; + if (ParseToken(lltok::exclaim, "expected '!' here") || + ParseMDNodeID(Node)) + return true; + + unsigned MDK = M->getMDKindID(Name.c_str()); + Result.push_back(std::make_pair(MDK, Node)); + + // If this is the end of the list, we're done. + } while (EatIfPresent(lltok::comma)); return false; } @@ -1061,36 +1106,58 @@ bool LLParser::ParseOptionalAlignment(unsigned &Alignment) { return false; } -/// ParseOptionalInfo -/// ::= OptionalInfo (',' OptionalInfo)+ -bool LLParser::ParseOptionalInfo(unsigned &Alignment) { - - // FIXME: Handle customized metadata info attached with an instruction. - do { - if (Lex.getKind() == lltok::kw_dbg) { - if (ParseOptionalDbgInfo()) return true; - } else if (Lex.getKind() == lltok::kw_align) { +/// ParseOptionalCommaAlign +/// ::= +/// ::= ',' align 4 +/// +/// This returns with AteExtraComma set to true if it ate an excess comma at the +/// end. +bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment, + bool &AteExtraComma) { + AteExtraComma = false; + while (EatIfPresent(lltok::comma)) { + // Metadata at the end is an early exit. + if (Lex.getKind() == lltok::MetadataVar) { + AteExtraComma = true; + return false; + } + + if (Lex.getKind() == lltok::kw_align) { if (ParseOptionalAlignment(Alignment)) return true; } else return true; - } while (EatIfPresent(lltok::comma)); - + } + return false; } +/// ParseIndexList - This parses the index list for an insert/extractvalue +/// instruction. This sets AteExtraComma in the case where we eat an extra +/// comma at the end of the line and find that it is followed by metadata. +/// Clients that don't allow metadata can call the version of this function that +/// only takes one argument. +/// /// ParseIndexList /// ::= (',' uint32)+ -bool LLParser::ParseIndexList(SmallVectorImpl &Indices) { +/// +bool LLParser::ParseIndexList(SmallVectorImpl &Indices, + bool &AteExtraComma) { + AteExtraComma = false; + if (Lex.getKind() != lltok::comma) return TokError("expected ',' as start of index list"); - + while (EatIfPresent(lltok::comma)) { + if (Lex.getKind() == lltok::MetadataVar) { + AteExtraComma = true; + return false; + } unsigned Idx; if (ParseUInt32(Idx)) return true; Indices.push_back(Idx); } - + return false; } @@ -1102,14 +1169,14 @@ bool LLParser::ParseIndexList(SmallVectorImpl &Indices) { bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) { LocTy TypeLoc = Lex.getLoc(); if (ParseTypeRec(Result)) return true; - + // Verify no unresolved uprefs. if (!UpRefs.empty()) return Error(UpRefs.back().Loc, "invalid unresolved type up reference"); - - if (!AllowVoid && Result.get() == Type::getVoidTy(Context)) + + if (!AllowVoid && Result.get()->isVoidTy()) return Error(TypeLoc, "void type only allowed for function results"); - + return false; } @@ -1124,45 +1191,45 @@ PATypeHolder LLParser::HandleUpRefs(const Type *ty) { // If Ty isn't abstract, or if there are no up-references in it, then there is // nothing to resolve here. if (!ty->isAbstract() || UpRefs.empty()) return ty; - + PATypeHolder Ty(ty); #if 0 - errs() << "Type '" << Ty->getDescription() + dbgs() << "Type '" << Ty->getDescription() << "' newly formed. Resolving upreferences.\n" << UpRefs.size() << " upreferences active!\n"; #endif - + // If we find any resolvable upreferences (i.e., those whose NestingLevel goes // to zero), we resolve them all together before we resolve them to Ty. At // the end of the loop, if there is anything to resolve to Ty, it will be in // this variable. OpaqueType *TypeToResolve = 0; - + for (unsigned i = 0; i != UpRefs.size(); ++i) { // Determine if 'Ty' directly contains this up-references 'LastContainedTy'. bool ContainsType = std::find(Ty->subtype_begin(), Ty->subtype_end(), UpRefs[i].LastContainedTy) != Ty->subtype_end(); - + #if 0 - errs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + dbgs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " << UpRefs[i].LastContainedTy->getDescription() << ") = " << (ContainsType ? "true" : "false") << " level=" << UpRefs[i].NestingLevel << "\n"; #endif if (!ContainsType) continue; - + // Decrement level of upreference unsigned Level = --UpRefs[i].NestingLevel; UpRefs[i].LastContainedTy = Ty; - + // If the Up-reference has a non-zero level, it shouldn't be resolved yet. if (Level != 0) continue; - + #if 0 - errs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n"; + dbgs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n"; #endif if (!TypeToResolve) TypeToResolve = UpRefs[i].UpRefTy; @@ -1171,10 +1238,10 @@ PATypeHolder LLParser::HandleUpRefs(const Type *ty) { UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list. --i; // Do not skip the next element. } - + if (TypeToResolve) TypeToResolve->refineAbstractTypeTo(Ty); - + return Ty; } @@ -1188,7 +1255,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) { case lltok::Type: // TypeRec ::= 'float' | 'void' (etc) Result = Lex.getTyVal(); - Lex.Lex(); + Lex.Lex(); break; case lltok::kw_opaque: // TypeRec ::= 'opaque' @@ -1230,7 +1297,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) { } Lex.Lex(); break; - + case lltok::LocalVarID: // TypeRec ::= %4 if (Lex.getUIntVal() < NumberedTypes.size()) @@ -1260,18 +1327,18 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) { break; } } - - // Parse the type suffixes. + + // Parse the type suffixes. while (1) { switch (Lex.getKind()) { // End of type. - default: return false; + default: return false; // TypeRec ::= TypeRec '*' case lltok::star: - if (Result.get() == Type::getLabelTy(Context)) + if (Result.get()->isLabelTy()) return TokError("basic block pointers are invalid"); - if (Result.get() == Type::getVoidTy(Context)) + if (Result.get()->isVoidTy()) return TokError("pointers to void are invalid; use i8* instead"); if (!PointerType::isValidElementType(Result.get())) return TokError("pointer to this type is invalid"); @@ -1281,9 +1348,9 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) { // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*' case lltok::kw_addrspace: { - if (Result.get() == Type::getLabelTy(Context)) + if (Result.get()->isLabelTy()) return TokError("basic block pointers are invalid"); - if (Result.get() == Type::getVoidTy(Context)) + if (Result.get()->isVoidTy()) return TokError("pointers to void are invalid; use i8* instead"); if (!PointerType::isValidElementType(Result.get())) return TokError("pointer to this type is invalid"); @@ -1295,7 +1362,7 @@ bool LLParser::ParseTypeRec(PATypeHolder &Result) { Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace)); break; } - + /// Types '(' ArgTypeListI ')' OptFuncAttrs case lltok::lparen: if (ParseFunctionType(Result)) @@ -1314,23 +1381,27 @@ bool LLParser::ParseParameterList(SmallVectorImpl &ArgList, PerFunctionState &PFS) { if (ParseToken(lltok::lparen, "expected '(' in call")) return true; - + while (Lex.getKind() != lltok::rparen) { // If this isn't the first argument, we need a comma. if (!ArgList.empty() && ParseToken(lltok::comma, "expected ',' in argument list")) return true; - + // Parse the argument. LocTy ArgLoc; PATypeHolder ArgTy(Type::getVoidTy(Context)); - unsigned ArgAttrs1, ArgAttrs2; + unsigned ArgAttrs1 = Attribute::None; + unsigned ArgAttrs2 = Attribute::None; Value *V; - if (ParseType(ArgTy, ArgLoc) || - ParseOptionalAttrs(ArgAttrs1, 0) || + if (ParseType(ArgTy, ArgLoc)) + return true; + + // Otherwise, handle normal operands. + if (ParseOptionalAttrs(ArgAttrs1, 0) || ParseValue(ArgTy, V, PFS) || - // FIXME: Should not allow attributes after the argument, remove this in - // LLVM 3.0. + // FIXME: Should not allow attributes after the argument, remove this + // in LLVM 3.0. ParseOptionalAttrs(ArgAttrs2, 3)) return true; ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2)); @@ -1356,7 +1427,7 @@ bool LLParser::ParseArgumentList(std::vector &ArgList, isVarArg = false; assert(Lex.getKind() == lltok::lparen); Lex.Lex(); // eat the (. - + if (Lex.getKind() == lltok::rparen) { // empty } else if (Lex.getKind() == lltok::dotdotdot) { @@ -1367,16 +1438,16 @@ bool LLParser::ParseArgumentList(std::vector &ArgList, PATypeHolder ArgTy(Type::getVoidTy(Context)); unsigned Attrs; std::string Name; - + // If we're parsing a type, use ParseTypeRec, because we allow recursive // types (such as a function returning a pointer to itself). If parsing a // function prototype, we require fully resolved types. if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || ParseOptionalAttrs(Attrs, 0)) return true; - - if (ArgTy == Type::getVoidTy(Context)) + + if (ArgTy->isVoidTy()) return Error(TypeLoc, "argument can not have void type"); - + if (Lex.getKind() == lltok::LocalVar || Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 Name = Lex.getStrVal(); @@ -1385,22 +1456,22 @@ bool LLParser::ParseArgumentList(std::vector &ArgList, if (!FunctionType::isValidArgumentType(ArgTy)) return Error(TypeLoc, "invalid type for function argument"); - + ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); - + while (EatIfPresent(lltok::comma)) { // Handle ... at end of arg list. if (EatIfPresent(lltok::dotdotdot)) { isVarArg = true; break; } - + // Otherwise must be an argument type. TypeLoc = Lex.getLoc(); if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || ParseOptionalAttrs(Attrs, 0)) return true; - if (ArgTy == Type::getVoidTy(Context)) + if (ArgTy->isVoidTy()) return Error(TypeLoc, "argument can not have void type"); if (Lex.getKind() == lltok::LocalVar || @@ -1413,14 +1484,14 @@ bool LLParser::ParseArgumentList(std::vector &ArgList, if (!ArgTy->isFirstClassType() && !isa(ArgTy)) return Error(TypeLoc, "invalid type for function argument"); - + ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); } } - + return ParseToken(lltok::rparen, "expected ')' at end of argument list"); } - + /// ParseFunctionType /// ::= Type ArgumentList OptionalAttrs bool LLParser::ParseFunctionType(PATypeHolder &Result) { @@ -1428,7 +1499,7 @@ bool LLParser::ParseFunctionType(PATypeHolder &Result) { if (!FunctionType::isValidReturnType(Result)) return TokError("invalid function return type"); - + std::vector ArgList; bool isVarArg; unsigned Attrs; @@ -1437,7 +1508,7 @@ bool LLParser::ParseFunctionType(PATypeHolder &Result) { // FIXME: Remove in LLVM 3.0 ParseOptionalAttrs(Attrs, 2)) return true; - + // Reject names on the arguments lists. for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { if (!ArgList[i].Name.empty()) @@ -1448,11 +1519,11 @@ bool LLParser::ParseFunctionType(PATypeHolder &Result) { // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0 } } - + std::vector ArgListTy; for (unsigned i = 0, e = ArgList.size(); i != e; ++i) ArgListTy.push_back(ArgList[i].Type); - + Result = HandleUpRefs(FunctionType::get(Result.get(), ArgListTy, isVarArg)); return false; @@ -1467,7 +1538,7 @@ bool LLParser::ParseFunctionType(PATypeHolder &Result) { bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { assert(Lex.getKind() == lltok::lbrace); Lex.Lex(); // Consume the '{' - + if (EatIfPresent(lltok::rbrace)) { Result = StructType::get(Context, Packed); return false; @@ -1477,27 +1548,27 @@ bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { LocTy EltTyLoc = Lex.getLoc(); if (ParseTypeRec(Result)) return true; ParamsList.push_back(Result); - - if (Result == Type::getVoidTy(Context)) + + if (Result->isVoidTy()) return Error(EltTyLoc, "struct element can not have void type"); if (!StructType::isValidElementType(Result)) return Error(EltTyLoc, "invalid element type for struct"); - + while (EatIfPresent(lltok::comma)) { EltTyLoc = Lex.getLoc(); if (ParseTypeRec(Result)) return true; - - if (Result == Type::getVoidTy(Context)) + + if (Result->isVoidTy()) return Error(EltTyLoc, "struct element can not have void type"); if (!StructType::isValidElementType(Result)) return Error(EltTyLoc, "invalid element type for struct"); - + ParamsList.push_back(Result); } - + if (ParseToken(lltok::rbrace, "expected '}' at end of struct")) return true; - + std::vector ParamsListTy; for (unsigned i = 0, e = ParamsList.size(); i != e; ++i) ParamsListTy.push_back(ParamsList[i].get()); @@ -1507,32 +1578,32 @@ bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { /// ParseArrayVectorType - Parse an array or vector type, assuming the first /// token has already been consumed. -/// TypeRec +/// TypeRec /// ::= '[' APSINTVAL 'x' Types ']' /// ::= '<' APSINTVAL 'x' Types '>' bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) { if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() || Lex.getAPSIntVal().getBitWidth() > 64) return TokError("expected number in address space"); - + LocTy SizeLoc = Lex.getLoc(); uint64_t Size = Lex.getAPSIntVal().getZExtValue(); Lex.Lex(); - + if (ParseToken(lltok::kw_x, "expected 'x' after element count")) return true; LocTy TypeLoc = Lex.getLoc(); PATypeHolder EltTy(Type::getVoidTy(Context)); if (ParseTypeRec(EltTy)) return true; - - if (EltTy == Type::getVoidTy(Context)) + + if (EltTy->isVoidTy()) return Error(TypeLoc, "array and vector element type cannot be void"); if (ParseToken(isVector ? lltok::greater : lltok::rsquare, "expected end of sequential type")) return true; - + if (isVector) { if (Size == 0) return Error(SizeLoc, "zero element vector is illegal"); @@ -1553,8 +1624,9 @@ bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) { // Function Semantic Analysis. //===----------------------------------------------------------------------===// -LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f) - : P(p), F(f) { +LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f, + int functionNumber) + : P(p), F(f), FunctionNumber(functionNumber) { // Insert unnamed arguments into the NumberedVals list. for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); @@ -1573,7 +1645,7 @@ LLParser::PerFunctionState::~PerFunctionState() { delete I->second.first; I->second.first = 0; } - + for (std::map >::iterator I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I) if (!isa(I->second.first)) { @@ -1584,7 +1656,29 @@ LLParser::PerFunctionState::~PerFunctionState() { } } -bool LLParser::PerFunctionState::VerifyFunctionComplete() { +bool LLParser::PerFunctionState::FinishFunction() { + // Check to see if someone took the address of labels in this block. + if (!P.ForwardRefBlockAddresses.empty()) { + ValID FunctionID; + if (!F.getName().empty()) { + FunctionID.Kind = ValID::t_GlobalName; + FunctionID.StrVal = F.getName(); + } else { + FunctionID.Kind = ValID::t_GlobalID; + FunctionID.UIntVal = FunctionNumber; + } + + std::map > >::iterator + FRBAI = P.ForwardRefBlockAddresses.find(FunctionID); + if (FRBAI != P.ForwardRefBlockAddresses.end()) { + // Resolve all these references. + if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this)) + return true; + + P.ForwardRefBlockAddresses.erase(FRBAI); + } + } + if (!ForwardRefVals.empty()) return P.Error(ForwardRefVals.begin()->second.second, "use of undefined value '%" + ForwardRefVals.begin()->first + @@ -1604,7 +1698,7 @@ Value *LLParser::PerFunctionState::GetVal(const std::string &Name, const Type *Ty, LocTy Loc) { // Look this name up in the normal function symbol table. Value *Val = F.getValueSymbolTable().lookup(Name); - + // If this is a forward reference for the value, see if we already created a // forward ref record. if (Val == 0) { @@ -1613,32 +1707,31 @@ Value *LLParser::PerFunctionState::GetVal(const std::string &Name, if (I != ForwardRefVals.end()) Val = I->second.first; } - + // If we have the value in the symbol table or fwd-ref table, return it. if (Val) { if (Val->getType() == Ty) return Val; - if (Ty == Type::getLabelTy(F.getContext())) + if (Ty->isLabelTy()) P.Error(Loc, "'%" + Name + "' is not a basic block"); else P.Error(Loc, "'%" + Name + "' defined with type '" + Val->getType()->getDescription() + "'"); return 0; } - + // Don't make placeholders with invalid type. - if (!Ty->isFirstClassType() && !isa(Ty) && - Ty != Type::getLabelTy(F.getContext())) { + if (!Ty->isFirstClassType() && !isa(Ty) && !Ty->isLabelTy()) { P.Error(Loc, "invalid use of a non-first-class type"); return 0; } - + // Otherwise, create a new forward reference for this value and remember it. Value *FwdVal; - if (Ty == Type::getLabelTy(F.getContext())) + if (Ty->isLabelTy()) FwdVal = BasicBlock::Create(F.getContext(), Name, &F); else FwdVal = new Argument(Ty, Name); - + ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); return FwdVal; } @@ -1647,7 +1740,7 @@ Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty, LocTy Loc) { // Look this name up in the normal function symbol table. Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; - + // If this is a forward reference for the value, see if we already created a // forward ref record. if (Val == 0) { @@ -1656,31 +1749,30 @@ Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty, if (I != ForwardRefValIDs.end()) Val = I->second.first; } - + // If we have the value in the symbol table or fwd-ref table, return it. if (Val) { if (Val->getType() == Ty) return Val; - if (Ty == Type::getLabelTy(F.getContext())) + if (Ty->isLabelTy()) P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block"); else P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" + Val->getType()->getDescription() + "'"); return 0; } - - if (!Ty->isFirstClassType() && !isa(Ty) && - Ty != Type::getLabelTy(F.getContext())) { + + if (!Ty->isFirstClassType() && !isa(Ty) && !Ty->isLabelTy()) { P.Error(Loc, "invalid use of a non-first-class type"); return 0; } - + // Otherwise, create a new forward reference for this value and remember it. Value *FwdVal; - if (Ty == Type::getLabelTy(F.getContext())) + if (Ty->isLabelTy()) FwdVal = BasicBlock::Create(F.getContext(), "", &F); else FwdVal = new Argument(Ty); - + ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); return FwdVal; } @@ -1691,28 +1783,28 @@ bool LLParser::PerFunctionState::SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc, Instruction *Inst) { // If this instruction has void type, it cannot have a name or ID specified. - if (Inst->getType() == Type::getVoidTy(F.getContext())) { + if (Inst->getType()->isVoidTy()) { if (NameID != -1 || !NameStr.empty()) return P.Error(NameLoc, "instructions returning void cannot have a name"); return false; } - + // If this was a numbered instruction, verify that the instruction is the // expected value and resolve any forward references. if (NameStr.empty()) { // If neither a name nor an ID was specified, just use the next ID. if (NameID == -1) NameID = NumberedVals.size(); - + if (unsigned(NameID) != NumberedVals.size()) return P.Error(NameLoc, "instruction expected to be numbered '%" + utostr(NumberedVals.size()) + "'"); - + std::map >::iterator FI = ForwardRefValIDs.find(NameID); if (FI != ForwardRefValIDs.end()) { if (FI->second.first->getType() != Inst->getType()) - return P.Error(NameLoc, "instruction forward referenced with type '" + + return P.Error(NameLoc, "instruction forward referenced with type '" + FI->second.first->getType()->getDescription() + "'"); FI->second.first->replaceAllUsesWith(Inst); delete FI->second.first; @@ -1728,18 +1820,18 @@ bool LLParser::PerFunctionState::SetInstName(int NameID, FI = ForwardRefVals.find(NameStr); if (FI != ForwardRefVals.end()) { if (FI->second.first->getType() != Inst->getType()) - return P.Error(NameLoc, "instruction forward referenced with type '" + + return P.Error(NameLoc, "instruction forward referenced with type '" + FI->second.first->getType()->getDescription() + "'"); FI->second.first->replaceAllUsesWith(Inst); delete FI->second.first; ForwardRefVals.erase(FI); } - + // Set the name on the instruction. Inst->setName(NameStr); - + if (Inst->getNameStr() != NameStr) - return P.Error(NameLoc, "multiple definition of local value named '" + + return P.Error(NameLoc, "multiple definition of local value named '" + NameStr + "'"); return false; } @@ -1768,11 +1860,11 @@ BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, else BB = GetBB(Name, Loc); if (BB == 0) return 0; // Already diagnosed error. - + // Move the block to the end of the function. Forward ref'd blocks are // inserted wherever they happen to be referenced. F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB); - + // Remove the block from forward ref sets. if (Name.empty()) { ForwardRefValIDs.erase(NumberedVals.size()); @@ -1781,7 +1873,7 @@ BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, // BB forward references are already in the function symbol table. ForwardRefVals.erase(Name); } - + return BB; } @@ -1792,8 +1884,10 @@ BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, /// ParseValID - Parse an abstract value that doesn't necessarily have a /// type implied. For example, if we parse "4" we don't know what integer type /// it has. The value will later be combined with its type and checked for -/// sanity. -bool LLParser::ParseValID(ValID &ID) { +/// sanity. PFS is used to convert function-local operands of metadata (since +/// metadata operands are not just parsed here but also converted to values). +/// PFS can be null when we are not parsing metadata values inside a function. +bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) { ID.Loc = Lex.getLoc(); switch (Lex.getKind()) { default: return TokError("expected value token"); @@ -1814,32 +1908,35 @@ bool LLParser::ParseValID(ValID &ID) { ID.StrVal = Lex.getStrVal(); ID.Kind = ValID::t_LocalName; break; - case lltok::Metadata: { // !{...} MDNode, !"foo" MDString - ID.Kind = ValID::t_Metadata; + case lltok::exclaim: // !{...} MDNode, !"foo" MDString Lex.Lex(); - if (Lex.getKind() == lltok::lbrace) { + + if (EatIfPresent(lltok::lbrace)) { SmallVector Elts; - if (ParseMDNodeVector(Elts) || + if (ParseMDNodeVector(Elts, PFS) || ParseToken(lltok::rbrace, "expected end of metadata node")) return true; - ID.MetadataVal = MDNode::get(Context, Elts.data(), Elts.size()); + ID.MDNodeVal = MDNode::get(Context, Elts.data(), Elts.size()); + ID.Kind = ValID::t_MDNode; return false; } // Standalone metadata reference // !{ ..., !42, ... } - if (!ParseMDNode(ID.MetadataVal)) + if (Lex.getKind() == lltok::APSInt) { + if (ParseMDNodeID(ID.MDNodeVal)) return true; + ID.Kind = ValID::t_MDNode; return false; - + } + // MDString: // ::= '!' STRINGCONSTANT - if (ParseMDString(ID.MetadataVal)) return true; - ID.Kind = ValID::t_Metadata; + if (ParseMDString(ID.MDStringVal)) return true; + ID.Kind = ValID::t_MDString; return false; - } case lltok::APSInt: - ID.APSIntVal = Lex.getAPSIntVal(); + ID.APSIntVal = Lex.getAPSIntVal(); ID.Kind = ValID::t_APSInt; break; case lltok::APFloat: @@ -1857,7 +1954,7 @@ bool LLParser::ParseValID(ValID &ID) { case lltok::kw_null: ID.Kind = ValID::t_Null; break; case lltok::kw_undef: ID.Kind = ValID::t_Undef; break; case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break; - + case lltok::lbrace: { // ValID ::= '{' ConstVector '}' Lex.Lex(); @@ -1865,7 +1962,7 @@ bool LLParser::ParseValID(ValID &ID) { if (ParseGlobalValueVector(Elts) || ParseToken(lltok::rbrace, "expected end of struct constant")) return true; - + ID.ConstantVal = ConstantStruct::get(Context, Elts.data(), Elts.size(), false); ID.Kind = ValID::t_Constant; @@ -1876,7 +1973,7 @@ bool LLParser::ParseValID(ValID &ID) { // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct. Lex.Lex(); bool isPackedStruct = EatIfPresent(lltok::lbrace); - + SmallVector Elts; LocTy FirstEltLoc = Lex.getLoc(); if (ParseGlobalValueVector(Elts) || @@ -1884,14 +1981,14 @@ bool LLParser::ParseValID(ValID &ID) { ParseToken(lltok::rbrace, "expected end of packed struct")) || ParseToken(lltok::greater, "expected end of constant")) return true; - + if (isPackedStruct) { ID.ConstantVal = ConstantStruct::get(Context, Elts.data(), Elts.size(), true); ID.Kind = ValID::t_Constant; return false; } - + if (Elts.empty()) return Error(ID.Loc, "constant vector must not be empty"); @@ -1899,14 +1996,14 @@ bool LLParser::ParseValID(ValID &ID) { !Elts[0]->getType()->isFloatingPoint()) return Error(FirstEltLoc, "vector elements must have integer or floating point type"); - + // Verify that all the vector elements have the same type. for (unsigned i = 1, e = Elts.size(); i != e; ++i) if (Elts[i]->getType() != Elts[0]->getType()) return Error(FirstEltLoc, "vector element #" + utostr(i) + " is not of type '" + Elts[0]->getType()->getDescription()); - + ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size()); ID.Kind = ValID::t_Constant; return false; @@ -1926,13 +2023,13 @@ bool LLParser::ParseValID(ValID &ID) { ID.Kind = ValID::t_EmptyArray; return false; } - + if (!Elts[0]->getType()->isFirstClassType()) - return Error(FirstEltLoc, "invalid array element type: " + + return Error(FirstEltLoc, "invalid array element type: " + Elts[0]->getType()->getDescription()); - + ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size()); - + // Verify all elements are correct type! for (unsigned i = 0, e = Elts.size(); i != e; ++i) { if (Elts[i]->getType() != Elts[0]->getType()) @@ -1940,7 +2037,7 @@ bool LLParser::ParseValID(ValID &ID) { "array element #" + utostr(i) + " is not of type '" +Elts[0]->getType()->getDescription()); } - + ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size()); ID.Kind = ValID::t_Constant; return false; @@ -1953,19 +2050,49 @@ bool LLParser::ParseValID(ValID &ID) { return false; case lltok::kw_asm: { - // ValID ::= 'asm' SideEffect? STRINGCONSTANT ',' STRINGCONSTANT - bool HasSideEffect; + // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT + bool HasSideEffect, AlignStack; Lex.Lex(); if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || + ParseOptionalToken(lltok::kw_alignstack, AlignStack) || ParseStringConstant(ID.StrVal) || ParseToken(lltok::comma, "expected comma in inline asm expression") || ParseToken(lltok::StringConstant, "expected constraint string")) return true; ID.StrVal2 = Lex.getStrVal(); - ID.UIntVal = HasSideEffect; + ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1); ID.Kind = ValID::t_InlineAsm; return false; } + + case lltok::kw_blockaddress: { + // ValID ::= 'blockaddress' '(' @foo ',' %bar ')' + Lex.Lex(); + + ValID Fn, Label; + LocTy FnLoc, LabelLoc; + + if (ParseToken(lltok::lparen, "expected '(' in block address expression") || + ParseValID(Fn) || + ParseToken(lltok::comma, "expected comma in block address expression")|| + ParseValID(Label) || + ParseToken(lltok::rparen, "expected ')' in block address expression")) + return true; + + if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) + return Error(Fn.Loc, "expected function name in blockaddress"); + if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName) + return Error(Label.Loc, "expected basic block name in blockaddress"); + + // Make a global variable as a placeholder for this reference. + GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), + false, GlobalValue::InternalLinkage, + 0, ""); + ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef)); + ID.ConstantVal = FwdRef; + ID.Kind = ValID::t_Constant; + return false; + } case lltok::kw_trunc: case lltok::kw_zext: @@ -1976,9 +2103,9 @@ bool LLParser::ParseValID(ValID &ID) { case lltok::kw_uitofp: case lltok::kw_sitofp: case lltok::kw_fptoui: - case lltok::kw_fptosi: + case lltok::kw_fptosi: case lltok::kw_inttoptr: - case lltok::kw_ptrtoint: { + case lltok::kw_ptrtoint: { unsigned Opc = Lex.getUIntVal(); PATypeHolder DestTy(Type::getVoidTy(Context)); Constant *SrcVal; @@ -1993,7 +2120,7 @@ bool LLParser::ParseValID(ValID &ID) { return Error(ID.Loc, "invalid cast opcode for cast from '" + SrcVal->getType()->getDescription() + "' to '" + DestTy->getDescription() + "'"); - ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, + ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, SrcVal, DestTy); ID.Kind = ValID::t_Constant; return false; @@ -2007,6 +2134,7 @@ bool LLParser::ParseValID(ValID &ID) { ParseIndexList(Indices) || ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) return true; + if (!isa(Val->getType()) && !isa(Val->getType())) return Error(ID.Loc, "extractvalue operand must be array or struct"); if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), @@ -2050,12 +2178,12 @@ bool LLParser::ParseValID(ValID &ID) { ParseGlobalTypeAndValue(Val1) || ParseToken(lltok::rparen, "expected ')' in compare constantexpr")) return true; - + if (Val0->getType() != Val1->getType()) return Error(ID.Loc, "compare operands must have the same type"); - + CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal; - + if (Opc == Instruction::FCmp) { if (!Val0->getType()->isFPOrFPVector()) return Error(ID.Loc, "fcmp requires floating point operands"); @@ -2070,7 +2198,7 @@ bool LLParser::ParseValID(ValID &ID) { ID.Kind = ValID::t_Constant; return false; } - + // Binary Operators. case lltok::kw_add: case lltok::kw_fadd: @@ -2133,7 +2261,7 @@ bool LLParser::ParseValID(ValID &ID) { ID.Kind = ValID::t_Constant; return false; } - + // Logical Operations case lltok::kw_shl: case lltok::kw_lshr: @@ -2158,8 +2286,8 @@ bool LLParser::ParseValID(ValID &ID) { ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1); ID.Kind = ValID::t_Constant; return false; - } - + } + case lltok::kw_getelementptr: case lltok::kw_shufflevector: case lltok::kw_insertelement: @@ -2175,11 +2303,11 @@ bool LLParser::ParseValID(ValID &ID) { ParseGlobalValueVector(Elts) || ParseToken(lltok::rparen, "expected ')' in constantexpr")) return true; - + if (Opc == Instruction::GetElementPtr) { if (Elts.size() == 0 || !isa(Elts[0]->getType())) return Error(ID.Loc, "getelementptr requires pointer operand"); - + if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), (Value**)(Elts.data() + 1), Elts.size() - 1)) @@ -2219,40 +2347,96 @@ bool LLParser::ParseValID(ValID &ID) { ID.ConstantVal = ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]); } - + ID.Kind = ValID::t_Constant; return false; } } - + Lex.Lex(); return false; } /// ParseGlobalValue - Parse a global value with the specified type. -bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) { - V = 0; +bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&C) { + C = 0; ValID ID; - return ParseValID(ID) || - ConvertGlobalValIDToValue(Ty, ID, V); + Value *V = NULL; + bool Parsed = ParseValID(ID) || + ConvertValIDToValue(Ty, ID, V, NULL); + if (V && !(C = dyn_cast(V))) + return Error(ID.Loc, "global values must be constants"); + return Parsed; +} + +bool LLParser::ParseGlobalTypeAndValue(Constant *&V) { + PATypeHolder Type(Type::getVoidTy(Context)); + return ParseType(Type) || + ParseGlobalValue(Type, V); } -/// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved -/// constant. -bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, - Constant *&V) { +/// ParseGlobalValueVector +/// ::= /*empty*/ +/// ::= TypeAndValue (',' TypeAndValue)* +bool LLParser::ParseGlobalValueVector(SmallVectorImpl &Elts) { + // Empty list. + if (Lex.getKind() == lltok::rbrace || + Lex.getKind() == lltok::rsquare || + Lex.getKind() == lltok::greater || + Lex.getKind() == lltok::rparen) + return false; + + Constant *C; + if (ParseGlobalTypeAndValue(C)) return true; + Elts.push_back(C); + + while (EatIfPresent(lltok::comma)) { + if (ParseGlobalTypeAndValue(C)) return true; + Elts.push_back(C); + } + + return false; +} + + +//===----------------------------------------------------------------------===// +// Function Parsing. +//===----------------------------------------------------------------------===// + +bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, + PerFunctionState *PFS) { if (isa(Ty)) return Error(ID.Loc, "functions are not values, refer to them as pointers"); - + switch (ID.Kind) { - default: llvm_unreachable("Unknown ValID!"); - case ValID::t_Metadata: - return Error(ID.Loc, "invalid use of metadata"); + default: llvm_unreachable("Unknown ValID!"); case ValID::t_LocalID: + if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); + V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc); + return (V == 0); case ValID::t_LocalName: - return Error(ID.Loc, "invalid use of function-local name"); - case ValID::t_InlineAsm: - return Error(ID.Loc, "inline asm can only be an operand of call/invoke"); + if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); + V = PFS->GetVal(ID.StrVal, Ty, ID.Loc); + return (V == 0); + case ValID::t_InlineAsm: { + const PointerType *PTy = dyn_cast(Ty); + const FunctionType *FTy = + PTy ? dyn_cast(PTy->getElementType()) : 0; + if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) + return Error(ID.Loc, "invalid type for inline asm constraint string"); + V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1); + return false; + } + case ValID::t_MDNode: + if (!Ty->isMetadataTy()) + return Error(ID.Loc, "metadata value must have metadata type"); + V = ID.MDNodeVal; + return false; + case ValID::t_MDString: + if (!Ty->isMetadataTy()) + return Error(ID.Loc, "metadata value must have metadata type"); + V = ID.MDStringVal; + return false; case ValID::t_GlobalName: V = GetGlobalVal(ID.StrVal, Ty, ID.Loc); return V == 0; @@ -2269,21 +2453,21 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, if (!Ty->isFloatingPoint() || !ConstantFP::isValueValidForType(Ty, ID.APFloatVal)) return Error(ID.Loc, "floating point constant invalid for type"); - + // The lexer has no type info, so builds all float and double FP constants // as double. Fix this here. Long double does not need this. if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble && - Ty == Type::getFloatTy(Context)) { + Ty->isFloatTy()) { bool Ignored; ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &Ignored); } V = ConstantFP::get(Context, ID.APFloatVal); - + if (V->getType() != Ty) return Error(ID.Loc, "floating point constant does not have type '" + Ty->getDescription() + "'"); - + return false; case ValID::t_Null: if (!isa(Ty)) @@ -2292,7 +2476,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, return false; case ValID::t_Undef: // FIXME: LabelTy should not be a first-class type. - if ((!Ty->isFirstClassType() || Ty == Type::getLabelTy(Context)) && + if ((!Ty->isFirstClassType() || Ty->isLabelTy()) && !isa(Ty)) return Error(ID.Loc, "invalid type for undef constant"); V = UndefValue::get(Ty); @@ -2304,7 +2488,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, return false; case ValID::t_Zero: // FIXME: LabelTy should not be a first-class type. - if (!Ty->isFirstClassType() || Ty == Type::getLabelTy(Context)) + if (!Ty->isFirstClassType() || Ty->isLabelTy()) return Error(ID.Loc, "invalid type for null constant"); V = Constant::getNullValue(Ty); return false; @@ -2315,72 +2499,12 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, return false; } } - -bool LLParser::ParseGlobalTypeAndValue(Constant *&V) { - PATypeHolder Type(Type::getVoidTy(Context)); - return ParseType(Type) || - ParseGlobalValue(Type, V); -} - -/// ParseGlobalValueVector -/// ::= /*empty*/ -/// ::= TypeAndValue (',' TypeAndValue)* -bool LLParser::ParseGlobalValueVector(SmallVectorImpl &Elts) { - // Empty list. - if (Lex.getKind() == lltok::rbrace || - Lex.getKind() == lltok::rsquare || - Lex.getKind() == lltok::greater || - Lex.getKind() == lltok::rparen) - return false; - - Constant *C; - if (ParseGlobalTypeAndValue(C)) return true; - Elts.push_back(C); - - while (EatIfPresent(lltok::comma)) { - if (ParseGlobalTypeAndValue(C)) return true; - Elts.push_back(C); - } - - return false; -} - - -//===----------------------------------------------------------------------===// -// Function Parsing. -//===----------------------------------------------------------------------===// - -bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, - PerFunctionState &PFS) { - if (ID.Kind == ValID::t_LocalID) - V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc); - else if (ID.Kind == ValID::t_LocalName) - V = PFS.GetVal(ID.StrVal, Ty, ID.Loc); - else if (ID.Kind == ValID::t_InlineAsm) { - const PointerType *PTy = dyn_cast(Ty); - const FunctionType *FTy = - PTy ? dyn_cast(PTy->getElementType()) : 0; - if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) - return Error(ID.Loc, "invalid type for inline asm constraint string"); - V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal); - return false; - } else if (ID.Kind == ValID::t_Metadata) { - V = ID.MetadataVal; - } else { - Constant *C; - if (ConvertGlobalValIDToValue(Ty, ID, C)) return true; - V = C; - return false; - } - - return V == 0; -} bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) { V = 0; ValID ID; - return ParseValID(ID) || - ConvertValIDToValue(Ty, ID, V, PFS); + return ParseValID(ID, &PFS) || + ConvertValIDToValue(Ty, ID, V, &PFS); } bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) { @@ -2389,6 +2513,18 @@ bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) { ParseValue(T, V, PFS); } +bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, + PerFunctionState &PFS) { + Value *V; + Loc = Lex.getLoc(); + if (ParseTypeAndValue(V, PFS)) return true; + if (!isa(V)) + return Error(Loc, "expected a basic block"); + BB = cast(V); + return false; +} + + /// FunctionHeader /// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs /// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection @@ -2397,7 +2533,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { // Parse the linkage. LocTy LinkageLoc = Lex.getLoc(); unsigned Linkage; - + unsigned Visibility, RetAttrs; CallingConv::ID CC; PATypeHolder RetType(Type::getVoidTy(Context)); @@ -2431,15 +2567,14 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { return Error(LinkageLoc, "invalid linkage for function declaration"); break; case GlobalValue::AppendingLinkage: - case GlobalValue::GhostLinkage: case GlobalValue::CommonLinkage: return Error(LinkageLoc, "invalid function linkage type"); } - + if (!FunctionType::isValidReturnType(RetType) || isa(RetType)) return Error(RetTypeLoc, "invalid function return type"); - + LocTy NameLoc = Lex.getLoc(); std::string FunctionName; @@ -2454,12 +2589,12 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { } else { return TokError("expected function name"); } - + Lex.Lex(); - + if (Lex.getKind() != lltok::lparen) return TokError("expected '(' in function argument list"); - + std::vector ArgList; bool isVarArg; unsigned FuncAttrs; @@ -2481,22 +2616,22 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs); FuncAttrs &= ~Attribute::Alignment; } - + // Okay, if we got here, the function is syntactically valid. Convert types // and do semantic checks. std::vector ParamTypeList; SmallVector Attrs; - // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function + // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function // attributes. unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; if (FuncAttrs & ObsoleteFuncAttrs) { RetAttrs |= FuncAttrs & ObsoleteFuncAttrs; FuncAttrs &= ~ObsoleteFuncAttrs; } - + if (RetAttrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); - + for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { ParamTypeList.push_back(ArgList[i].Type); if (ArgList[i].Attrs != Attribute::None) @@ -2507,11 +2642,10 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs)); AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); - - if (PAL.paramHasAttr(1, Attribute::StructRet) && - RetType != Type::getVoidTy(Context)) - return Error(RetTypeLoc, "functions with 'sret' argument must return void"); - + + if (PAL.paramHasAttr(1, Attribute::StructRet) && !RetType->isVoidTy()) + return Error(RetTypeLoc, "functions with 'sret' argument must return void"); + const FunctionType *FT = FunctionType::get(RetType, ParamTypeList, isVarArg); const PointerType *PFT = PointerType::getUnqual(FT); @@ -2541,8 +2675,10 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { AI != AE; ++AI) AI->setName(""); } + } else if (M->getNamedValue(FunctionName)) { + return Error(NameLoc, "redefinition of function '@" + FunctionName + "'"); } - + } else { // If this is a definition of a forward referenced function, make sure the // types agree. @@ -2564,7 +2700,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { if (FunctionName.empty()) NumberedVals.push_back(Fn); - + Fn->setLinkage((GlobalValue::LinkageTypes)Linkage); Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility); Fn->setCallingConv(CC); @@ -2572,21 +2708,25 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { Fn->setAlignment(Alignment); Fn->setSection(Section); if (!GC.empty()) Fn->setGC(GC.c_str()); - + // Add all of the arguments we parsed to the function. Function::arg_iterator ArgIt = Fn->arg_begin(); for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) { + // If we run out of arguments in the Function prototype, exit early. + // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above. + if (ArgIt == Fn->arg_end()) break; + // If the argument has a name, insert it into the argument symbol table. if (ArgList[i].Name.empty()) continue; - + // Set the name, if it conflicted, it will be auto-renamed. ArgIt->setName(ArgList[i].Name); - + if (ArgIt->getNameStr() != ArgList[i].Name) return Error(ArgList[i].Loc, "redefinition of argument '%" + ArgList[i].Name + "'"); } - + return false; } @@ -2599,17 +2739,24 @@ bool LLParser::ParseFunctionBody(Function &Fn) { if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin) return TokError("expected '{' in function body"); Lex.Lex(); // eat the {. + + int FunctionNumber = -1; + if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1; - PerFunctionState PFS(*this, Fn); + PerFunctionState PFS(*this, Fn, FunctionNumber); + + // We need at least one basic block. + if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_end) + return TokError("function body requires at least one basic block"); while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end) if (ParseBasicBlock(PFS)) return true; - + // Eat the }. Lex.Lex(); - + // Verify function is ok. - return PFS.VerifyFunctionComplete(); + return PFS.FinishFunction(); } /// ParseBasicBlock @@ -2622,21 +2769,22 @@ bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { Name = Lex.getStrVal(); Lex.Lex(); } - + BasicBlock *BB = PFS.DefineBB(Name, NameLoc); if (BB == 0) return true; - + std::string NameStr; - + // Parse the instructions in this block until we get a terminator. Instruction *Inst; + SmallVector, 4> MetadataOnInst; do { // This instruction may have three possibilities for a name: a) none // specified, b) name specified "%foo =", c) number specified: "%4 =". LocTy NameLoc = Lex.getLoc(); int NameID = -1; NameStr = ""; - + if (Lex.getKind() == lltok::LocalVarID) { NameID = Lex.getUIntVal(); Lex.Lex(); @@ -2651,23 +2799,35 @@ bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { return true; } - if (ParseInstruction(Inst, BB, PFS)) return true; - if (EatIfPresent(lltok::comma)) - ParseOptionalDbgInfo(); + switch (ParseInstruction(Inst, BB, PFS)) { + default: assert(0 && "Unknown ParseInstruction result!"); + case InstError: return true; + case InstNormal: + // With a normal result, we check to see if the instruction is followed by + // a comma and metadata. + if (EatIfPresent(lltok::comma)) + if (ParseInstructionMetadata(MetadataOnInst)) + return true; + break; + case InstExtraComma: + // If the instruction parser ate an extra comma at the end of it, it + // *must* be followed by metadata. + if (ParseInstructionMetadata(MetadataOnInst)) + return true; + break; + } // Set metadata attached with this instruction. - Metadata &TheMetadata = M->getContext().getMetadata(); - for (SmallVector, 2>::iterator - MDI = MDsOnInst.begin(), MDE = MDsOnInst.end(); MDI != MDE; ++MDI) - TheMetadata.setMD(MDI->first, MDI->second, Inst); - MDsOnInst.clear(); + for (unsigned i = 0, e = MetadataOnInst.size(); i != e; ++i) + Inst->setMetadata(MetadataOnInst[i].first, MetadataOnInst[i].second); + MetadataOnInst.clear(); BB->getInstList().push_back(Inst); // Set the name on the instruction. if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true; } while (!isa(Inst)); - + return false; } @@ -2677,15 +2837,15 @@ bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { /// ParseInstruction - Parse one of the many different instructions. /// -bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, - PerFunctionState &PFS) { +int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, + PerFunctionState &PFS) { lltok::Kind Token = Lex.getKind(); if (Token == lltok::Eof) return TokError("found end of file when expecting more instructions"); LocTy Loc = Lex.getLoc(); unsigned KeywordVal = Lex.getUIntVal(); Lex.Lex(); // Eat the keyword. - + switch (Token) { default: return Error(Loc, "expected instruction opcode"); // Terminator Instructions. @@ -2694,6 +2854,7 @@ bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_ret: return ParseRet(Inst, BB, PFS); case lltok::kw_br: return ParseBr(Inst, PFS); case lltok::kw_switch: return ParseSwitch(Inst, PFS); + case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); case lltok::kw_invoke: return ParseInvoke(Inst, PFS); // Binary Operators. case lltok::kw_add: @@ -2763,7 +2924,7 @@ bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_uitofp: case lltok::kw_sitofp: case lltok::kw_fptoui: - case lltok::kw_fptosi: + case lltok::kw_fptosi: case lltok::kw_inttoptr: case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal); // Other. @@ -2776,9 +2937,9 @@ bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_call: return ParseCall(Inst, PFS, false); case lltok::kw_tail: return ParseCall(Inst, PFS, true); // Memory. - case lltok::kw_alloca: - case lltok::kw_malloc: return ParseAlloc(Inst, PFS, KeywordVal); - case lltok::kw_free: return ParseFree(Inst, PFS); + case lltok::kw_alloca: return ParseAlloc(Inst, PFS); + case lltok::kw_malloc: return ParseAlloc(Inst, PFS, BB, false); + case lltok::kw_free: return ParseFree(Inst, PFS, BB); case lltok::kw_load: return ParseLoad(Inst, PFS, false); case lltok::kw_store: return ParseStore(Inst, PFS, false); case lltok::kw_volatile: @@ -2841,57 +3002,55 @@ bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) { //===----------------------------------------------------------------------===// /// ParseRet - Parse a return instruction. -/// ::= 'ret' void (',' 'dbg' !1) -/// ::= 'ret' TypeAndValue (',' 'dbg' !1) -/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' 'dbg' !1) +/// ::= 'ret' void (',' !dbg, !1)* +/// ::= 'ret' TypeAndValue (',' !dbg, !1)* +/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' !dbg, !1)* /// [[obsolete: LLVM 3.0]] -bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, - PerFunctionState &PFS) { +int LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, + PerFunctionState &PFS) { PATypeHolder Ty(Type::getVoidTy(Context)); if (ParseType(Ty, true /*void allowed*/)) return true; - - if (Ty == Type::getVoidTy(Context)) { - if (EatIfPresent(lltok::comma)) - if (ParseOptionalDbgInfo()) return true; + + if (Ty->isVoidTy()) { Inst = ReturnInst::Create(Context); return false; } - + Value *RV; if (ParseValue(Ty, RV, PFS)) return true; + bool ExtraComma = false; if (EatIfPresent(lltok::comma)) { - // Parse optional 'dbg' - if (Lex.getKind() == lltok::kw_dbg) { - if (ParseOptionalDbgInfo()) return true; + // Parse optional custom metadata, e.g. !dbg + if (Lex.getKind() == lltok::MetadataVar) { + ExtraComma = true; } else { // The normal case is one return value. - // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring use - // of 'ret {i32,i32} {i32 1, i32 2}' + // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring + // use of 'ret {i32,i32} {i32 1, i32 2}' SmallVector RVs; RVs.push_back(RV); - + do { - // If optional 'dbg' is seen then this is the end of MRV. - if (Lex.getKind() == lltok::kw_dbg) - break; - if (ParseTypeAndValue(RV, PFS)) return true; - RVs.push_back(RV); + // If optional custom metadata, e.g. !dbg is seen then this is the + // end of MRV. + if (Lex.getKind() == lltok::MetadataVar) + break; + if (ParseTypeAndValue(RV, PFS)) return true; + RVs.push_back(RV); } while (EatIfPresent(lltok::comma)); RV = UndefValue::get(PFS.getFunction().getReturnType()); for (unsigned i = 0, e = RVs.size(); i != e; ++i) { - Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv"); - BB->getInstList().push_back(I); - RV = I; + Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv"); + BB->getInstList().push_back(I); + RV = I; } } } - if (EatIfPresent(lltok::comma)) - if (ParseOptionalDbgInfo()) return true; Inst = ReturnInst::Create(Context, RV); - return false; + return ExtraComma ? InstExtraComma : InstNormal; } @@ -2900,29 +3059,25 @@ bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, /// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { LocTy Loc, Loc2; - Value *Op0, *Op1, *Op2; + Value *Op0; + BasicBlock *Op1, *Op2; if (ParseTypeAndValue(Op0, Loc, PFS)) return true; - + if (BasicBlock *BB = dyn_cast(Op0)) { Inst = BranchInst::Create(BB); return false; } - + if (Op0->getType() != Type::getInt1Ty(Context)) return Error(Loc, "branch condition must have 'i1' type"); - + if (ParseToken(lltok::comma, "expected ',' after branch condition") || - ParseTypeAndValue(Op1, Loc, PFS) || + ParseTypeAndBasicBlock(Op1, Loc, PFS) || ParseToken(lltok::comma, "expected ',' after true destination") || - ParseTypeAndValue(Op2, Loc2, PFS)) + ParseTypeAndBasicBlock(Op2, Loc2, PFS)) return true; - - if (!isa(Op1)) - return Error(Loc, "true destination of branch must be a basic block"); - if (!isa(Op2)) - return Error(Loc2, "true destination of branch must be a basic block"); - - Inst = BranchInst::Create(cast(Op1), cast(Op2), Op0); + + Inst = BranchInst::Create(Op1, Op2, Op0); return false; } @@ -2933,50 +3088,87 @@ bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { /// ::= (TypeAndValue ',' TypeAndValue)* bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) { LocTy CondLoc, BBLoc; - Value *Cond, *DefaultBB; + Value *Cond; + BasicBlock *DefaultBB; if (ParseTypeAndValue(Cond, CondLoc, PFS) || ParseToken(lltok::comma, "expected ',' after switch condition") || - ParseTypeAndValue(DefaultBB, BBLoc, PFS) || + ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) || ParseToken(lltok::lsquare, "expected '[' with switch table")) return true; if (!isa(Cond->getType())) return Error(CondLoc, "switch condition must have integer type"); - if (!isa(DefaultBB)) - return Error(BBLoc, "default destination must be a basic block"); - + // Parse the jump table pairs. SmallPtrSet SeenCases; SmallVector, 32> Table; while (Lex.getKind() != lltok::rsquare) { - Value *Constant, *DestBB; - + Value *Constant; + BasicBlock *DestBB; + if (ParseTypeAndValue(Constant, CondLoc, PFS) || ParseToken(lltok::comma, "expected ',' after case value") || - ParseTypeAndValue(DestBB, BBLoc, PFS)) + ParseTypeAndBasicBlock(DestBB, PFS)) return true; - + if (!SeenCases.insert(Constant)) return Error(CondLoc, "duplicate case value in switch"); if (!isa(Constant)) return Error(CondLoc, "case value is not a constant integer"); - if (!isa(DestBB)) - return Error(BBLoc, "case destination is not a basic block"); - - Table.push_back(std::make_pair(cast(Constant), - cast(DestBB))); + + Table.push_back(std::make_pair(cast(Constant), DestBB)); } - + Lex.Lex(); // Eat the ']'. - - SwitchInst *SI = SwitchInst::Create(Cond, cast(DefaultBB), - Table.size()); + + SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size()); for (unsigned i = 0, e = Table.size(); i != e; ++i) SI->addCase(Table[i].first, Table[i].second); Inst = SI; return false; } +/// ParseIndirectBr +/// Instruction +/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']' +bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) { + LocTy AddrLoc; + Value *Address; + if (ParseTypeAndValue(Address, AddrLoc, PFS) || + ParseToken(lltok::comma, "expected ',' after indirectbr address") || + ParseToken(lltok::lsquare, "expected '[' with indirectbr")) + return true; + + if (!isa(Address->getType())) + return Error(AddrLoc, "indirectbr address must have pointer type"); + + // Parse the destination list. + SmallVector DestList; + + if (Lex.getKind() != lltok::rsquare) { + BasicBlock *DestBB; + if (ParseTypeAndBasicBlock(DestBB, PFS)) + return true; + DestList.push_back(DestBB); + + while (EatIfPresent(lltok::comma)) { + if (ParseTypeAndBasicBlock(DestBB, PFS)) + return true; + DestList.push_back(DestBB); + } + } + + if (ParseToken(lltok::rsquare, "expected ']' at end of block list")) + return true; + + IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size()); + for (unsigned i = 0, e = DestList.size(); i != e; ++i) + IBI->addDestination(DestList[i]); + Inst = IBI; + return false; +} + + /// ParseInvoke /// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList /// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue @@ -2989,7 +3181,7 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { ValID CalleeID; SmallVector ArgList; - Value *NormalBB, *UnwindBB; + BasicBlock *NormalBB, *UnwindBB; if (ParseOptionalCallingConv(CC) || ParseOptionalAttrs(RetAttrs, 1) || ParseType(RetType, RetTypeLoc, true /*void allowed*/) || @@ -2997,16 +3189,11 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { ParseParameterList(ArgList, PFS) || ParseOptionalAttrs(FnAttrs, 2) || ParseToken(lltok::kw_to, "expected 'to' in invoke") || - ParseTypeAndValue(NormalBB, PFS) || + ParseTypeAndBasicBlock(NormalBB, PFS) || ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || - ParseTypeAndValue(UnwindBB, PFS)) + ParseTypeAndBasicBlock(UnwindBB, PFS)) return true; - - if (!isa(NormalBB)) - return Error(CallLoc, "normal destination is not a basic block"); - if (!isa(UnwindBB)) - return Error(CallLoc, "unwind destination is not a basic block"); - + // If RetType is a non-function pointer type, then this is the short syntax // for the call, which means that RetType is just the return type. Infer the // rest of the function argument types from the arguments that are present. @@ -3018,18 +3205,18 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { std::vector ParamTypes; for (unsigned i = 0, e = ArgList.size(); i != e; ++i) ParamTypes.push_back(ArgList[i].V->getType()); - + if (!FunctionType::isValidReturnType(RetType)) return Error(RetTypeLoc, "Invalid result type for LLVM function"); - + Ty = FunctionType::get(RetType, ParamTypes, false); PFTy = PointerType::getUnqual(Ty); } - + // Look up the callee. Value *Callee; - if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; - + if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; + // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional // function attributes. unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; @@ -3037,14 +3224,14 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { RetAttrs |= FnAttrs & ObsoleteFuncAttrs; FnAttrs &= ~ObsoleteFuncAttrs; } - + // Set up the Attributes for the function. SmallVector Attrs; if (RetAttrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); - + SmallVector Args; - + // Loop through FunctionType's arguments and ensure they are specified // correctly. Also, gather any parameter attributes. FunctionType::param_iterator I = Ty->param_begin(); @@ -3056,7 +3243,7 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { } else if (!Ty->isVarArg()) { return Error(ArgList[i].Loc, "too many arguments specified"); } - + if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) return Error(ArgList[i].Loc, "argument is not of expected type '" + ExpectedTy->getDescription() + "'"); @@ -3064,18 +3251,17 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { if (ArgList[i].Attrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); } - + if (I != E) return Error(CallLoc, "not enough parameters specified for call"); - + if (FnAttrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); - + // Finish off the Attributes and check them AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); - - InvokeInst *II = InvokeInst::Create(Callee, cast(NormalBB), - cast(UnwindBB), + + InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB, Args.begin(), Args.end()); II->setCallingConv(CC); II->setAttributes(PAL); @@ -3112,10 +3298,10 @@ bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, case 1: Valid = LHS->getType()->isIntOrIntVector(); break; case 2: Valid = LHS->getType()->isFPOrFPVector(); break; } - + if (!Valid) return Error(Loc, "invalid operand type for instruction"); - + Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); return false; } @@ -3152,7 +3338,7 @@ bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS, ParseToken(lltok::comma, "expected ',' after compare value") || ParseValue(LHS->getType(), RHS, PFS)) return true; - + if (Opc == Instruction::FCmp) { if (!LHS->getType()->isFPOrFPVector()) return Error(Loc, "fcmp requires floating point operands"); @@ -3182,7 +3368,7 @@ bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS, ParseToken(lltok::kw_to, "expected 'to' after cast value") || ParseType(DestTy)) return true; - + if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) { CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy); return Error(Loc, "invalid cast opcode for cast from '" + @@ -3204,10 +3390,10 @@ bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after select value") || ParseTypeAndValue(Op2, PFS)) return true; - + if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2)) return Error(Loc, Reason); - + Inst = SelectInst::Create(Op0, Op1, Op2); return false; } @@ -3222,7 +3408,7 @@ bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after vaarg operand") || ParseType(EltTy, TypeLoc)) return true; - + if (!EltTy->isFirstClassType()) return Error(TypeLoc, "va_arg requires operand with first class type"); @@ -3239,10 +3425,10 @@ bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after extract value") || ParseTypeAndValue(Op1, PFS)) return true; - + if (!ExtractElementInst::isValidOperands(Op0, Op1)) return Error(Loc, "invalid extractelement operands"); - + Inst = ExtractElementInst::Create(Op0, Op1); return false; } @@ -3258,10 +3444,10 @@ bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after insertelement value") || ParseTypeAndValue(Op2, PFS)) return true; - + if (!InsertElementInst::isValidOperands(Op0, Op1, Op2)) return Error(Loc, "invalid insertelement operands"); - + Inst = InsertElementInst::Create(Op0, Op1, Op2); return false; } @@ -3277,21 +3463,21 @@ bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after shuffle value") || ParseTypeAndValue(Op2, PFS)) return true; - + if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2)) return Error(Loc, "invalid extractelement operands"); - + Inst = new ShuffleVectorInst(Op0, Op1, Op2); return false; } /// ParsePHI -/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Valueß ']')* -bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { +/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')* +int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { PATypeHolder Ty(Type::getVoidTy(Context)); Value *Op0, *Op1; LocTy TypeLoc = Lex.getLoc(); - + if (ParseType(Ty) || ParseToken(lltok::lsquare, "expected '[' in phi value list") || ParseValue(Ty, Op0, PFS) || @@ -3299,14 +3485,20 @@ bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { ParseValue(Type::getLabelTy(Context), Op1, PFS) || ParseToken(lltok::rsquare, "expected ']' in phi value list")) return true; - + + bool AteExtraComma = false; SmallVector, 16> PHIVals; while (1) { PHIVals.push_back(std::make_pair(Op0, cast(Op1))); - + if (!EatIfPresent(lltok::comma)) break; + if (Lex.getKind() == lltok::MetadataVar) { + AteExtraComma = true; + break; + } + if (ParseToken(lltok::lsquare, "expected '[' in phi value list") || ParseValue(Ty, Op0, PFS) || ParseToken(lltok::comma, "expected ',' after insertelement value") || @@ -3314,7 +3506,7 @@ bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::rsquare, "expected ']' in phi value list")) return true; } - + if (!Ty->isFirstClassType()) return Error(TypeLoc, "phi node must have first class type"); @@ -3323,7 +3515,7 @@ bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { for (unsigned i = 0, e = PHIVals.size(); i != e; ++i) PN->addIncoming(PHIVals[i].first, PHIVals[i].second); Inst = PN; - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseCall @@ -3338,7 +3530,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, ValID CalleeID; SmallVector ArgList; LocTy CallLoc = Lex.getLoc(); - + if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) || ParseOptionalCallingConv(CC) || ParseOptionalAttrs(RetAttrs, 1) || @@ -3347,7 +3539,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, ParseParameterList(ArgList, PFS) || ParseOptionalAttrs(FnAttrs, 2)) return true; - + // If RetType is a non-function pointer type, then this is the short syntax // for the call, which means that RetType is just the return type. Infer the // rest of the function argument types from the arguments that are present. @@ -3359,18 +3551,18 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, std::vector ParamTypes; for (unsigned i = 0, e = ArgList.size(); i != e; ++i) ParamTypes.push_back(ArgList[i].V->getType()); - + if (!FunctionType::isValidReturnType(RetType)) return Error(RetTypeLoc, "Invalid result type for LLVM function"); - + Ty = FunctionType::get(RetType, ParamTypes, false); PFTy = PointerType::getUnqual(Ty); } - + // Look up the callee. Value *Callee; - if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; - + if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; + // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional // function attributes. unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; @@ -3383,9 +3575,9 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, SmallVector Attrs; if (RetAttrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); - + SmallVector Args; - + // Loop through FunctionType's arguments and ensure they are specified // correctly. Also, gather any parameter attributes. FunctionType::param_iterator I = Ty->param_begin(); @@ -3397,7 +3589,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, } else if (!Ty->isVarArg()) { return Error(ArgList[i].Loc, "too many arguments specified"); } - + if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) return Error(ArgList[i].Loc, "argument is not of expected type '" + ExpectedTy->getDescription() + "'"); @@ -3405,7 +3597,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, if (ArgList[i].Attrs != Attribute::None) Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); } - + if (I != E) return Error(CallLoc, "not enough parameters specified for call"); @@ -3414,7 +3606,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, // Finish off the Attributes and check them AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); - + CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end()); CI->setTailCall(isTail); CI->setCallingConv(CC); @@ -3430,87 +3622,102 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, /// ParseAlloc /// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)? /// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)? -bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS, - unsigned Opc) { +int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS, + BasicBlock* BB, bool isAlloca) { PATypeHolder Ty(Type::getVoidTy(Context)); Value *Size = 0; LocTy SizeLoc; unsigned Alignment = 0; if (ParseType(Ty)) return true; + bool AteExtraComma = false; if (EatIfPresent(lltok::comma)) { - if (Lex.getKind() == lltok::kw_align || Lex.getKind() == lltok::kw_dbg) { - if (ParseOptionalInfo(Alignment)) return true; + if (Lex.getKind() == lltok::kw_align) { + if (ParseOptionalAlignment(Alignment)) return true; + } else if (Lex.getKind() == lltok::MetadataVar) { + AteExtraComma = true; } else { - if (ParseTypeAndValue(Size, SizeLoc, PFS)) return true; - if (EatIfPresent(lltok::comma)) - if (ParseOptionalInfo(Alignment)) return true; + if (ParseTypeAndValue(Size, SizeLoc, PFS) || + ParseOptionalCommaAlign(Alignment, AteExtraComma)) + return true; } } - if (Size && Size->getType() != Type::getInt32Ty(Context)) + if (Size && !Size->getType()->isInteger(32)) return Error(SizeLoc, "element count must be i32"); - if (Opc == Instruction::Malloc) - Inst = new MallocInst(Ty, Size, Alignment); - else + if (isAlloca) { Inst = new AllocaInst(Ty, Size, Alignment); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; + } + + // Autoupgrade old malloc instruction to malloc call. + // FIXME: Remove in LLVM 3.0. + const Type *IntPtrTy = Type::getInt32Ty(Context); + Constant *AllocSize = ConstantExpr::getSizeOf(Ty); + AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy); + if (!MallocF) + // Prototype malloc as "void *(int32)". + // This function is renamed as "malloc" in ValidateEndOfModule(). + MallocF = cast( + M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL)); + Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF); +return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseFree /// ::= 'free' TypeAndValue -bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS) { +bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS, + BasicBlock* BB) { Value *Val; LocTy Loc; if (ParseTypeAndValue(Val, Loc, PFS)) return true; if (!isa(Val->getType())) return Error(Loc, "operand to free must be a pointer"); - Inst = new FreeInst(Val); + Inst = CallInst::CreateFree(Val, BB); return false; } /// ParseLoad /// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)? -bool LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS, - bool isVolatile) { +int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS, + bool isVolatile) { Value *Val; LocTy Loc; unsigned Alignment = 0; - if (ParseTypeAndValue(Val, Loc, PFS)) return true; - - if (EatIfPresent(lltok::comma)) - if (ParseOptionalInfo(Alignment)) return true; + bool AteExtraComma = false; + if (ParseTypeAndValue(Val, Loc, PFS) || + ParseOptionalCommaAlign(Alignment, AteExtraComma)) + return true; if (!isa(Val->getType()) || !cast(Val->getType())->getElementType()->isFirstClassType()) return Error(Loc, "load operand must be a pointer to a first class type"); - + Inst = new LoadInst(Val, "", isVolatile, Alignment); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseStore /// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)? -bool LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS, - bool isVolatile) { +int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS, + bool isVolatile) { Value *Val, *Ptr; LocTy Loc, PtrLoc; unsigned Alignment = 0; + bool AteExtraComma = false; if (ParseTypeAndValue(Val, Loc, PFS) || ParseToken(lltok::comma, "expected ',' after store operand") || - ParseTypeAndValue(Ptr, PtrLoc, PFS)) + ParseTypeAndValue(Ptr, PtrLoc, PFS) || + ParseOptionalCommaAlign(Alignment, AteExtraComma)) return true; - if (EatIfPresent(lltok::comma)) - if (ParseOptionalInfo(Alignment)) return true; - if (!isa(Ptr->getType())) return Error(PtrLoc, "store operand must be a pointer"); if (!Val->getType()->isFirstClassType()) return Error(Loc, "store operand must be a first class value"); if (cast(Ptr->getType())->getElementType() != Val->getType()) return Error(Loc, "stored value and pointer type do not match"); - + Inst = new StoreInst(Val, Ptr, isVolatile, Alignment); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseGetResult @@ -3523,7 +3730,7 @@ bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) { ParseToken(lltok::comma, "expected ',' after getresult operand") || ParseUInt32(Element, EltLoc)) return true; - + if (!isa(Val->getType()) && !isa(Val->getType())) return Error(ValLoc, "getresult inst requires an aggregate operand"); if (!ExtractValueInst::getIndexedType(Val->getType(), Element)) @@ -3534,40 +3741,46 @@ bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) { /// ParseGetElementPtr /// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)* -bool LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { +int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { Value *Ptr, *Val; LocTy Loc, EltLoc; bool InBounds = EatIfPresent(lltok::kw_inbounds); if (ParseTypeAndValue(Ptr, Loc, PFS)) return true; - + if (!isa(Ptr->getType())) return Error(Loc, "base of getelementptr must be a pointer"); - + SmallVector Indices; + bool AteExtraComma = false; while (EatIfPresent(lltok::comma)) { + if (Lex.getKind() == lltok::MetadataVar) { + AteExtraComma = true; + break; + } if (ParseTypeAndValue(Val, EltLoc, PFS)) return true; if (!isa(Val->getType())) return Error(EltLoc, "getelementptr index must be an integer"); Indices.push_back(Val); } - + if (!GetElementPtrInst::getIndexedType(Ptr->getType(), Indices.begin(), Indices.end())) return Error(Loc, "invalid getelementptr indices"); Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end()); if (InBounds) cast(Inst)->setIsInBounds(true); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseExtractValue /// ::= 'extractvalue' TypeAndValue (',' uint32)+ -bool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { +int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { Value *Val; LocTy Loc; SmallVector Indices; + bool AteExtraComma; if (ParseTypeAndValue(Val, Loc, PFS) || - ParseIndexList(Indices)) + ParseIndexList(Indices, AteExtraComma)) return true; if (!isa(Val->getType()) && !isa(Val->getType())) @@ -3577,28 +3790,29 @@ bool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { Indices.end())) return Error(Loc, "invalid indices for extractvalue"); Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end()); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } /// ParseInsertValue /// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+ -bool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { +int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { Value *Val0, *Val1; LocTy Loc0, Loc1; SmallVector Indices; + bool AteExtraComma; if (ParseTypeAndValue(Val0, Loc0, PFS) || ParseToken(lltok::comma, "expected comma after insertvalue operand") || ParseTypeAndValue(Val1, Loc1, PFS) || - ParseIndexList(Indices)) + ParseIndexList(Indices, AteExtraComma)) return true; if (!isa(Val0->getType()) && !isa(Val0->getType())) return Error(Loc0, "extractvalue operand must be array or struct"); - + if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), Indices.end())) return Error(Loc0, "invalid indices for insertvalue"); Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end()); - return false; + return AteExtraComma ? InstExtraComma : InstNormal; } //===----------------------------------------------------------------------===// @@ -3609,33 +3823,22 @@ bool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { /// ::= Element (',' Element)* /// Element /// ::= 'null' | TypeAndValue -bool LLParser::ParseMDNodeVector(SmallVectorImpl &Elts) { - assert(Lex.getKind() == lltok::lbrace); - Lex.Lex(); +bool LLParser::ParseMDNodeVector(SmallVectorImpl &Elts, + PerFunctionState *PFS) { do { - Value *V = 0; - if (Lex.getKind() == lltok::kw_null) { - Lex.Lex(); - V = 0; - } else { - PATypeHolder Ty(Type::getVoidTy(Context)); - if (ParseType(Ty)) return true; - if (Lex.getKind() == lltok::Metadata) { - Lex.Lex(); - MetadataBase *Node = 0; - if (!ParseMDNode(Node)) - V = Node; - else { - MetadataBase *MDS = 0; - if (ParseMDString(MDS)) return true; - V = MDS; - } - } else { - Constant *C; - if (ParseGlobalValue(Ty, C)) return true; - V = C; - } + // Null is a special case since it is typeless. + if (EatIfPresent(lltok::kw_null)) { + Elts.push_back(0); + continue; } + + Value *V = 0; + PATypeHolder Ty(Type::getVoidTy(Context)); + ValID ID; + if (ParseType(Ty) || ParseValID(ID, PFS) || + ConvertValIDToValue(Ty, ID, V, PFS)) + return true; + Elts.push_back(V); } while (EatIfPresent(lltok::comma));