X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y;h=5a824ae8fe44b9b24c9972869946b741ddef3092;hb=e6be34a53ecbe8c2ff9f0793b13d847e94c0de91;hp=3f7115842a8cca69f53d19d563de5303f723d8e7;hpb=9d6565a5b1fbc4286d6ee638d8f47a3171a9ed7e;p=oota-llvm.git diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 3f7115842a8..5a824ae8fe4 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -18,19 +18,18 @@ #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/ValueSymbolTable.h" +#include "llvm/AutoUpgrade.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/CommandLine.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/Streams.h" +#include "llvm/ParamAttrsList.h" #include #include #include #include -#ifndef NDEBUG -#define YYDEBUG 1 -#endif // The following is a gross hack. In order to rid the libAsmParser library of // exceptions, we have to have a way of getting the yyparse function to go into @@ -50,15 +49,6 @@ static bool TriggerError = false; int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); - -namespace llvm { - std::string CurFilename; -#if YYDEBUG -static cl::opt -Debug("debug-yacc", cl::desc("Print yacc debug state changes"), - cl::Hidden, cl::init(false)); -#endif -} using namespace llvm; static Module *ParserResult; @@ -84,13 +74,12 @@ static GlobalVariable *CurGV; typedef std::vector ValueList; // Numbered defs static void -ResolveDefinitions(std::map &LateResolvers, - std::map *FutureLateResolvers = 0); +ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0); static struct PerModuleInfo { Module *CurrentModule; - std::map Values; // Module level numbered definitions - std::map LateResolveValues; + ValueList Values; // Module level numbered definitions + ValueList LateResolveValues; std::vector Types; std::map LateResolveTypes; @@ -132,6 +121,11 @@ static struct PerModuleInfo { return; } + // Look for intrinsic functions and CallInst that need to be upgraded + for (Module::iterator FI = CurrentModule->begin(), + FE = CurrentModule->end(); FI != FE; ) + UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove + Values.clear(); // Clear out function local definitions Types.clear(); CurrentModule = 0; @@ -201,24 +195,21 @@ static struct PerModuleInfo { } return false; } - - } CurModule; static struct PerFunctionInfo { Function *CurrentFunction; // Pointer to current function being created - std::map Values; // Keep track of #'d definitions - std::map LateResolveValues; + ValueList Values; // Keep track of #'d definitions + unsigned NextValNum; + ValueList LateResolveValues; bool isDeclare; // Is this function a forward declararation? GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration. GlobalValue::VisibilityTypes Visibility; /// BBForwardRefs - When we see forward references to basic blocks, keep /// track of them here. - std::map > BBForwardRefs; - std::vector NumberedBlocks; - unsigned NextBBNum; + std::map BBForwardRefs; inline PerFunctionInfo() { CurrentFunction = 0; @@ -229,16 +220,14 @@ static struct PerFunctionInfo { inline void FunctionStart(Function *M) { CurrentFunction = M; - NextBBNum = 0; + NextValNum = 0; } void FunctionDone() { - NumberedBlocks.clear(); - // Any forward referenced blocks left? if (!BBForwardRefs.empty()) { GenerateError("Undefined reference to label " + - BBForwardRefs.begin()->first->getName()); + BBForwardRefs.begin()->second->getName()); return; } @@ -246,6 +235,7 @@ static struct PerFunctionInfo { ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); Values.clear(); // Clear out function local definitions + BBForwardRefs.clear(); CurrentFunction = 0; isDeclare = false; Linkage = GlobalValue::ExternalLinkage; @@ -260,14 +250,23 @@ static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } // Code to handle definitions of all the types //===----------------------------------------------------------------------===// -static int InsertValue(Value *V, - std::map &ValueTab = CurFun.Values) { - if (V->hasName()) return -1; // Is this a numbered definition? +static void InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) { + // Things that have names or are void typed don't get slot numbers + if (V->hasName() || (V->getType() == Type::VoidTy)) + return; - // Yes, insert the value into the value table... - ValueList &List = ValueTab[V->getType()]; - List.push_back(V); - return List.size()-1; + // In the case of function values, we have to allow for the forward reference + // of basic blocks, which are included in the numbering. Consequently, we keep + // track of the next insertion location with NextValNum. When a BB gets + // inserted, it could change the size of the CurFun.Values vector. + if (&ValueTab == &CurFun.Values) { + if (ValueTab.size() <= CurFun.NextValNum) + ValueTab.resize(CurFun.NextValNum+1); + ValueTab[CurFun.NextValNum++] = V; + return; + } + // For all other lists, its okay to just tack it on the back of the vector. + ValueTab.push_back(V); } static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { @@ -278,7 +277,7 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { return CurModule.Types[D.Num]; break; case ValID::LocalName: // Is it a named definition? - if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) { D.destroy(); // Free old strdup'd memory... return N; } @@ -314,11 +313,11 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { return Typ; } -// getValNonImprovising - Look up the value specified by the provided type and +// getExistingVal - Look up the value specified by the provided type and // the provided ValID. If the value exists and has already been defined, return // it. Otherwise return null. // -static Value *getValNonImprovising(const Type *Ty, const ValID &D) { +static Value *getExistingVal(const Type *Ty, const ValID &D) { if (isa(Ty)) { GenerateError("Functions are not values and " "must be referenced as pointers"); @@ -327,33 +326,36 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { switch (D.Type) { case ValID::LocalID: { // Is it a numbered definition? - // Module constants occupy the lowest numbered slots. - std::map::iterator VI = CurFun.Values.find(Ty); - // Make sure that our type is within bounds. - if (VI == CurFun.Values.end()) return 0; - // Check that the number is within bounds. - if (D.Num >= VI->second.size()) return 0; - - return VI->second[D.Num]; + if (D.Num >= CurFun.Values.size()) + return 0; + Value *Result = CurFun.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); + return 0; + } + return Result; } case ValID::GlobalID: { // Is it a numbered definition? - unsigned Num = D.Num; - - // Module constants occupy the lowest numbered slots... - std::map::iterator VI = CurModule.Values.find(Ty); - if (VI == CurModule.Values.end()) + if (D.Num >= CurModule.Values.size()) return 0; - if (D.Num >= VI->second.size()) + Value *Result = CurModule.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); return 0; - return VI->second[Num]; + } + return Result; } case ValID::LocalName: { // Is it a named definition? if (!inFunctionScope()) return 0; ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); - Value *N = SymTab.lookup(D.Name); + Value *N = SymTab.lookup(D.getName()); if (N == 0) return 0; if (N->getType() != Ty) @@ -364,7 +366,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { } case ValID::GlobalName: { // Is it a named definition? ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable(); - Value *N = SymTab.lookup(D.Name); + Value *N = SymTab.lookup(D.getName()); if (N == 0) return 0; if (N->getType() != Ty) @@ -377,33 +379,42 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { // Check to make sure that "Ty" is an integral type, and that our // value will fit into the specified type... case ValID::ConstSIntVal: // Is it a constant pool reference?? - if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + if (!isa(Ty) || + !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { GenerateError("Signed integral constant '" + itostr(D.ConstPool64) + "' is invalid for type '" + Ty->getDescription() + "'"); return 0; } - return ConstantInt::get(Ty, D.ConstPool64); + return ConstantInt::get(Ty, D.ConstPool64, true); case ValID::ConstUIntVal: // Is it an unsigned const pool reference? - if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) { - if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { - GenerateError("Integral constant '" + utostr(D.UConstPool64) + - "' is invalid or out of range"); - return 0; - } else { // This is really a signed reference. Transmogrify. - return ConstantInt::get(Ty, D.ConstPool64); - } - } else { + if (isa(Ty) && + ConstantInt::isValueValidForType(Ty, D.UConstPool64)) return ConstantInt::get(Ty, D.UConstPool64); + + if (!isa(Ty) || + !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Integral constant '" + utostr(D.UConstPool64) + + "' is invalid or out of range for type '" + + Ty->getDescription() + "'"); + return 0; } + // This is really a signed reference. Transmogrify. + return ConstantInt::get(Ty, D.ConstPool64, true); case ValID::ConstFPVal: // Is it a floating point const pool reference? - if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { + if (!Ty->isFloatingPoint() || + !ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) { GenerateError("FP constant invalid for type"); return 0; } - return ConstantFP::get(Ty, D.ConstPoolFP); + // 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 (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble && + Ty==Type::FloatTy) + D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + return ConstantFP::get(Ty, *D.ConstPoolFP); case ValID::ConstNullVal: // Is it a null value? if (!isa(Ty)) { @@ -447,7 +458,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { return 0; } -// getVal - This function is identical to getValNonImprovising, except that if a +// getVal - This function is identical to getExistingVal, except that if a // value is not already defined, it "improvises" by creating a placeholder var // that looks and acts just like the requested variable. When the value is // defined later, all uses of the placeholder variable are replaced with the @@ -460,7 +471,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { } // See if the value has already been defined. - Value *V = getValNonImprovising(Ty, ID); + Value *V = getExistingVal(Ty, ID); if (V) return V; if (TriggerError) return 0; @@ -473,12 +484,30 @@ static Value *getVal(const Type *Ty, const ValID &ID) { // or an id number that hasn't been read yet. We may be referencing something // forward, so just create an entry to be resolved later and get to it... // - V = new Argument(Ty); - + switch (ID.Type) { + case ValID::GlobalName: + case ValID::GlobalID: { + const PointerType *PTy = dyn_cast(Ty); + if (!PTy) { + GenerateError("Invalid type for reference to global" ); + return 0; + } + const Type* ElTy = PTy->getElementType(); + if (const FunctionType *FTy = dyn_cast(ElTy)) + V = new Function(FTy, GlobalValue::ExternalLinkage); + else + V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "", + (Module*)0, false, PTy->getAddressSpace()); + break; + } + default: + V = new Argument(Ty); + } + // Remember where this forward reference came from. FIXME, shouldn't we try // to recycle these things?? CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, - llvmAsmlineno))); + LLLgetLineNo()))); if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); @@ -487,69 +516,105 @@ static Value *getVal(const Type *Ty, const ValID &ID) { return V; } -/// getBBVal - This is used for two purposes: -/// * If isDefinition is true, a new basic block with the specified ID is being -/// defined. -/// * If isDefinition is true, this is a reference to a basic block, which may -/// or may not be a forward reference. -/// -static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { +/// defineBBVal - This is a definition of a new basic block with the specified +/// identifier which must be the same as CurFun.NextValNum, if its numeric. +static BasicBlock *defineBBVal(const ValID &ID) { assert(inFunctionScope() && "Can't get basic block at global scope!"); - std::string Name; BasicBlock *BB = 0; - switch (ID.Type) { - default: - GenerateError("Illegal label reference " + ID.getName()); - return 0; - case ValID::LocalID: // Is it a numbered definition? - if (ID.Num >= CurFun.NumberedBlocks.size()) - CurFun.NumberedBlocks.resize(ID.Num+1); - BB = CurFun.NumberedBlocks[ID.Num]; - break; - case ValID::LocalName: // Is it a named definition? - Name = ID.Name; - Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name); - if (N && N->getType()->getTypeID() == Type::LabelTyID) - BB = cast(N); - break; - } - // See if the block has already been defined. - if (BB) { - // If this is the definition of the block, make sure the existing value was - // just a forward reference. If it was a forward reference, there will be - // an entry for it in the PlaceHolderInfo map. - if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) { - // The existing value was a definition, not a forward reference. - GenerateError("Redefinition of label " + ID.getName()); - return 0; + // First, see if this was forward referenced + + std::map::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + // The forward declaration could have been inserted anywhere in the + // function: insert it into the correct place now. + CurFun.CurrentFunction->getBasicBlockList().remove(BB); + CurFun.CurrentFunction->getBasicBlockList().push_back(BB); + + // We're about to erase the entry, save the key so we can clean it up. + ValID Tmp = BBI->first; + + // Erase the forward ref from the map as its no longer "forward" + CurFun.BBForwardRefs.erase(ID); + + // The key has been removed from the map but so we don't want to leave + // strdup'd memory around so destroy it too. + Tmp.destroy(); + + // If its a numbered definition, bump the number and set the BB value. + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); } - ID.destroy(); // Free strdup'd memory. + ID.destroy(); return BB; + } + + // We haven't seen this BB before and its first mention is a definition. + // Just create it and return it. + std::string Name (ID.Type == ValID::LocalName ? ID.getName() : ""); + BB = new BasicBlock(Name, CurFun.CurrentFunction); + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); } - // Otherwise this block has not been seen before. - BB = new BasicBlock("", CurFun.CurrentFunction); - if (ID.Type == ValID::LocalName) { - BB->setName(ID.Name); + ID.destroy(); // Free strdup'd memory + return BB; +} + +/// getBBVal - get an existing BB value or create a forward reference for it. +/// +static BasicBlock *getBBVal(const ValID &ID) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + BasicBlock *BB = 0; + + std::map::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + } if (ID.Type == ValID::LocalName) { + std::string Name = ID.getName(); + Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name); + if (N) { + if (N->getType()->getTypeID() == Type::LabelTyID) + BB = cast(N); + else + GenerateError("Reference to label '" + Name + "' is actually of type '"+ + N->getType()->getDescription() + "'"); + } + } else if (ID.Type == ValID::LocalID) { + if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) { + if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID) + BB = cast(CurFun.Values[ID.Num]); + else + GenerateError("Reference to label '%" + utostr(ID.Num) + + "' is actually of type '"+ + CurFun.Values[ID.Num]->getType()->getDescription() + "'"); + } } else { - CurFun.NumberedBlocks[ID.Num] = BB; + GenerateError("Illegal label reference " + ID.getName()); + return 0; } - // If this is not a definition, keep track of it so we can use it as a forward - // reference. - if (!isDefinition) { - // Remember where this forward reference came from. - CurFun.BBForwardRefs[BB] = std::make_pair(ID, llvmAsmlineno); - } else { - // The forward declaration could have been inserted anywhere in the - // function: insert it into the correct place now. - CurFun.CurrentFunction->getBasicBlockList().remove(BB); - CurFun.CurrentFunction->getBasicBlockList().push_back(BB); + // If its already been defined, return it now. + if (BB) { + ID.destroy(); // Free strdup'd memory. + return BB; } - ID.destroy(); + + // Otherwise, this block has not been seen before, create it. + std::string Name; + if (ID.Type == ValID::LocalName) + Name = ID.getName(); + BB = new BasicBlock(Name, CurFun.CurrentFunction); + + // Insert it in the forward refs map. + CurFun.BBForwardRefs[ID] = BB; + return BB; } @@ -571,50 +636,44 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { // defs now... // static void -ResolveDefinitions(std::map &LateResolvers, - std::map *FutureLateResolvers) { +ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) { // Loop over LateResolveDefs fixing up stuff that couldn't be resolved - for (std::map::iterator LRI = LateResolvers.begin(), - E = LateResolvers.end(); LRI != E; ++LRI) { - ValueList &List = LRI->second; - while (!List.empty()) { - Value *V = List.back(); - List.pop_back(); + while (!LateResolvers.empty()) { + Value *V = LateResolvers.back(); + LateResolvers.pop_back(); - std::map >::iterator PHI = - CurModule.PlaceHolderInfo.find(V); - assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!"); + std::map >::iterator PHI = + CurModule.PlaceHolderInfo.find(V); + assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!"); - ValID &DID = PHI->second.first; + ValID &DID = PHI->second.first; - Value *TheRealValue = getValNonImprovising(LRI->first, DID); - if (TriggerError) + Value *TheRealValue = getExistingVal(V->getType(), DID); + if (TriggerError) + return; + if (TheRealValue) { + V->replaceAllUsesWith(TheRealValue); + delete V; + CurModule.PlaceHolderInfo.erase(PHI); + } else if (FutureLateResolvers) { + // Functions have their unresolved items forwarded to the module late + // resolver table + InsertValue(V, *FutureLateResolvers); + } else { + if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) { + GenerateError("Reference to an invalid definition: '" +DID.getName()+ + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); return; - if (TheRealValue) { - V->replaceAllUsesWith(TheRealValue); - delete V; - CurModule.PlaceHolderInfo.erase(PHI); - } else if (FutureLateResolvers) { - // Functions have their unresolved items forwarded to the module late - // resolver table - InsertValue(V, *FutureLateResolvers); } else { - if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) { - GenerateError("Reference to an invalid definition: '" +DID.getName()+ - "' of type '" + V->getType()->getDescription() + "'", - PHI->second.second); - return; - } else { - GenerateError("Reference to an invalid definition: #" + - itostr(DID.Num) + " of type '" + - V->getType()->getDescription() + "'", - PHI->second.second); - return; - } + GenerateError("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", + PHI->second.second); + return; } } } - LateResolvers.clear(); } @@ -622,10 +681,12 @@ ResolveDefinitions(std::map &LateResolvers, // name is not null) things referencing Name can be resolved. Otherwise, things // refering to the number can be resolved. Do this now. // -static void ResolveTypeTo(char *Name, const Type *ToTy) { +static void ResolveTypeTo(std::string *Name, const Type *ToTy) { ValID D; - if (Name) D = ValID::createLocalName(Name); - else D = ValID::createLocalID(CurModule.Types.size()); + if (Name) + D = ValID::createLocalName(*Name); + else + D = ValID::createLocalID(CurModule.Types.size()); std::map::iterator I = CurModule.LateResolveTypes.find(D); @@ -639,10 +700,10 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) { // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is free'd by this function. // -static void setValueName(Value *V, char *NameStr) { +static void setValueName(Value *V, std::string *NameStr) { if (!NameStr) return; - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string if (V->getType() == Type::VoidTy) { GenerateError("Can't assign name '" + Name+"' to value with void type"); @@ -664,31 +725,32 @@ static void setValueName(Value *V, char *NameStr) { /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, /// this is a declaration, otherwise it is a definition. static GlobalVariable * -ParseGlobalVariable(char *NameStr, +ParseGlobalVariable(std::string *NameStr, GlobalValue::LinkageTypes Linkage, GlobalValue::VisibilityTypes Visibility, bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { + Constant *Initializer, bool IsThreadLocal, + unsigned AddressSpace = 0) { if (isa(Ty)) { GenerateError("Cannot declare global vars of function type"); return 0; } - const PointerType *PTy = PointerType::get(Ty); + const PointerType *PTy = PointerType::get(Ty, AddressSpace); std::string Name; if (NameStr) { - Name = NameStr; // Copy string - free(NameStr); // Free old string + Name = *NameStr; // Copy string + delete NameStr; // Free old string } // See if this global value was forward referenced. If so, recycle the // object. ValID ID; if (!Name.empty()) { - ID = ValID::createGlobalName((char*)Name.c_str()); + ID = ValID::createGlobalName(Name); } else { - ID = ValID::createGlobalID(CurModule.Values[PTy].size()); + ID = ValID::createGlobalID(CurModule.Values.size()); } if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { @@ -701,6 +763,7 @@ ParseGlobalVariable(char *NameStr, GV->setLinkage(Linkage); GV->setVisibility(Visibility); GV->setConstant(isConstantGlobal); + GV->setThreadLocal(IsThreadLocal); InsertValue(GV, CurModule.Values); return GV; } @@ -725,7 +788,7 @@ ParseGlobalVariable(char *NameStr, // Otherwise there is no existing GV to use, create one now. GlobalVariable *GV = new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, - CurModule.CurrentModule); + CurModule.CurrentModule, IsThreadLocal, AddressSpace); GV->setVisibility(Visibility); InsertValue(GV, CurModule.Values); return GV; @@ -738,12 +801,12 @@ ParseGlobalVariable(char *NameStr, // This function returns true if the type has already been defined, but is // allowed to be redefined in the specified context. If the name is a new name // for the type plane, it is inserted and false is returned. -static bool setTypeName(const Type *T, char *NameStr) { +static bool setTypeName(const Type *T, std::string *NameStr) { assert(!inFunctionScope() && "Can't give types function-local names!"); if (NameStr == 0) return false; - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string // We don't allow assigning names to void type if (T == Type::VoidTy) { @@ -878,22 +941,11 @@ static PATypeHolder HandleUpRefs(const Type *ty) { // static Module* RunParser(Module * M); -Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { - set_scan_file(F); - - CurFilename = Filename; - return RunParser(new Module(CurFilename)); -} - -Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { - set_scan_string(AsmString); - - CurFilename = "from_memory"; - if (M == NULL) { - return RunParser(new Module (CurFilename)); - } else { - return RunParser(M); - } +Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { + InitLLLexer(MB); + Module *M = RunParser(new Module(LLLgetFilename())); + FreeLexer(); + return M; } %} @@ -914,7 +966,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { llvm::ArgListType *ArgList; llvm::TypeWithAttrs TypeWithAttrs; llvm::TypeWithAttrsList *TypeWithAttrsList; - llvm::ValueRefList *ValueRefList; + llvm::ParamList *ParamList; // Represent the RHS of PHI node std::list BasicBlock InstructionList %type BBTerminatorInst %type Inst InstVal MemoryInst -%type ConstVal ConstExpr +%type ConstVal ConstExpr AliaseeRef %type ConstVector %type ArgList ArgListH %type PHIList -%type ValueRefList // For call param lists & GEP indices +%type ParamList // For call param lists & GEP indices %type IndexList // For GEP indices %type TypeListI %type ArgTypeList ArgTypeListI %type ArgType %type JumpTable %type GlobalType // GLOBAL or CONSTANT? +%type ThreadLocal // 'thread_local' or not %type OptVolatile // 'volatile' or not %type OptTailCall // TAIL CALL or plain CALL. %type OptSideEffect // 'sideeffect' or not. %type GVInternalLinkage GVExternalLinkage %type FunctionDefineLinkage FunctionDeclareLinkage +%type AliasLinkage %type GVVisibilityStyle // ValueRef - Unresolved reference to a definition or BB %type ValueRef ConstValueRef SymbolicValueRef %type ResolvedVal // pair +%type ReturnedVal // Tokens and types for handling constant integer values // // ESINT64VAL - A negative number within long long range @@ -978,6 +1034,12 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { // EUINT64VAL - A positive number within uns. long long range %token EUINT64VAL +// ESAPINTVAL - A negative number with arbitrary precision +%token ESAPINTVAL + +// EUAPINTVAL - A positive number with arbitrary precision +%token EUAPINTVAL + %token LOCALVAL_ID GLOBALVAL_ID // %123 @123 %token FPVAL // Float or Double constant @@ -985,20 +1047,23 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { %type Types ResultTypes %type IntType FPType PrimType // Classifications %token VOID INTTYPE -%token FLOAT DOUBLE LABEL +%token FLOAT DOUBLE X86_FP80 FP128 PPC_FP128 LABEL %token TYPE -%token LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT + +%token LOCALVAR GLOBALVAR LABELSTR +%token STRINGCONSTANT ATSTRINGCONSTANT PCTSTRINGCONSTANT %type LocalName OptLocalName OptLocalAssign -%type GlobalName OptGlobalAssign -%type OptAlign OptCAlign -%type OptSection SectionString +%type GlobalName OptGlobalAssign GlobalAssign +%type OptSection SectionString OptGC -%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK -%token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE +%type OptAlign OptCAlign OptAddrSpace + +%token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK +%token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL %token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING %token DLLIMPORT DLLEXPORT EXTERN_WEAK -%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN +%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN ADDRSPACE %token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT %token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK X86_STDCALLCC_TOK X86_FASTCALLCC_TOK %token DATALAYOUT @@ -1031,12 +1096,14 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { // Other Operators %token PHI_TOK SELECT VAARG %token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR +%token GETRESULT // Function Attributes -%token NORETURN INREG SRET +%token SIGNEXT ZEROEXT NORETURN INREG SRET NOUNWIND NOALIAS BYVAL NEST +%token READNONE READONLY GC // Visibility Styles -%token DEFAULT HIDDEN +%token DEFAULT HIDDEN PROTECTED %start Module %% @@ -1073,11 +1140,14 @@ FPredicates // These are some types that allow classification if we only want a particular // thing... for example, only a signed, unsigned, or integral type. IntType : INTTYPE; -FPType : FLOAT | DOUBLE; +FPType : FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80; -LocalName : LOCALVAR | STRINGCONSTANT; +LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT ; OptLocalName : LocalName | /*empty*/ { $$ = 0; }; +OptAddrSpace : ADDRSPACE '(' EUINT64VAL ')' { $$=$3; } + | /*empty*/ { $$=0; }; + /// OptLocalAssign - Value producing statements have an optional assignment /// component. OptLocalAssign : LocalName '=' { @@ -1089,17 +1159,19 @@ OptLocalAssign : LocalName '=' { CHECK_FOR_ERROR }; -GlobalName : GLOBALVAR | ATSTRINGCONSTANT; +GlobalName : GLOBALVAR | ATSTRINGCONSTANT ; -OptGlobalAssign : GlobalName '=' { - $$ = $1; - CHECK_FOR_ERROR - } +OptGlobalAssign : GlobalAssign | /*empty*/ { $$ = 0; CHECK_FOR_ERROR }; +GlobalAssign : GlobalName '=' { + $$ = $1; + CHECK_FOR_ERROR + }; + GVInternalLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | WEAK { $$ = GlobalValue::WeakLinkage; } @@ -1115,8 +1187,10 @@ GVExternalLinkage ; GVVisibilityStyle - : /*empty*/ { $$ = GlobalValue::DefaultVisibility; } - | HIDDEN { $$ = GlobalValue::HiddenVisibility; } + : /*empty*/ { $$ = GlobalValue::DefaultVisibility; } + | DEFAULT { $$ = GlobalValue::DefaultVisibility; } + | HIDDEN { $$ = GlobalValue::HiddenVisibility; } + | PROTECTED { $$ = GlobalValue::ProtectedVisibility; } ; FunctionDeclareLinkage @@ -1125,7 +1199,7 @@ FunctionDeclareLinkage | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } ; -FunctionDefineLinkage +FunctionDefineLinkage : /*empty*/ { $$ = GlobalValue::ExternalLinkage; } | INTERNAL { $$ = GlobalValue::InternalLinkage; } | LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } @@ -1133,6 +1207,12 @@ FunctionDefineLinkage | DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; } ; +AliasLinkage + : /*empty*/ { $$ = GlobalValue::ExternalLinkage; } + | WEAK { $$ = GlobalValue::WeakLinkage; } + | INTERNAL { $$ = GlobalValue::InternalLinkage; } + ; + OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CCC_TOK { $$ = CallingConv::C; } | FASTCC_TOK { $$ = CallingConv::Fast; } | @@ -1146,25 +1226,42 @@ OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CHECK_FOR_ERROR }; -ParamAttr : ZEXT { $$ = FunctionType::ZExtAttribute; } - | SEXT { $$ = FunctionType::SExtAttribute; } - | INREG { $$ = FunctionType::InRegAttribute; } - | SRET { $$ = FunctionType::StructRetAttribute; } +ParamAttr : ZEROEXT { $$ = ParamAttr::ZExt; } + | ZEXT { $$ = ParamAttr::ZExt; } + | SIGNEXT { $$ = ParamAttr::SExt; } + | SEXT { $$ = ParamAttr::SExt; } + | INREG { $$ = ParamAttr::InReg; } + | SRET { $$ = ParamAttr::StructRet; } + | NOALIAS { $$ = ParamAttr::NoAlias; } + | BYVAL { $$ = ParamAttr::ByVal; } + | NEST { $$ = ParamAttr::Nest; } + | ALIGN EUINT64VAL { $$ = + ParamAttr::constructAlignmentFromInt($2); } ; -OptParamAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } +OptParamAttrs : /* empty */ { $$ = ParamAttr::None; } | OptParamAttrs ParamAttr { - $$ = FunctionType::ParameterAttributes($1 | $2); + $$ = $1 | $2; } ; -FuncAttr : NORETURN { $$ = FunctionType::NoReturnAttribute; } - | ParamAttr +FuncAttr : NORETURN { $$ = ParamAttr::NoReturn; } + | NOUNWIND { $$ = ParamAttr::NoUnwind; } + | ZEROEXT { $$ = ParamAttr::ZExt; } + | SIGNEXT { $$ = ParamAttr::SExt; } + | READNONE { $$ = ParamAttr::ReadNone; } + | READONLY { $$ = ParamAttr::ReadOnly; } ; -OptFuncAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } +OptFuncAttrs : /* empty */ { $$ = ParamAttr::None; } | OptFuncAttrs FuncAttr { - $$ = FunctionType::ParameterAttributes($1 | $2); + $$ = $1 | $2; + } + ; + +OptGC : /* empty */ { $$ = 0; } + | GC STRINGCONSTANT { + $$ = $2; } ; @@ -1186,9 +1283,10 @@ OptCAlign : /*empty*/ { $$ = 0; } | }; + SectionString : SECTION STRINGCONSTANT { - for (unsigned i = 0, e = strlen($2); i != e; ++i) - if ($2[i] == '"' || $2[i] == '\\') + for (unsigned i = 0, e = $2->length(); i != e; ++i) + if ((*$2)[i] == '"' || (*$2)[i] == '\\') GEN_ERROR("Invalid character in section name"); $$ = $2; CHECK_FOR_ERROR @@ -1203,8 +1301,8 @@ OptSection : /*empty*/ { $$ = 0; } | GlobalVarAttributes : /* empty */ {} | ',' GlobalVarAttribute GlobalVarAttributes {}; GlobalVarAttribute : SectionString { - CurGV->setSection($1); - free($1); + CurGV->setSection(*$1); + delete $1; CHECK_FOR_ERROR } | ALIGN EUINT64VAL { @@ -1220,7 +1318,7 @@ GlobalVarAttribute : SectionString { // Derived types are added later... // -PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ; +PrimType : INTTYPE | FLOAT | DOUBLE | PPC_FP128 | FP128 | X86_FP80 | LABEL ; Types : OPAQUE { @@ -1231,10 +1329,10 @@ Types $$ = new PATypeHolder($1); CHECK_FOR_ERROR } - | Types '*' { // Pointer type? + | Types OptAddrSpace '*' { // Pointer type? if (*$1 == Type::LabelTy) GEN_ERROR("Cannot form a pointer to a basic block"); - $$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1))); + $$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1, $2))); delete $1; CHECK_FOR_ERROR } @@ -1252,36 +1350,55 @@ Types CHECK_FOR_ERROR } | Types '(' ArgTypeListI ')' OptFuncAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. + const Type* RetTy = *$1; + if (!(RetTy->isFirstClassType() || RetTy == Type::VoidTy || + isa(RetTy))) + GEN_ERROR("LLVM Functions cannot return aggregates"); + std::vector Params; - std::vector Attrs; - Attrs.push_back($5); - for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { - Params.push_back(I->Ty->get()); - if (I->Ty->get() != Type::VoidTy) - Attrs.push_back(I->Attrs); + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + for (; I != E; ++I ) { + const Type *Ty = I->Ty->get(); + Params.push_back(Ty); } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, Attrs); + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); + + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get(RetTy, Params, isVarArg); delete $3; // Delete the argument list delete $1; // Delete the return type handle $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR } | VOID '(' ArgTypeListI ')' OptFuncAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. std::vector Params; - std::vector Attrs; - Attrs.push_back($5); - for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { - Params.push_back(I->Ty->get()); - if (I->Ty->get() != Type::VoidTy) - Attrs.push_back(I->Attrs); + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + for ( ; I != E; ++I ) { + const Type* Ty = I->Ty->get(); + Params.push_back(Ty); } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - FunctionType *FT = FunctionType::get($1, Params, isVarArg, Attrs); + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); + + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get($1, Params, isVarArg); delete $3; // Delete the argument list $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR @@ -1292,14 +1409,12 @@ Types delete $4; CHECK_FOR_ERROR } - | '<' EUINT64VAL 'x' Types '>' { // Packed array type? + | '<' EUINT64VAL 'x' Types '>' { // Vector type? const llvm::Type* ElemTy = $4->get(); if ((unsigned)$2 != $2) GEN_ERROR("Unsigned result not equal to signed result"); if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger()) GEN_ERROR("Element type of a VectorType must be primitive"); - if (!isPowerOf2_32($2)) - GEN_ERROR("Vector length should be a power of 2"); $$ = new PATypeHolder(HandleUpRefs(VectorType::get(*$4, (unsigned)$2))); delete $4; CHECK_FOR_ERROR @@ -1335,9 +1450,11 @@ Types ; ArgType - : Types OptParamAttrs { + : Types OptParamAttrs { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. $$.Ty = $1; - $$.Attrs = $2; + $$.Attrs = ParamAttr::None; } ; @@ -1345,7 +1462,7 @@ ResultTypes : Types { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); - if (!(*$1)->isFirstClassType()) + if (!(*$1)->isFirstClassType() && !isa($1->get())) GEN_ERROR("LLVM functions cannot return aggregate types"); $$ = $1; } @@ -1369,14 +1486,14 @@ ArgTypeListI : ArgTypeList | ArgTypeList ',' DOTDOTDOT { $$=$1; - TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; TWA.Ty = new PATypeHolder(Type::VoidTy); $$->push_back(TWA); CHECK_FOR_ERROR } | DOTDOTDOT { $$ = new TypeWithAttrsList; - TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; TWA.Ty = new PATypeHolder(Type::VoidTy); $$->push_back(TWA); CHECK_FOR_ERROR @@ -1391,11 +1508,13 @@ ArgTypeListI // TypeListI : Types { $$ = new std::list(); - $$->push_back(*$1); delete $1; + $$->push_back(*$1); + delete $1; CHECK_FOR_ERROR } | TypeListI ',' Types { - ($$=$1)->push_back(*$3); delete $3; + ($$=$1)->push_back(*$3); + delete $3; CHECK_FOR_ERROR }; @@ -1459,21 +1578,19 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr int NumElements = ATy->getNumElements(); const Type *ETy = ATy->getElementType(); - char *EndStr = UnEscapeLexed($3, true); - if (NumElements != -1 && NumElements != (EndStr-$3)) + if (NumElements != -1 && NumElements != int($3->length())) GEN_ERROR("Can't build string constant of size " + - itostr((int)(EndStr-$3)) + + itostr((int)($3->length())) + " when array has size " + itostr(NumElements) + ""); std::vector Vals; if (ETy == Type::Int8Ty) { - for (unsigned char *C = (unsigned char *)$3; - C != (unsigned char*)EndStr; ++C) - Vals.push_back(ConstantInt::get(ETy, *C)); + for (unsigned i = 0; i < $3->length(); ++i) + Vals.push_back(ConstantInt::get(ETy, (*$3)[i])); } else { - free($3); + delete $3; GEN_ERROR("Cannot build string arrays of non byte sized elements"); } - free($3); + delete $3; $$ = ConstantArray::get(ATy, Vals); delete $1; CHECK_FOR_ERROR @@ -1525,7 +1642,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // Check to ensure that Type is not packed if (STy->isPacked()) - GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'"); + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); $$ = ConstantStruct::get(STy, *$3); delete $1; delete $3; @@ -1544,7 +1662,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // Check to ensure that Type is not packed if (STy->isPacked()) - GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'"); + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); $$ = ConstantStruct::get(STy, std::vector()); delete $1; @@ -1569,7 +1688,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // Check to ensure that Type is packed if (!STy->isPacked()) - GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'"); + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); $$ = ConstantStruct::get(STy, *$4); delete $1; delete $4; @@ -1588,7 +1708,8 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // Check to ensure that Type is packed if (!STy->isPacked()) - GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'"); + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); $$ = ConstantStruct::get(STy, std::vector()); delete $1; @@ -1618,19 +1739,19 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const PointerType *Ty = dyn_cast($1->get()); if (Ty == 0) - GEN_ERROR("Global const reference must be a pointer type"); + GEN_ERROR("Global const reference must be a pointer type " + (*$1)->getDescription()); // ConstExprs can exist in the body of a function, thus creating // GlobalValues whenever they refer to a variable. Because we are in - // the context of a function, getValNonImprovising will search the functions + // the context of a function, getExistingVal will search the functions // symbol table instead of the module symbol table for the global symbol, // which throws things all off. To get around this, we just tell - // getValNonImprovising that we are at global scope here. + // getExistingVal that we are at global scope here. // Function *SavedCurFn = CurFun.CurrentFunction; CurFun.CurrentFunction = 0; - Value *V = getValNonImprovising(Ty, $2); + Value *V = getExistingVal(Ty, $2); CHECK_FOR_ERROR CurFun.CurrentFunction = SavedCurFn; @@ -1653,7 +1774,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr } else { std::string Name; if ($2.Type == ValID::GlobalName) - Name = $2.Name; + Name = $2.getName(); else if ($2.Type != ValID::GlobalID) GEN_ERROR("Invalid reference to global"); @@ -1661,11 +1782,11 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr GlobalValue *GV; if (const FunctionType *FTy = dyn_cast(PT->getElementType())) { - GV = new Function(FTy, GlobalValue::ExternalLinkage, Name, + GV = new Function(FTy, GlobalValue::ExternalWeakLinkage, Name, CurModule.CurrentModule); } else { GV = new GlobalVariable(PT->getElementType(), false, - GlobalValue::ExternalLinkage, 0, + GlobalValue::ExternalWeakLinkage, 0, Name, CurModule.CurrentModule); } @@ -1702,13 +1823,33 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr | IntType ESINT64VAL { // integral constants if (!ConstantInt::isValueValidForType($1, $2)) GEN_ERROR("Constant value doesn't fit in type"); - $$ = ConstantInt::get($1, $2); + $$ = ConstantInt::get($1, $2, true); + CHECK_FOR_ERROR + } + | IntType ESAPINTVAL { // arbitrary precision integer constants + uint32_t BitWidth = cast($1)->getBitWidth(); + if ($2->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + $2->sextOrTrunc(BitWidth); + $$ = ConstantInt::get(*$2); + delete $2; CHECK_FOR_ERROR } | IntType EUINT64VAL { // integral constants if (!ConstantInt::isValueValidForType($1, $2)) GEN_ERROR("Constant value doesn't fit in type"); - $$ = ConstantInt::get($1, $2); + $$ = ConstantInt::get($1, $2, false); + CHECK_FOR_ERROR + } + | IntType EUAPINTVAL { // arbitrary precision integer constants + uint32_t BitWidth = cast($1)->getBitWidth(); + if ($2->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + $2->zextOrTrunc(BitWidth); + $$ = ConstantInt::get(*$2); + delete $2; CHECK_FOR_ERROR } | INTTYPE TRUETOK { // Boolean constants @@ -1721,10 +1862,15 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $$ = ConstantInt::getFalse(); CHECK_FOR_ERROR } - | FPType FPVAL { // Float & Double constants - if (!ConstantFP::isValueValidForType($1, $2)) + | FPType FPVAL { // Floating point constants + if (!ConstantFP::isValueValidForType($1, *$2)) GEN_ERROR("Floating point constant invalid for type"); - $$ = ConstantFP::get($1, $2); + // Lexer has no type info, so builds all float and double FP constants + // as double. Fix this here. Long double is done right. + if (&$2->getSemantics()==&APFloat::IEEEdouble && $1==Type::FloatTy) + $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + $$ = ConstantFP::get($1, *$2); + delete $2; CHECK_FOR_ERROR }; @@ -1746,7 +1892,7 @@ ConstExpr: CastOps '(' ConstVal TO Types ')' { GEN_ERROR("GetElementPtr requires a pointer operand"); const Type *IdxTy = - GetElementPtrInst::getIndexedType($3->getType(), &(*$4)[0], $4->size(), + GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end(), true); if (!IdxTy) GEN_ERROR("Index list invalid for constant getelementptr"); @@ -1833,6 +1979,34 @@ ConstVector : ConstVector ',' ConstVal { // GlobalType - Match either GLOBAL or CONSTANT for global declarations... GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; +// ThreadLocal +ThreadLocal : THREAD_LOCAL { $$ = true; } | { $$ = false; }; + +// AliaseeRef - Match either GlobalValue or bitcast to GlobalValue. +AliaseeRef : ResultTypes SymbolicValueRef { + const Type* VTy = $1->get(); + Value *V = getVal(VTy, $2); + CHECK_FOR_ERROR + GlobalValue* Aliasee = dyn_cast(V); + if (!Aliasee) + GEN_ERROR("Aliases can be created only to global values"); + + $$ = Aliasee; + CHECK_FOR_ERROR + delete $1; + } + | BITCAST '(' AliaseeRef TO Types ')' { + Constant *Val = $3; + const Type *DestTy = $5->get(); + if (!CastInst::castIsValid($1, $3, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + + $$ = ConstantExpr::getCast($1, $3, DestTy); + CHECK_FOR_ERROR + delete $5; + }; //===----------------------------------------------------------------------===// // Rules to match Modules @@ -1870,18 +2044,6 @@ Definition | MODULE ASM_TOK AsmBlock { CHECK_FOR_ERROR } - | IMPLEMENTATION { - // Emit an error if there are any unresolved types left. - if (!CurModule.LateResolveTypes.empty()) { - const ValID &DID = CurModule.LateResolveTypes.begin()->first; - if (DID.Type == ValID::LocalName) { - GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'"); - } else { - GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num)); - } - } - CHECK_FOR_ERROR - } | OptLocalAssign TYPE Types { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); @@ -1917,34 +2079,77 @@ Definition } CHECK_FOR_ERROR } - | OptGlobalAssign GVVisibilityStyle GlobalType ConstVal { + | OptGlobalAssign GVVisibilityStyle ThreadLocal GlobalType ConstVal + OptAddrSpace { /* "Externally Visible" Linkage */ - if ($4 == 0) + if ($5 == 0) GEN_ERROR("Global value initializer is not a constant"); CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage, - $2, $3, $4->getType(), $4); + $2, $4, $5->getType(), $5, $3, $6); CHECK_FOR_ERROR } GlobalVarAttributes { CurGV = 0; } - | OptGlobalAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal { - if ($5 == 0) + | OptGlobalAssign GVInternalLinkage GVVisibilityStyle ThreadLocal GlobalType + ConstVal OptAddrSpace { + if ($6 == 0) GEN_ERROR("Global value initializer is not a constant"); - CurGV = ParseGlobalVariable($1, $2, $3, $4, $5->getType(), $5); + CurGV = ParseGlobalVariable($1, $2, $3, $5, $6->getType(), $6, $4, $7); CHECK_FOR_ERROR } GlobalVarAttributes { CurGV = 0; } - | OptGlobalAssign GVExternalLinkage GVVisibilityStyle GlobalType Types { + | OptGlobalAssign GVExternalLinkage GVVisibilityStyle ThreadLocal GlobalType + Types OptAddrSpace { if (!UpRefs.empty()) - GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription()); - CurGV = ParseGlobalVariable($1, $2, $3, $4, *$5, 0); + GEN_ERROR("Invalid upreference in type: " + (*$6)->getDescription()); + CurGV = ParseGlobalVariable($1, $2, $3, $5, *$6, 0, $4, $7); CHECK_FOR_ERROR - delete $5; + delete $6; } GlobalVarAttributes { CurGV = 0; CHECK_FOR_ERROR } + | OptGlobalAssign GVVisibilityStyle ALIAS AliasLinkage AliaseeRef { + std::string Name; + if ($1) { + Name = *$1; + delete $1; + } + if (Name.empty()) + GEN_ERROR("Alias name cannot be empty"); + + Constant* Aliasee = $5; + if (Aliasee == 0) + GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name); + + GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), $4, Name, Aliasee, + CurModule.CurrentModule); + GA->setVisibility($2); + InsertValue(GA, CurModule.Values); + + + // If there was a forward reference of this alias, resolve it now. + + ValID ID; + if (!Name.empty()) + ID = ValID::createGlobalName(Name); + else + ID = ValID::createGlobalID(CurModule.Values.size()-1); + + if (GlobalValue *FWGV = + CurModule.GetForwardRefForGlobal(GA->getType(), ID)) { + // Replace uses of the fwdref with the actual alias. + FWGV->replaceAllUsesWith(GA); + if (GlobalVariable *GV = dyn_cast(FWGV)) + GV->eraseFromParent(); + else + cast(FWGV)->eraseFromParent(); + } + ID.destroy(); + + CHECK_FOR_ERROR + } | TARGET TargetDefinition { CHECK_FOR_ERROR } @@ -1956,36 +2161,33 @@ Definition AsmBlock : STRINGCONSTANT { const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); - char *EndStr = UnEscapeLexed($1, true); - std::string NewAsm($1, EndStr); - free($1); - if (AsmSoFar.empty()) - CurModule.CurrentModule->setModuleInlineAsm(NewAsm); + CurModule.CurrentModule->setModuleInlineAsm(*$1); else - CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm); + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*$1); + delete $1; CHECK_FOR_ERROR }; TargetDefinition : TRIPLE '=' STRINGCONSTANT { - CurModule.CurrentModule->setTargetTriple($3); - free($3); + CurModule.CurrentModule->setTargetTriple(*$3); + delete $3; } | DATALAYOUT '=' STRINGCONSTANT { - CurModule.CurrentModule->setDataLayout($3); - free($3); + CurModule.CurrentModule->setDataLayout(*$3); + delete $3; }; LibrariesDefinition : '[' LibList ']'; LibList : LibList ',' STRINGCONSTANT { - CurModule.CurrentModule->addLibrary($3); - free($3); + CurModule.CurrentModule->addLibrary(*$3); + delete $3; CHECK_FOR_ERROR } | STRINGCONSTANT { - CurModule.CurrentModule->addLibrary($1); - free($1); + CurModule.CurrentModule->addLibrary(*$1); + delete $1; CHECK_FOR_ERROR } | /* empty: end of list */ { @@ -2027,7 +2229,7 @@ ArgList : ArgListH { struct ArgListEntry E; E.Ty = new PATypeHolder(Type::VoidTy); E.Name = 0; - E.Attrs = FunctionType::NoAttributeSet; + E.Attrs = ParamAttr::None; $$->push_back(E); CHECK_FOR_ERROR } @@ -2036,7 +2238,7 @@ ArgList : ArgListH { struct ArgListEntry E; E.Ty = new PATypeHolder(Type::VoidTy); E.Name = 0; - E.Attrs = FunctionType::NoAttributeSet; + E.Attrs = ParamAttr::None; $$->push_back(E); CHECK_FOR_ERROR } @@ -2046,10 +2248,9 @@ ArgList : ArgListH { }; FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' - OptFuncAttrs OptSection OptAlign { - UnEscapeLexed($3); - std::string FunctionName($3); - free($3); // Free strdup'd memory! + OptFuncAttrs OptSection OptAlign OptGC { + std::string FunctionName(*$3); + delete $3; // Free strdup'd memory! // Check the function result for abstractness if this is a define. We should // have no abstract types at this point @@ -2057,32 +2258,46 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription()); std::vector ParamTypeList; - std::vector ParamAttrs; - ParamAttrs.push_back($7); + ParamAttrsVector Attrs; + if ($7 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = 0; + PAWI.attrs = $7; + Attrs.push_back(PAWI); + } if ($5) { // If there are arguments... - for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I) { + unsigned index = 1; + for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++index) { const Type* Ty = I->Ty->get(); if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty)) GEN_ERROR("Reference to abstract argument: " + Ty->getDescription()); ParamTypeList.push_back(Ty); if (Ty != Type::VoidTy) - ParamAttrs.push_back(I->Attrs); + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } } } bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; if (isVarArg) ParamTypeList.pop_back(); - FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, - ParamAttrs); - const PointerType *PFT = PointerType::get(FT); + const ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + + FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg); + const PointerType *PFT = PointerType::getUnqual(FT); delete $2; ValID ID; if (!FunctionName.empty()) { ID = ValID::createGlobalName((char*)FunctionName.c_str()); } else { - ID = ValID::createGlobalID(CurModule.Values[PFT].size()); + ID = ValID::createGlobalID(CurModule.Values.size()); } Function *Fn = 0; @@ -2091,6 +2306,7 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' // Move the function to the end of the list, from whereever it was // previously inserted. Fn = cast(FWRef); + assert(!Fn->getParamAttrs() && "Forward reference has parameter attributes!"); CurModule.CurrentModule->getFunctionList().remove(Fn); CurModule.CurrentModule->getFunctionList().push_back(Fn); } else if (!FunctionName.empty() && // Merge with an earlier prototype? @@ -2099,20 +2315,23 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' // The existing function doesn't have the same type. This is an overload // error. GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); + } else if (Fn->getParamAttrs() != PAL) { + // The existing function doesn't have the same parameter attributes. + // This is an overload error. + GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); } else if (!CurFun.isDeclare && !Fn->isDeclaration()) { // Neither the existing or the current function is a declaration and they // have the same name and same type. Clearly this is a redefinition. GEN_ERROR("Redefinition of function '" + FunctionName + "'"); - } if (Fn->isDeclaration()) { + } else if (Fn->isDeclaration()) { // Make sure to strip off any argument names so we can't get conflicts. for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); AI != AE; ++AI) AI->setName(""); } } else { // Not already defined? - Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName, + Fn = new Function(FT, GlobalValue::ExternalWeakLinkage, FunctionName, CurModule.CurrentModule); - InsertValue(Fn, CurModule.Values); } @@ -2126,10 +2345,15 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' Fn->setVisibility(CurFun.Visibility); } Fn->setCallingConv($1); + Fn->setParamAttrs(PAL); Fn->setAlignment($9); if ($8) { - Fn->setSection($8); - free($8); + Fn->setSection(*$8); + delete $8; + } + if ($10) { + Fn->setCollector($10->c_str()); + delete $10; } // Add all of the arguments we parsed to the function... @@ -2146,7 +2370,7 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' for (ArgListType::iterator I = $5->begin(); I != $5->end() && ArgIt != ArgEnd; ++I, ++ArgIt) { delete I->Ty; // Delete the typeholder... - setValueName(ArgIt, I->Name); // Insert arg into symtab... + setValueName(ArgIt, I->Name); // Insert arg into symtab... CHECK_FOR_ERROR InsertValue(ArgIt); Idx++; @@ -2258,13 +2482,9 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant CHECK_FOR_ERROR } | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT { - char *End = UnEscapeLexed($3, true); - std::string AsmStr = std::string($3, End); - End = UnEscapeLexed($5, true); - std::string Constraints = std::string($5, End); - $$ = ValID::createInlineAsm(AsmStr, Constraints, $2); - free($3); - free($5); + $$ = ValID::createInlineAsm(*$3, *$5, $2); + delete $3; + delete $5; CHECK_FOR_ERROR }; @@ -2280,11 +2500,13 @@ SymbolicValueRef : LOCALVAL_ID { // Is it an integer reference...? CHECK_FOR_ERROR } | LocalName { // Is it a named reference...? - $$ = ValID::createLocalName($1); + $$ = ValID::createLocalName(*$1); + delete $1; CHECK_FOR_ERROR } | GlobalName { // Is it a named reference...? - $$ = ValID::createGlobalName($1); + $$ = ValID::createGlobalName(*$1); + delete $1; CHECK_FOR_ERROR }; @@ -2304,6 +2526,16 @@ ResolvedVal : Types ValueRef { } ; +ReturnedVal : ResolvedVal { + $$ = new std::vector(); + $$->push_back($1); + CHECK_FOR_ERROR + } + | ReturnedVal ',' ResolvedVal { + ($$=$1)->push_back($3); + CHECK_FOR_ERROR + }; + BasicBlockList : BasicBlockList BasicBlock { $$ = $1; CHECK_FOR_ERROR @@ -2322,7 +2554,6 @@ BasicBlock : InstructionList OptLocalAssign BBTerminatorInst { CHECK_FOR_ERROR InsertValue($3); $1->getInstList().push_back($3); - InsertValue($1); $$ = $1; CHECK_FOR_ERROR }; @@ -2336,44 +2567,34 @@ InstructionList : InstructionList Inst { $$ = $1; CHECK_FOR_ERROR } - | /* empty */ { - $$ = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true); - CHECK_FOR_ERROR - - // Make sure to move the basic block to the correct location in the - // function, instead of leaving it inserted wherever it was first - // referenced. - Function::BasicBlockListType &BBL = - CurFun.CurrentFunction->getBasicBlockList(); - BBL.splice(BBL.end(), BBL, $$); + | /* empty */ { // Empty space between instruction lists + $$ = defineBBVal(ValID::createLocalID(CurFun.NextValNum)); CHECK_FOR_ERROR } - | LABELSTR { - $$ = getBBVal(ValID::createLocalName($1), true); + | LABELSTR { // Labelled (named) basic block + $$ = defineBBVal(ValID::createLocalName(*$1)); + delete $1; CHECK_FOR_ERROR - // Make sure to move the basic block to the correct location in the - // function, instead of leaving it inserted wherever it was first - // referenced. - Function::BasicBlockListType &BBL = - CurFun.CurrentFunction->getBasicBlockList(); - BBL.splice(BBL.end(), BBL, $$); - CHECK_FOR_ERROR }; -BBTerminatorInst : RET ResolvedVal { // Return with a result... - $$ = new ReturnInst($2); +BBTerminatorInst : + RET ReturnedVal { // Return with a result... + ValueList &VL = *$2; + assert(!VL.empty() && "Invalid ret operands!"); + $$ = new ReturnInst(&VL[0], VL.size()); + delete $2; CHECK_FOR_ERROR } - | RET VOID { // Return with no result... + | RET VOID { // Return with no result... $$ = new ReturnInst(); CHECK_FOR_ERROR } - | BR LABEL ValueRef { // Unconditional Branch... + | BR LABEL ValueRef { // Unconditional Branch... BasicBlock* tmpBB = getBBVal($3); CHECK_FOR_ERROR $$ = new BranchInst(tmpBB); - } // Conditional Branch... + } // Conditional Branch... | BR INTTYPE ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { assert(cast($2)->getBitWidth() == 1 && "Not Bool?"); BasicBlock* tmpBBA = getBBVal($6); @@ -2412,7 +2633,7 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = S; CHECK_FOR_ERROR } - | INVOKE OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' OptFuncAttrs + | INVOKE OptCallingConv ResultTypes ValueRef '(' ParamList ')' OptFuncAttrs TO LABEL ValueRef UNWIND LABEL ValueRef { // Handle the short syntax @@ -2422,20 +2643,19 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - FunctionType::ParamAttrsList ParamAttrs; - ParamAttrs.push_back($8); - for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { + ParamList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - ParamAttrs.push_back(I->Attrs); } - - Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); - PFTy = PointerType::get(Ty); + Ty = FunctionType::get($3->get(), ParamTypes, false); + PFTy = PointerType::getUnqual(Ty); } + delete $3; + Value *V = getVal(PFTy, $4); // Get the function we're calling... CHECK_FOR_ERROR BasicBlock *Normal = getBBVal($11); @@ -2443,6 +2663,12 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... BasicBlock *Except = getBBVal($14); CHECK_FOR_ERROR + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $8; + Attrs.push_back(PAWI); + } + // Check the arguments ValueList Args; if ($6->empty()) { // Has no arguments? @@ -2455,26 +2681,45 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... // correctly! FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); + ParamList::iterator ArgI = $6->begin(), ArgE = $6->end(); + unsigned index = 1; - for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { if (ArgI->Val->getType() != *I) GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + (*I)->getDescription() + "'"); Args.push_back(ArgI->Val); + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } } if (Ty->isVarArg()) { if (I == E) - for (; ArgI != ArgE; ++ArgI) + for (; ArgI != ArgE; ++ArgI, ++index) { Args.push_back(ArgI->Val); // push the remaining varargs + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } + } } else if (I != E || ArgI != ArgE) GEN_ERROR("Invalid number of parameters detected"); } + const ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + // Create the InvokeInst - InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); + InvokeInst *II = new InvokeInst(V, Normal, Except, Args.begin(), Args.end()); II->setCallingConv($2); + II->setParamAttrs(PAL); $$ = II; delete $6; CHECK_FOR_ERROR @@ -2492,7 +2737,7 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { $$ = $1; - Constant *V = cast(getValNonImprovising($2, $3)); + Constant *V = cast(getExistingVal($2, $3)); CHECK_FOR_ERROR if (V == 0) GEN_ERROR("May only switch on a constant pool value"); @@ -2503,7 +2748,7 @@ JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { } | IntType ConstValueRef ',' LABEL ValueRef { $$ = new std::vector >(); - Constant *V = cast(getValNonImprovising($1, $2)); + Constant *V = cast(getExistingVal($1, $2)); CHECK_FOR_ERROR if (V == 0) @@ -2545,23 +2790,43 @@ PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes }; -ValueRefList : Types ValueRef OptParamAttrs { +ParamList : Types OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); // Used for call and invoke instructions - $$ = new ValueRefList(); - ValueRefListEntry E; E.Attrs = $3; E.Val = getVal($1->get(), $2); + $$ = new ParamList(); + ParamListEntry E; E.Attrs = $2 | $4; E.Val = getVal($1->get(), $3); + $$->push_back(E); + delete $1; + CHECK_FOR_ERROR + } + | LABEL OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 + // Labels are only valid in ASMs + $$ = new ParamList(); + ParamListEntry E; E.Attrs = $2 | $4; E.Val = getBBVal($3); $$->push_back(E); + CHECK_FOR_ERROR } - | ValueRefList ',' Types ValueRef OptParamAttrs { + | ParamList ',' Types OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); $$ = $1; - ValueRefListEntry E; E.Attrs = $5; E.Val = getVal($3->get(), $4); + ParamListEntry E; E.Attrs = $4 | $6; E.Val = getVal($3->get(), $5); $$->push_back(E); + delete $3; CHECK_FOR_ERROR } - | /*empty*/ { $$ = new ValueRefList(); }; + | ParamList ',' LABEL OptParamAttrs ValueRef OptParamAttrs { + // FIXME: Remove trailing OptParamAttrs in LLVM 3.0, it was a mistake in 2.0 + $$ = $1; + ParamListEntry E; E.Attrs = $4 | $6; E.Val = getBBVal($5); + $$->push_back(E); + CHECK_FOR_ERROR + } + | /*empty*/ { $$ = new ParamList(); }; IndexList // Used for gep instructions and constant expressions : /*empty*/ { $$ = new std::vector(); } @@ -2588,11 +2853,6 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { !isa((*$2).get())) GEN_ERROR( "Arithmetic operator requires integer, FP, or packed operands"); - if (isa((*$2).get()) && - ($1 == Instruction::URem || - $1 == Instruction::SRem || - $1 == Instruction::FRem)) - GEN_ERROR("Remainder not supported on packed types"); Value* val1 = getVal(*$2, $3); CHECK_FOR_ERROR Value* val2 = getVal(*$2, $5); @@ -2623,7 +2883,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); if (isa((*$3).get())) - GEN_ERROR("Packed types not supported by icmp instruction"); + GEN_ERROR("Vector types not supported by icmp instruction"); Value* tmpVal1 = getVal(*$3, $4); CHECK_FOR_ERROR Value* tmpVal2 = getVal(*$3, $6); @@ -2631,12 +2891,13 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); if ($$ == 0) GEN_ERROR("icmp operator returned null"); + delete $3; } | FCMP FPredicates Types ValueRef ',' ValueRef { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); if (isa((*$3).get())) - GEN_ERROR("Packed types not supported by fcmp instruction"); + GEN_ERROR("Vector types not supported by fcmp instruction"); Value* tmpVal1 = getVal(*$3, $4); CHECK_FOR_ERROR Value* tmpVal2 = getVal(*$3, $6); @@ -2644,6 +2905,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); if ($$ == 0) GEN_ERROR("fcmp operator returned null"); + delete $3; } | CastOps ResolvedVal TO Types { if (!UpRefs.empty()) @@ -2705,7 +2967,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { delete $2; // Free the list... CHECK_FOR_ERROR } - | OptTailCall OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' + | OptTailCall OptCallingConv ResultTypes ValueRef '(' ParamList ')' OptFuncAttrs { // Handle the short syntax @@ -2715,23 +2977,37 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - FunctionType::ParamAttrsList ParamAttrs; - ParamAttrs.push_back($8); - for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { + ParamList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I) { const Type *Ty = I->Val->getType(); if (Ty == Type::VoidTy) GEN_ERROR("Short call syntax cannot be used with varargs"); ParamTypes.push_back(Ty); - ParamAttrs.push_back(I->Attrs); } - - Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); - PFTy = PointerType::get(Ty); + Ty = FunctionType::get($3->get(), ParamTypes, false); + PFTy = PointerType::getUnqual(Ty); } Value *V = getVal(PFTy, $4); // Get the function we're calling... CHECK_FOR_ERROR + // Check for call to invalid intrinsic to avoid crashing later. + if (Function *theF = dyn_cast(V)) { + if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) && + (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) && + !theF->getIntrinsicID(true)) + GEN_ERROR("Call to invalid LLVM intrinsic function '" + + theF->getName() + "'"); + } + + // Set up the ParamAttrs for the function + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = 0; + PAWI.attrs = $8; + Attrs.push_back(PAWI); + } // Check the arguments ValueList Args; if ($6->empty()) { // Has no arguments? @@ -2741,29 +3017,49 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { "expects arguments"); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified - // correctly! - // + // correctly. Also, gather any parameter attributes. FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); + ParamList::iterator ArgI = $6->begin(), ArgE = $6->end(); + unsigned index = 1; - for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { if (ArgI->Val->getType() != *I) GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + (*I)->getDescription() + "'"); Args.push_back(ArgI->Val); + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } } if (Ty->isVarArg()) { if (I == E) - for (; ArgI != ArgE; ++ArgI) + for (; ArgI != ArgE; ++ArgI, ++index) { Args.push_back(ArgI->Val); // push the remaining varargs + if (ArgI->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; + PAWI.index = index; + PAWI.attrs = ArgI->Attrs; + Attrs.push_back(PAWI); + } + } } else if (I != E || ArgI != ArgE) GEN_ERROR("Invalid number of parameters detected"); } + + // Finish off the ParamAttrs and check them + const ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + // Create the call node - CallInst *CI = new CallInst(V, &Args[0], Args.size()); + CallInst *CI = new CallInst(V, Args.begin(), Args.end()); CI->setTailCall($1); CI->setCallingConv($2); + CI->setParamAttrs(PAL); $$ = CI; delete $6; delete $3; @@ -2823,7 +3119,7 @@ MemoryInst : MALLOC Types OptCAlign { CHECK_FOR_ERROR } - | OptVolatile LOAD Types ValueRef { + | OptVolatile LOAD Types ValueRef OptCAlign { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); if (!isa($3->get())) @@ -2834,10 +3130,10 @@ MemoryInst : MALLOC Types OptCAlign { (*$3)->getDescription()); Value* tmpVal = getVal(*$3, $4); CHECK_FOR_ERROR - $$ = new LoadInst(tmpVal, "", $1); + $$ = new LoadInst(tmpVal, "", $1, $5); delete $3; } - | OptVolatile STORE ResolvedVal ',' Types ValueRef { + | OptVolatile STORE ResolvedVal ',' Types ValueRef OptCAlign { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription()); const PointerType *PT = dyn_cast($5->get()); @@ -2851,21 +3147,29 @@ MemoryInst : MALLOC Types OptCAlign { Value* tmpVal = getVal(*$5, $6); CHECK_FOR_ERROR - $$ = new StoreInst($3, tmpVal, $1); + $$ = new StoreInst($3, tmpVal, $1, $7); delete $5; } +| GETRESULT Types SymbolicValueRef ',' EUINT64VAL { + Value *TmpVal = getVal($2->get(), $3); + if (!GetResultInst::isValidOperands(TmpVal, $5)) + GEN_ERROR("Invalid getresult operands"); + $$ = new GetResultInst(TmpVal, $5); + delete $2; + CHECK_FOR_ERROR + } | GETELEMENTPTR Types ValueRef IndexList { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); if (!isa($2->get())) GEN_ERROR("getelementptr insn requires pointer operand"); - if (!GetElementPtrInst::getIndexedType(*$2, &(*$4)[0], $4->size(), true)) + if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end(), true)) GEN_ERROR("Invalid getelementptr indices for type '" + (*$2)->getDescription()+ "'"); Value* tmpVal = getVal(*$2, $3); CHECK_FOR_ERROR - $$ = new GetElementPtrInst(tmpVal, &(*$4)[0], $4->size()); + $$ = new GetElementPtrInst(tmpVal, $4->begin(), $4->end()); delete $2; delete $4; }; @@ -2875,13 +3179,7 @@ MemoryInst : MALLOC Types OptCAlign { // common code from the two 'RunVMAsmParser' functions static Module* RunParser(Module * M) { - - llvmAsmlineno = 1; // Reset the current line number... CurModule.CurrentModule = M; -#if YYDEBUG - yydebug = Debug; -#endif - // Check to make sure the parser succeeded if (yyparse()) { if (ParserResult) @@ -2889,6 +3187,38 @@ static Module* RunParser(Module * M) { return 0; } + // Emit an error if there are any unresolved types left. + if (!CurModule.LateResolveTypes.empty()) { + const ValID &DID = CurModule.LateResolveTypes.begin()->first; + if (DID.Type == ValID::LocalName) { + GenerateError("Undefined type remains at eof: '"+DID.getName() + "'"); + } else { + GenerateError("Undefined type remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + + // Emit an error if there are any unresolved values left. + if (!CurModule.LateResolveValues.empty()) { + Value *V = CurModule.LateResolveValues.back(); + std::map >::iterator I = + CurModule.PlaceHolderInfo.find(V); + + if (I != CurModule.PlaceHolderInfo.end()) { + ValID &DID = I->second.first; + if (DID.Type == ValID::LocalName) { + GenerateError("Undefined value remains at eof: "+DID.getName() + "'"); + } else { + GenerateError("Undefined value remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + } + // Check to make sure that parsing produced a result if (!ParserResult) return 0; @@ -2901,21 +3231,21 @@ static Module* RunParser(Module * M) { } void llvm::GenerateError(const std::string &message, int LineNo) { - if (LineNo == -1) LineNo = llvmAsmlineno; + if (LineNo == -1) LineNo = LLLgetLineNo(); // TODO: column number in exception if (TheParseError) - TheParseError->setError(CurFilename, message, LineNo); + TheParseError->setError(LLLgetFilename(), message, LineNo); TriggerError = 1; } int yyerror(const char *ErrorMsg) { - std::string where - = std::string((CurFilename == "-") ? std::string("") : CurFilename) - + ":" + utostr((unsigned) llvmAsmlineno) + ": "; + std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": "; std::string errMsg = where + "error: " + std::string(ErrorMsg); - if (yychar != YYEMPTY && yychar != 0) - errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+ - "'"; + if (yychar != YYEMPTY && yychar != 0) { + errMsg += " while reading token: '"; + errMsg += std::string(LLLgetTokenStart(), + LLLgetTokenStart()+LLLgetTokenLength()) + "'"; + } GenerateError(errMsg); return 0; }