X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y.cvs;h=2b08d3afa1b845e639967bb89e0810043631bc2c;hb=5c10424842040c7819095406f4430147ac422fba;hp=2842f27f1b8c475d5a71c8e6cc3d13a582e30067;hpb=1dc6969f48a443707bd19517d8c70ea235a0a988;p=oota-llvm.git diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs index 2842f27f1b8..2b08d3afa1b 100644 --- a/lib/AsmParser/llvmAsmParser.y.cvs +++ b/lib/AsmParser/llvmAsmParser.y.cvs @@ -17,15 +17,20 @@ #include "llvm/InlineAsm.h" #include "llvm/Instructions.h" #include "llvm/Module.h" -#include "llvm/SymbolTable.h" -#include "llvm/Assembly/AutoUpgrade.h" +#include "llvm/ValueSymbolTable.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 -#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 @@ -48,6 +53,11 @@ 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; @@ -58,16 +68,13 @@ static Module *ParserResult; // //#define DEBUG_UPREFS 1 #ifdef DEBUG_UPREFS -#define UR_OUT(X) std::cerr << X +#define UR_OUT(X) cerr << X #else #define UR_OUT(X) #endif #define YYERROR_VERBOSE 1 -static bool ObsoleteVarArgs; -static bool NewVarArgs; -static BasicBlock *CurBB; static GlobalVariable *CurGV; @@ -75,14 +82,14 @@ static GlobalVariable *CurGV; // destroyed when the function is completed. // 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; @@ -124,11 +131,6 @@ 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++); - Values.clear(); // Clear out function local definitions Types.clear(); CurrentModule = 0; @@ -148,40 +150,89 @@ static struct PerModuleInfo { } return Ret; } + + bool TypeIsUnresolved(PATypeHolder* PATy) { + // If it isn't abstract, its resolved + const Type* Ty = PATy->get(); + if (!Ty->isAbstract()) + return false; + // Traverse the type looking for abstract types. If it isn't abstract then + // we don't need to traverse that leg of the type. + std::vector WorkList, SeenList; + WorkList.push_back(Ty); + while (!WorkList.empty()) { + const Type* Ty = WorkList.back(); + SeenList.push_back(Ty); + WorkList.pop_back(); + if (const OpaqueType* OpTy = dyn_cast(Ty)) { + // Check to see if this is an unresolved type + std::map::iterator I = LateResolveTypes.begin(); + std::map::iterator E = LateResolveTypes.end(); + for ( ; I != E; ++I) { + if (I->second.get() == OpTy) + return true; + } + } else if (const SequentialType* SeqTy = dyn_cast(Ty)) { + const Type* TheTy = SeqTy->getElementType(); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } else if (const StructType* StrTy = dyn_cast(Ty)) { + for (unsigned i = 0; i < StrTy->getNumElements(); ++i) { + const Type* TheTy = StrTy->getElementType(i); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } + } + } + 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; - bool isDeclare; // Is this function a forward declararation? + 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; isDeclare = false; - Linkage = GlobalValue::ExternalLinkage; + Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; } 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; } @@ -189,9 +240,11 @@ static struct PerFunctionInfo { ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); Values.clear(); // Clear out function local definitions + BBForwardRefs.clear(); CurrentFunction = 0; isDeclare = false; Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; } } CurFun; // Info for the current function... @@ -202,31 +255,40 @@ 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? - - // Yes, insert the value into the value table... - ValueList &List = ValueTab[V->getType()]; - List.push_back(V); - return List.size()-1; +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; + + // 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) { switch (D.Type) { - case ValID::NumberVal: // Is it a numbered definition? + case ValID::LocalID: // Is it a numbered definition? // Module constants occupy the lowest numbered slots... - if ((unsigned)D.Num < CurModule.Types.size()) - return CurModule.Types[(unsigned)D.Num]; + if (D.Num < CurModule.Types.size()) + return CurModule.Types[D.Num]; break; - case ValID::NameVal: // Is it a named definition? + case ValID::LocalName: // Is it a named definition? if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { D.destroy(); // Free old strdup'd memory... return N; } break; default: - GenerateError("Internal parser error: Invalid symbol type reference!"); + GenerateError("Internal parser error: Invalid symbol type reference"); return 0; } @@ -238,11 +300,11 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { if (inFunctionScope()) { - if (D.Type == ValID::NameVal) { + if (D.Type == ValID::LocalName) { GenerateError("Reference to an undefined type: '" + D.getName() + "'"); return 0; } else { - GenerateError("Reference to an undefined type: #" + itostr(D.Num)); + GenerateError("Reference to an undefined type: #" + utostr(D.Num)); return 0; } } @@ -256,18 +318,11 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { return Typ; } -static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { - SymbolTable &SymTab = - inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); - return SymTab.lookup(Ty, Name); -} - -// 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"); @@ -275,30 +330,52 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { } switch (D.Type) { - case ValID::NumberVal: { // Is it a numbered definition? - unsigned Num = (unsigned)D.Num; - - // Module constants occupy the lowest numbered slots... - std::map::iterator VI = CurModule.Values.find(Ty); - if (VI != CurModule.Values.end()) { - if (Num < VI->second.size()) - return VI->second[Num]; - Num -= VI->second.size(); + case ValID::LocalID: { // Is it a numbered definition? + // Check that the number is within bounds. + 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; } - - // Make sure that our type is within bounds - VI = CurFun.Values.find(Ty); - if (VI == CurFun.Values.end()) return 0; - - // Check that the number is within bounds... - if (VI->second.size() <= Num) return 0; - - return VI->second[Num]; + return Result; } - - case ValID::NameVal: { // Is it a named definition? - Value *N = lookupInSymbolTable(Ty, std::string(D.Name)); - if (N == 0) return 0; + case ValID::GlobalID: { // Is it a numbered definition? + if (D.Num >= CurModule.Values.size()) + return 0; + 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 Result; + } + + case ValID::LocalName: { // Is it a named definition? + if (!inFunctionScope()) + return 0; + ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); + Value *N = SymTab.lookup(D.Name); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; + + D.destroy(); // Free old strdup'd memory... + return N; + } + case ValID::GlobalName: { // Is it a named definition? + ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable(); + Value *N = SymTab.lookup(D.Name); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; D.destroy(); // Free old strdup'd memory... return N; @@ -307,37 +384,37 @@ 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 (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64)) { + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { GenerateError("Signed integral constant '" + itostr(D.ConstPool64) + "' is invalid for type '" + - Ty->getDescription() + "'!"); + Ty->getDescription() + "'"); return 0; } - return ConstantSInt::get(Ty, D.ConstPool64); + return ConstantInt::get(Ty, D.ConstPool64, true); case ValID::ConstUIntVal: // Is it an unsigned const pool reference? - if (!ConstantUInt::isValueValidForType(Ty, D.UConstPool64)) { - if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64)) { + if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) { + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { GenerateError("Integral constant '" + utostr(D.UConstPool64) + - "' is invalid or out of range!"); + "' is invalid or out of range"); return 0; } else { // This is really a signed reference. Transmogrify. - return ConstantSInt::get(Ty, D.ConstPool64); + return ConstantInt::get(Ty, D.ConstPool64, true); } } else { - return ConstantUInt::get(Ty, D.UConstPool64); + return ConstantInt::get(Ty, D.UConstPool64); } case ValID::ConstFPVal: // Is it a floating point const pool reference? if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { - GenerateError("FP constant invalid for type!!"); + GenerateError("FP constant invalid for type"); return 0; } return ConstantFP::get(Ty, D.ConstPoolFP); case ValID::ConstNullVal: // Is it a null value? if (!isa(Ty)) { - GenerateError("Cannot create a a non pointer null!"); + GenerateError("Cannot create a a non pointer null"); return 0; } return ConstantPointerNull::get(cast(Ty)); @@ -350,7 +427,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { case ValID::ConstantVal: // Fully resolved constant? if (D.ConstantValue->getType() != Ty) { - GenerateError("Constant expression type different from required type!"); + GenerateError("Constant expression type different from required type"); return 0; } return D.ConstantValue; @@ -360,7 +437,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { const FunctionType *FTy = PTy ? dyn_cast(PTy->getElementType()) : 0; if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) { - GenerateError("Invalid type for asm constraint string!"); + GenerateError("Invalid type for asm constraint string"); return 0; } InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints, @@ -377,7 +454,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 @@ -390,12 +467,12 @@ 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; if (!Ty->isFirstClassType() && !isa(Ty)) { - GenerateError("Invalid use of a composite type!"); + GenerateError("Invalid use of a composite type"); return 0; } @@ -417,69 +494,104 @@ 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::NumberVal: // Is it a numbered definition? - if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size()) - CurFun.NumberedBlocks.resize(ID.Num+1); - BB = CurFun.NumberedBlocks[ID.Num]; - break; - case ValID::NameVal: // Is it a named definition? - Name = ID.Name; - if (Value *N = CurFun.CurrentFunction-> - getSymbolTable().lookup(Type::LabelTy, Name)) - 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.Name : ""); + 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::NameVal) { - 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.Name; + 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.Name; + BB = new BasicBlock(Name, CurFun.CurrentFunction); + + // Insert it in the forward refs map. + CurFun.BBForwardRefs[ID] = BB; + return BB; } @@ -501,50 +613,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::NameVal) { - 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(); } @@ -554,8 +660,8 @@ ResolveDefinitions(std::map &LateResolvers, // static void ResolveTypeTo(char *Name, const Type *ToTy) { ValID D; - if (Name) D = ValID::create(Name); - else D = ValID::create((int)CurModule.Types.size()); + if (Name) D = ValID::createLocalName(Name); + else D = ValID::createLocalID(CurModule.Types.size()); std::map::iterator I = CurModule.LateResolveTypes.find(D); @@ -570,36 +676,37 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) { // assumed to be a malloc'd string buffer, and is free'd by this function. // static void setValueName(Value *V, char *NameStr) { - if (NameStr) { - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string - - if (V->getType() == Type::VoidTy) { - GenerateError("Can't assign name '" + Name+"' to value with void type!"); - return; - } + if (!NameStr) return; + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string - assert(inFunctionScope() && "Must be in function scope!"); - SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); - if (ST.lookup(V->getType(), Name)) { - GenerateError("Redefinition of value named '" + Name + "' in the '" + - V->getType()->getDescription() + "' type plane!"); - return; - } + if (V->getType() == Type::VoidTy) { + GenerateError("Can't assign name '" + Name+"' to value with void type"); + return; + } - // Set the name. - V->setName(Name); + assert(inFunctionScope() && "Must be in function scope!"); + ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); + if (ST.lookup(Name)) { + GenerateError("Redefinition of value '" + Name + "' of type '" + + V->getType()->getDescription() + "'"); + return; } + + // Set the name. + V->setName(Name); } /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, /// this is a declaration, otherwise it is a definition. static GlobalVariable * -ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, +ParseGlobalVariable(char *NameStr, + GlobalValue::LinkageTypes Linkage, + GlobalValue::VisibilityTypes Visibility, bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { + Constant *Initializer, bool IsThreadLocal) { if (isa(Ty)) { - GenerateError("Cannot declare global vars of function type!"); + GenerateError("Cannot declare global vars of function type"); return 0; } @@ -615,9 +722,9 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, // object. ValID ID; if (!Name.empty()) { - ID = ValID::create((char*)Name.c_str()); + ID = ValID::createGlobalName((char*)Name.c_str()); } else { - ID = ValID::create((int)CurModule.Values[PTy].size()); + ID = ValID::createGlobalID(CurModule.Values.size()); } if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { @@ -628,46 +735,35 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, CurModule.CurrentModule->getGlobalList().push_back(GV); GV->setInitializer(Initializer); GV->setLinkage(Linkage); + GV->setVisibility(Visibility); GV->setConstant(isConstantGlobal); + GV->setThreadLocal(IsThreadLocal); InsertValue(GV, CurModule.Values); return GV; } - // If this global has a name, check to see if there is already a definition - // of this global in the module. If so, merge as appropriate. Note that - // this is really just a hack around problems in the CFE. :( + // If this global has a name if (!Name.empty()) { - // We are a simple redefinition of a value, check to see if it is defined - // the same as the old one. - if (GlobalVariable *EGV = - CurModule.CurrentModule->getGlobalVariable(Name, Ty)) { - // We are allowed to redefine a global variable in two circumstances: - // 1. If at least one of the globals is uninitialized or - // 2. If both initializers have the same value. - // - if (!EGV->hasInitializer() || !Initializer || - EGV->getInitializer() == Initializer) { - - // Make sure the existing global version gets the initializer! Make - // sure that it also gets marked const if the new version is. - if (Initializer && !EGV->hasInitializer()) - EGV->setInitializer(Initializer); - if (isConstantGlobal) - EGV->setConstant(true); - EGV->setLinkage(Linkage); - return EGV; + // if the global we're parsing has an initializer (is a definition) and + // has external linkage. + if (Initializer && Linkage != GlobalValue::InternalLinkage) + // If there is already a global with external linkage with this name + if (CurModule.CurrentModule->getGlobalVariable(Name, false)) { + // If we allow this GVar to get created, it will be renamed in the + // symbol table because it conflicts with an existing GVar. We can't + // allow redefinition of GVars whose linking indicates that their name + // must stay the same. Issue the error. + GenerateError("Redefinition of global variable named '" + Name + + "' of type '" + Ty->getDescription() + "'"); + return 0; } - - GenerateError("Redefinition of global variable named '" + Name + - "' in the '" + Ty->getDescription() + "' type plane!"); - return 0; - } } // 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); + GV->setVisibility(Visibility); InsertValue(GV, CurModule.Values); return GV; } @@ -688,7 +784,7 @@ static bool setTypeName(const Type *T, char *NameStr) { // We don't allow assigning names to void type if (T == Type::VoidTy) { - GenerateError("Can't assign name '" + Name + "' to the void type!"); + GenerateError("Can't assign name '" + Name + "' to the void type"); return false; } @@ -697,7 +793,7 @@ static bool setTypeName(const Type *T, char *NameStr) { if (AlreadyExists) { // Inserting a name that is already defined??? const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); - assert(Existing && "Conflict but no matching type?"); + assert(Existing && "Conflict but no matching type?!"); // There is only one case where this is allowed: when we are refining an // opaque type. In this case, Existing will be an opaque type. @@ -714,8 +810,8 @@ static bool setTypeName(const Type *T, char *NameStr) { if (Existing == T) return true; // Yes, it's equal. // Any other kind of (non-equivalent) redefinition is an error. - GenerateError("Redefinition of type named '" + Name + "' in the '" + - T->getDescription() + "' type plane!"); + GenerateError("Redefinition of type named '" + Name + "' of type '" + + T->getDescription() + "'"); } return false; @@ -813,144 +909,12 @@ static PATypeHolder HandleUpRefs(const Type *ty) { return Ty; } - -// common code from the two 'RunVMAsmParser' functions -static Module* RunParser(Module * M) { - - llvmAsmlineno = 1; // Reset the current line number... - ObsoleteVarArgs = false; - NewVarArgs = false; - CurModule.CurrentModule = M; - - // Check to make sure the parser succeeded - if (yyparse()) { - if (ParserResult) - delete ParserResult; - return 0; - } - - // Check to make sure that parsing produced a result - if (!ParserResult) - return 0; - - // Reset ParserResult variable while saving its value for the result. - Module *Result = ParserResult; - ParserResult = 0; - - //Not all functions use vaarg, so make a second check for ObsoleteVarArgs - { - Function* F; - if ((F = Result->getNamedFunction("llvm.va_start")) - && F->getFunctionType()->getNumParams() == 0) - ObsoleteVarArgs = true; - if((F = Result->getNamedFunction("llvm.va_copy")) - && F->getFunctionType()->getNumParams() == 1) - ObsoleteVarArgs = true; - } - - if (ObsoleteVarArgs && NewVarArgs) { - GenerateError( - "This file is corrupt: it uses both new and old style varargs"); - return 0; - } - - if(ObsoleteVarArgs) { - if(Function* F = Result->getNamedFunction("llvm.va_start")) { - if (F->arg_size() != 0) { - GenerateError("Obsolete va_start takes 0 argument!"); - return 0; - } - - //foo = va_start() - // -> - //bar = alloca typeof(foo) - //va_start(bar) - //foo = load bar - - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getReturnType(); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_start", - RetTy, ArgTyPtr, (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast(F->use_back()); - AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI); - new CallInst(NF, bar, "", CI); - Value* foo = new LoadInst(bar, "vastart.fix.2", CI); - CI->replaceAllUsesWith(foo); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - - if(Function* F = Result->getNamedFunction("llvm.va_end")) { - if(F->arg_size() != 1) { - GenerateError("Obsolete va_end takes 1 argument!"); - return 0; - } - - //vaend foo - // -> - //bar = alloca 1 of typeof(foo) - //vaend bar - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getParamType(0); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_end", - RetTy, ArgTyPtr, (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast(F->use_back()); - AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI); - new StoreInst(CI->getOperand(1), bar, CI); - new CallInst(NF, bar, "", CI); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - - if(Function* F = Result->getNamedFunction("llvm.va_copy")) { - if(F->arg_size() != 1) { - GenerateError("Obsolete va_copy takes 1 argument!"); - return 0; - } - //foo = vacopy(bar) - // -> - //a = alloca 1 of typeof(foo) - //b = alloca 1 of typeof(foo) - //store bar -> b - //vacopy(a, b) - //foo = load a - - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getReturnType(); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_copy", - RetTy, ArgTyPtr, ArgTyPtr, - (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast(F->use_back()); - AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI); - AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI); - new StoreInst(CI->getOperand(1), b, CI); - new CallInst(NF, a, b, "", CI); - Value* foo = new LoadInst(a, "vacopy.fix.3", CI); - CI->replaceAllUsesWith(foo); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - } - - return Result; -} - //===----------------------------------------------------------------------===// // RunVMAsmParser - Define an interface to this parser //===----------------------------------------------------------------------===// // +static Module* RunParser(Module * M); + Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { set_scan_file(F); @@ -974,19 +938,21 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { %union { llvm::Module *ModuleVal; llvm::Function *FunctionVal; - std::pair *ArgVal; llvm::BasicBlock *BasicBlockVal; llvm::TerminatorInst *TermInstVal; llvm::Instruction *InstVal; llvm::Constant *ConstVal; const llvm::Type *PrimType; + std::list *TypeList; llvm::PATypeHolder *TypeVal; llvm::Value *ValueVal; - - std::vector > *ArgList; std::vector *ValueList; - std::list *TypeList; + llvm::ArgListType *ArgList; + llvm::TypeWithAttrs TypeWithAttrs; + llvm::TypeWithAttrsList *TypeWithAttrsList; + llvm::ValueRefList *ValueRefList; + // Represent the RHS of PHI node std::list > *PHIList; @@ -994,6 +960,9 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { std::vector *ConstVector; llvm::GlobalValue::LinkageTypes Linkage; + llvm::GlobalValue::VisibilityTypes Visibility; + uint16_t ParamAttrs; + llvm::APInt *APIntVal; int64_t SInt64Val; uint64_t UInt64Val; int SIntVal; @@ -1002,16 +971,18 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { bool BoolVal; char *StrVal; // This memory is strdup'd! - llvm::ValID ValIDVal; // strdup'd memory maybe! - - llvm::Instruction::BinaryOps BinaryOpVal; - llvm::Instruction::TermOps TermOpVal; - llvm::Instruction::MemoryOps MemOpVal; - llvm::Instruction::OtherOps OtherOpVal; - llvm::Module::Endianness Endianness; + llvm::ValID ValIDVal; // strdup'd memory maybe! + + llvm::Instruction::BinaryOps BinaryOpVal; + llvm::Instruction::TermOps TermOpVal; + llvm::Instruction::MemoryOps MemOpVal; + llvm::Instruction::CastOps CastOpVal; + llvm::Instruction::OtherOps OtherOpVal; + llvm::ICmpInst::Predicate IPredicate; + llvm::FCmpInst::Predicate FPredicate; } -%type Module FunctionList +%type Module %type Function FunctionProto FunctionHeader BasicBlockList %type BasicBlock InstructionList %type BBTerminatorInst @@ -1019,18 +990,21 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { %type ConstVal ConstExpr %type ConstVector %type ArgList ArgListH -%type ArgVal %type PHIList -%type ValueRefList ValueRefListE // For call param lists -%type IndexList // For GEP derived indices -%type TypeListI ArgTypeListI +%type ValueRefList // 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 OptLinkage -%type BigOrLittle +%type GVInternalLinkage GVExternalLinkage +%type FunctionDefineLinkage FunctionDeclareLinkage +%type GVVisibilityStyle // ValueRef - Unresolved reference to a definition or BB %type ValueRef ConstValueRef SymbolicValueRef @@ -1042,93 +1016,116 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { // EUINT64VAL - A positive number within uns. long long range %token EUINT64VAL -%type EINT64VAL -%token SINTVAL // Signed 32 bit ints... -%token UINTVAL // Unsigned 32 bit ints... -%type INTVAL +// 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 // Built in types... -%type Types TypesV UpRTypes UpRTypesV -%type SIntType UIntType IntType FPType PrimType // Classifications -%token VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG -%token FLOAT DOUBLE TYPE LABEL - -%token VAR_ID LABELSTR STRINGCONSTANT -%type Name OptName OptAssign -%type OptAlign OptCAlign +%type Types ResultTypes +%type IntType FPType PrimType // Classifications +%token VOID INTTYPE +%token FLOAT DOUBLE LABEL +%token TYPE + +%token LOCALVAR GLOBALVAR LABELSTR STRINGCONSTANT ATSTRINGCONSTANT +%type LocalName OptLocalName OptLocalAssign +%type GlobalName OptGlobalAssign +%type OptAlign OptCAlign %type OptSection SectionString -%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK -%token DECLARE GLOBAL CONSTANT SECTION VOLATILE -%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING +%token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK +%token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE THREAD_LOCAL +%token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING %token DLLIMPORT DLLEXPORT EXTERN_WEAK -%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN +%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN %token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT -%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK -%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK -%token DATA +%token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK X86_STDCALLCC_TOK X86_FASTCALLCC_TOK +%token DATALAYOUT %type OptCallingConv +%type OptParamAttrs ParamAttr +%type OptFuncAttrs FuncAttr // Basic Block Terminating Operators %token RET BR SWITCH INVOKE UNWIND UNREACHABLE // Binary Operators -%type ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories -%token ADD SUB MUL DIV REM AND OR XOR -%token SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comarators +%type ArithmeticOps LogicalOps // Binops Subcatagories +%token ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR +%token SHL LSHR ASHR + +%token ICMP FCMP +%type IPredicates +%type FPredicates +%token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE +%token OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE // Memory Instructions %token MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR +// Cast Operators +%type CastOps +%token TRUNC ZEXT SEXT FPTRUNC FPEXT BITCAST +%token UITOFP SITOFP FPTOUI FPTOSI INTTOPTR PTRTOINT + // Other Operators -%type ShiftOps -%token PHI_TOK CAST SELECT SHL SHR VAARG +%token PHI_TOK SELECT VAARG %token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR -%token VAARG_old VANEXT_old //OBSOLETE +// Function Attributes +%token NORETURN INREG SRET NOUNWIND + +// Visibility Styles +%token DEFAULT HIDDEN %start Module %% -// Handle constant integer size restriction and conversion... -// -INTVAL : SINTVAL; -INTVAL : UINTVAL { - if ($1 > (uint32_t)INT32_MAX) // Outside of my range! - GEN_ERROR("Value too large for type!"); - $$ = (int32_t)$1; - CHECK_FOR_ERROR -}; - - -EINT64VAL : ESINT64VAL; // These have same type and can't cause problems... -EINT64VAL : EUINT64VAL { - if ($1 > (uint64_t)INT64_MAX) // Outside of my range! - GEN_ERROR("Value too large for type!"); - $$ = (int64_t)$1; - CHECK_FOR_ERROR -}; // Operations that are notably excluded from this list include: // RET, BR, & SWITCH because they end basic blocks and are treated specially. // -ArithmeticOps: ADD | SUB | MUL | DIV | REM; -LogicalOps : AND | OR | XOR; -SetCondOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE; - -ShiftOps : SHL | SHR; +ArithmeticOps: ADD | SUB | MUL | UDIV | SDIV | FDIV | UREM | SREM | FREM; +LogicalOps : SHL | LSHR | ASHR | AND | OR | XOR; +CastOps : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | BITCAST | + UITOFP | SITOFP | FPTOUI | FPTOSI | INTTOPTR | PTRTOINT; + +IPredicates + : EQ { $$ = ICmpInst::ICMP_EQ; } | NE { $$ = ICmpInst::ICMP_NE; } + | SLT { $$ = ICmpInst::ICMP_SLT; } | SGT { $$ = ICmpInst::ICMP_SGT; } + | SLE { $$ = ICmpInst::ICMP_SLE; } | SGE { $$ = ICmpInst::ICMP_SGE; } + | ULT { $$ = ICmpInst::ICMP_ULT; } | UGT { $$ = ICmpInst::ICMP_UGT; } + | ULE { $$ = ICmpInst::ICMP_ULE; } | UGE { $$ = ICmpInst::ICMP_UGE; } + ; + +FPredicates + : OEQ { $$ = FCmpInst::FCMP_OEQ; } | ONE { $$ = FCmpInst::FCMP_ONE; } + | OLT { $$ = FCmpInst::FCMP_OLT; } | OGT { $$ = FCmpInst::FCMP_OGT; } + | OLE { $$ = FCmpInst::FCMP_OLE; } | OGE { $$ = FCmpInst::FCMP_OGE; } + | ORD { $$ = FCmpInst::FCMP_ORD; } | UNO { $$ = FCmpInst::FCMP_UNO; } + | UEQ { $$ = FCmpInst::FCMP_UEQ; } | UNE { $$ = FCmpInst::FCMP_UNE; } + | ULT { $$ = FCmpInst::FCMP_ULT; } | UGT { $$ = FCmpInst::FCMP_UGT; } + | ULE { $$ = FCmpInst::FCMP_ULE; } | UGE { $$ = FCmpInst::FCMP_UGE; } + | TRUETOK { $$ = FCmpInst::FCMP_TRUE; } + | FALSETOK { $$ = FCmpInst::FCMP_FALSE; } + ; // These are some types that allow classification if we only want a particular // thing... for example, only a signed, unsigned, or integral type. -SIntType : LONG | INT | SHORT | SBYTE; -UIntType : ULONG | UINT | USHORT | UBYTE; -IntType : SIntType | UIntType; +IntType : INTTYPE; FPType : FLOAT | DOUBLE; -// OptAssign - Value producing statements have an optional assignment component -OptAssign : Name '=' { +LocalName : LOCALVAR | STRINGCONSTANT; +OptLocalName : LocalName | /*empty*/ { $$ = 0; }; + +/// OptLocalAssign - Value producing statements have an optional assignment +/// component. +OptLocalAssign : LocalName '=' { $$ = $1; CHECK_FOR_ERROR } @@ -1137,43 +1134,100 @@ OptAssign : Name '=' { CHECK_FOR_ERROR }; -OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | - LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } | - WEAK { $$ = GlobalValue::WeakLinkage; } | - APPENDING { $$ = GlobalValue::AppendingLinkage; } | - DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; } | - DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; } | - EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } | - /*empty*/ { $$ = GlobalValue::ExternalLinkage; }; +GlobalName : GLOBALVAR | ATSTRINGCONSTANT; + +OptGlobalAssign : GlobalName '=' { + $$ = $1; + CHECK_FOR_ERROR + } + | /*empty*/ { + $$ = 0; + CHECK_FOR_ERROR + }; + +GVInternalLinkage + : INTERNAL { $$ = GlobalValue::InternalLinkage; } + | WEAK { $$ = GlobalValue::WeakLinkage; } + | LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } + | APPENDING { $$ = GlobalValue::AppendingLinkage; } + | DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; } + ; + +GVExternalLinkage + : DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; } + | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } + | EXTERNAL { $$ = GlobalValue::ExternalLinkage; } + ; + +GVVisibilityStyle + : /*empty*/ { $$ = GlobalValue::DefaultVisibility; } + | HIDDEN { $$ = GlobalValue::HiddenVisibility; } + ; + +FunctionDeclareLinkage + : /*empty*/ { $$ = GlobalValue::ExternalLinkage; } + | DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; } + | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } + ; + +FunctionDefineLinkage + : /*empty*/ { $$ = GlobalValue::ExternalLinkage; } + | INTERNAL { $$ = GlobalValue::InternalLinkage; } + | LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } + | WEAK { $$ = GlobalValue::WeakLinkage; } + | DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; } + ; OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CCC_TOK { $$ = CallingConv::C; } | - CSRETCC_TOK { $$ = CallingConv::CSRet; } | FASTCC_TOK { $$ = CallingConv::Fast; } | COLDCC_TOK { $$ = CallingConv::Cold; } | X86_STDCALLCC_TOK { $$ = CallingConv::X86_StdCall; } | X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } | CC_TOK EUINT64VAL { if ((unsigned)$2 != $2) - GEN_ERROR("Calling conv too large!"); + GEN_ERROR("Calling conv too large"); $$ = $2; CHECK_FOR_ERROR }; +ParamAttr : ZEXT { $$ = ParamAttr::ZExt; } + | SEXT { $$ = ParamAttr::SExt; } + | INREG { $$ = ParamAttr::InReg; } + | SRET { $$ = ParamAttr::StructRet; } + ; + +OptParamAttrs : /* empty */ { $$ = ParamAttr::None; } + | OptParamAttrs ParamAttr { + $$ = $1 | $2; + } + ; + +FuncAttr : NORETURN { $$ = ParamAttr::NoReturn; } + | NOUNWIND { $$ = ParamAttr::NoUnwind; } + | ParamAttr + ; + +OptFuncAttrs : /* empty */ { $$ = ParamAttr::None; } + | OptFuncAttrs FuncAttr { + $$ = $1 | $2; + } + ; + // OptAlign/OptCAlign - An optional alignment, and an optional alignment with // a comma before it. OptAlign : /*empty*/ { $$ = 0; } | ALIGN EUINT64VAL { $$ = $2; if ($$ != 0 && !isPowerOf2_32($$)) - GEN_ERROR("Alignment must be a power of two!"); + GEN_ERROR("Alignment must be a power of two"); CHECK_FOR_ERROR }; OptCAlign : /*empty*/ { $$ = 0; } | ',' ALIGN EUINT64VAL { $$ = $3; if ($$ != 0 && !isPowerOf2_32($$)) - GEN_ERROR("Alignment must be a power of two!"); + GEN_ERROR("Alignment must be a power of two"); CHECK_FOR_ERROR }; @@ -1181,7 +1235,7 @@ OptCAlign : /*empty*/ { $$ = 0; } | SectionString : SECTION STRINGCONSTANT { for (unsigned i = 0, e = strlen($2); i != e; ++i) if ($2[i] == '"' || $2[i] == '\\') - GEN_ERROR("Invalid character in section name!"); + GEN_ERROR("Invalid character in section name"); $$ = $2; CHECK_FOR_ERROR }; @@ -1201,84 +1255,123 @@ GlobalVarAttribute : SectionString { } | ALIGN EUINT64VAL { if ($2 != 0 && !isPowerOf2_32($2)) - GEN_ERROR("Alignment must be a power of two!"); + GEN_ERROR("Alignment must be a power of two"); CurGV->setAlignment($2); CHECK_FOR_ERROR }; //===----------------------------------------------------------------------===// // Types includes all predefined types... except void, because it can only be -// used in specific contexts (function returning void for example). To have -// access to it, a user must explicitly use TypesV. -// - -// TypesV includes all of 'Types', but it also includes the void type. -TypesV : Types | VOID { $$ = new PATypeHolder($1); }; -UpRTypesV : UpRTypes | VOID { $$ = new PATypeHolder($1); }; - -Types : UpRTypes { - if (!UpRefs.empty()) - GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); - $$ = $1; - CHECK_FOR_ERROR - }; - +// used in specific contexts (function returning void for example). // Derived types are added later... // -PrimType : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT ; -PrimType : LONG | ULONG | FLOAT | DOUBLE | TYPE | LABEL; -UpRTypes : OPAQUE { +PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ; + +Types + : OPAQUE { $$ = new PATypeHolder(OpaqueType::get()); CHECK_FOR_ERROR } | PrimType { $$ = new PATypeHolder($1); CHECK_FOR_ERROR - }; -UpRTypes : SymbolicValueRef { // Named types are also simple types... - const Type* tmp = getTypeVal($1); - CHECK_FOR_ERROR - $$ = new PATypeHolder(tmp); -}; - -// Include derived types in the Types production. -// -UpRTypes : '\\' EUINT64VAL { // Type UpReference - if ($2 > (uint64_t)~0U) GEN_ERROR("Value out of range!"); + } + | Types '*' { // Pointer type? + if (*$1 == Type::LabelTy) + GEN_ERROR("Cannot form a pointer to a basic block"); + $$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1))); + delete $1; + CHECK_FOR_ERROR + } + | SymbolicValueRef { // Named types are also simple types... + const Type* tmp = getTypeVal($1); + CHECK_FOR_ERROR + $$ = new PATypeHolder(tmp); + } + | '\\' EUINT64VAL { // Type UpReference + if ($2 > (uint64_t)~0U) GEN_ERROR("Value out of range"); OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder UpRefs.push_back(UpRefRecord((unsigned)$2, OT)); // Add to vector... $$ = new PATypeHolder(OT); UR_OUT("New Upreference!\n"); CHECK_FOR_ERROR } - | UpRTypesV '(' ArgTypeListI ')' { // Function derived type? + | Types '(' ArgTypeListI ')' OptFuncAttrs { std::vector Params; - for (std::list::iterator I = $3->begin(), - E = $3->end(); I != E; ++I) - Params.push_back(*I); + ParamAttrsVector Attrs; + if ($5 != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = 0; X.attrs = $5; + Attrs.push_back(X); + } + unsigned index = 1; + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + for (; I != E; ++I, ++index) { + const Type *Ty = I->Ty->get(); + Params.push_back(Ty); + if (Ty != Type::VoidTy) + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; + Attrs.push_back(X); + } + } bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - $$ = new PATypeHolder(HandleUpRefs(FunctionType::get(*$1,Params,isVarArg))); + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = ParamAttrsList::get(Attrs); + FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, ActualAttrs); + delete $3; // Delete the argument list + delete $1; // Delete the return type handle + $$ = new PATypeHolder(HandleUpRefs(FT)); + CHECK_FOR_ERROR + } + | VOID '(' ArgTypeListI ')' OptFuncAttrs { + std::vector Params; + ParamAttrsVector Attrs; + if ($5 != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = 0; X.attrs = $5; + Attrs.push_back(X); + } + TypeWithAttrsList::iterator I = $3->begin(), E = $3->end(); + unsigned index = 1; + for ( ; I != E; ++I, ++index) { + const Type* Ty = I->Ty->get(); + Params.push_back(Ty); + if (Ty != Type::VoidTy) + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; + Attrs.push_back(X); + } + } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = ParamAttrsList::get(Attrs); + + FunctionType *FT = FunctionType::get($1, Params, isVarArg, ActualAttrs); delete $3; // Delete the argument list - delete $1; // Delete the return type handle + $$ = new PATypeHolder(HandleUpRefs(FT)); CHECK_FOR_ERROR } - | '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type? + + | '[' EUINT64VAL 'x' Types ']' { // Sized array type? $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2))); delete $4; CHECK_FOR_ERROR } - | '<' EUINT64VAL 'x' UpRTypes '>' { // 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->isPrimitiveType()) - GEN_ERROR("Elemental type of a PackedType must be primitive"); + 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(PackedType::get(*$4, (unsigned)$2))); + GEN_ERROR("Vector length should be a power of 2"); + $$ = new PATypeHolder(HandleUpRefs(VectorType::get(*$4, (unsigned)$2))); delete $4; CHECK_FOR_ERROR } @@ -1296,39 +1389,86 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference $$ = new PATypeHolder(StructType::get(std::vector())); CHECK_FOR_ERROR } - | UpRTypes '*' { // Pointer type? - if (*$1 == Type::LabelTy) - GEN_ERROR("Cannot form a pointer to a basic block"); - $$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1))); - delete $1; + | '<' '{' TypeListI '}' '>' { + std::vector Elements; + for (std::list::iterator I = $3->begin(), + E = $3->end(); I != E; ++I) + Elements.push_back(*I); + + $$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true))); + delete $3; CHECK_FOR_ERROR - }; + } + | '<' '{' '}' '>' { // Empty structure type? + $$ = new PATypeHolder(StructType::get(std::vector(), true)); + CHECK_FOR_ERROR + } + ; -// TypeList - Used for struct declarations and as a basis for function type -// declaration type lists -// -TypeListI : UpRTypes { - $$ = new std::list(); - $$->push_back(*$1); delete $1; +ArgType + : Types OptParamAttrs { + $$.Ty = $1; + $$.Attrs = $2; + } + ; + +ResultTypes + : Types { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); + if (!(*$1)->isFirstClassType()) + GEN_ERROR("LLVM functions cannot return aggregate types"); + $$ = $1; + } + | VOID { + $$ = new PATypeHolder(Type::VoidTy); + } + ; + +ArgTypeList : ArgType { + $$ = new TypeWithAttrsList(); + $$->push_back($1); CHECK_FOR_ERROR } - | TypeListI ',' UpRTypes { - ($$=$1)->push_back(*$3); delete $3; + | ArgTypeList ',' ArgType { + ($$=$1)->push_back($3); CHECK_FOR_ERROR - }; + } + ; -// ArgTypeList - List of types for a function type declaration... -ArgTypeListI : TypeListI - | TypeListI ',' DOTDOTDOT { - ($$=$1)->push_back(Type::VoidTy); +ArgTypeListI + : ArgTypeList + | ArgTypeList ',' DOTDOTDOT { + $$=$1; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + $$->push_back(TWA); CHECK_FOR_ERROR } | DOTDOTDOT { - ($$ = new std::list())->push_back(Type::VoidTy); + $$ = new TypeWithAttrsList; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + $$->push_back(TWA); CHECK_FOR_ERROR } | /*empty*/ { + $$ = new TypeWithAttrsList(); + CHECK_FOR_ERROR + }; + +// TypeList - Used for struct declarations and as a basis for function type +// declaration type lists +// +TypeListI : Types { $$ = new std::list(); + $$->push_back(*$1); + delete $1; + CHECK_FOR_ERROR + } + | TypeListI ',' Types { + ($$=$1)->push_back(*$3); + delete $3; CHECK_FOR_ERROR }; @@ -1339,10 +1479,12 @@ ArgTypeListI : TypeListI // ResolvedVal, ValueRef and ConstValueRef productions. // ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); const Type *ETy = ATy->getElementType(); int NumElements = ATy->getNumElements(); @@ -1350,7 +1492,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr if (NumElements != -1 && NumElements != (int)$3->size()) GEN_ERROR("Type mismatch: constant sized array initialized with " + utostr($3->size()) + " arguments, but has size of " + - itostr(NumElements) + "!"); + itostr(NumElements) + ""); // Verify all elements are correct type! for (unsigned i = 0; i < $3->size(); i++) { @@ -1365,24 +1507,28 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr CHECK_FOR_ERROR } | Types '[' ']' { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); int NumElements = ATy->getNumElements(); if (NumElements != -1 && NumElements != 0) GEN_ERROR("Type mismatch: constant sized array initialized with 0" - " arguments, but has size of " + itostr(NumElements) +"!"); + " arguments, but has size of " + itostr(NumElements) +""); $$ = ConstantArray::get(ATy, std::vector()); delete $1; CHECK_FOR_ERROR } | Types 'c' STRINGCONSTANT { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); int NumElements = ATy->getNumElements(); const Type *ETy = ATy->getElementType(); @@ -1390,18 +1536,15 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr if (NumElements != -1 && NumElements != (EndStr-$3)) GEN_ERROR("Can't build string constant of size " + itostr((int)(EndStr-$3)) + - " when array has size " + itostr(NumElements) + "!"); + " when array has size " + itostr(NumElements) + ""); std::vector Vals; - if (ETy == Type::SByteTy) { - for (signed char *C = (signed char *)$3; C != (signed char *)EndStr; ++C) - Vals.push_back(ConstantSInt::get(ETy, *C)); - } else if (ETy == Type::UByteTy) { + if (ETy == Type::Int8Ty) { for (unsigned char *C = (unsigned char *)$3; - C != (unsigned char*)EndStr; ++C) - Vals.push_back(ConstantUInt::get(ETy, *C)); + C != (unsigned char*)EndStr; ++C) + Vals.push_back(ConstantInt::get(ETy, *C)); } else { free($3); - GEN_ERROR("Cannot build string arrays of non byte sized elements!"); + GEN_ERROR("Cannot build string arrays of non byte sized elements"); } free($3); $$ = ConstantArray::get(ATy, Vals); @@ -1409,10 +1552,12 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr CHECK_FOR_ERROR } | Types '<' ConstVector '>' { // Nonempty unsized arr - const PackedType *PTy = dyn_cast($1->get()); + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); + const VectorType *PTy = dyn_cast($1->get()); if (PTy == 0) GEN_ERROR("Cannot make packed constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); const Type *ETy = PTy->getElementType(); int NumElements = PTy->getNumElements(); @@ -1420,7 +1565,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr if (NumElements != -1 && NumElements != (int)$3->size()) GEN_ERROR("Type mismatch: constant sized packed initialized with " + utostr($3->size()) + " arguments, but has size of " + - itostr(NumElements) + "!"); + itostr(NumElements) + ""); // Verify all elements are correct type! for (unsigned i = 0; i < $3->size(); i++) { @@ -1430,7 +1575,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr (*$3)[i]->getType()->getDescription() + "'."); } - $$ = ConstantPacked::get(PTy, *$3); + $$ = ConstantVector::get(PTy, *$3); delete $1; delete $3; CHECK_FOR_ERROR } @@ -1438,67 +1583,129 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr const StructType *STy = dyn_cast($1->get()); if (STy == 0) GEN_ERROR("Cannot make struct constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); + + if ($3->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + for (unsigned i = 0, e = $3->size(); i != e; ++i) + if ((*$3)[i]->getType() != STy->getElementType(i)) + GEN_ERROR("Expected type '" + + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + + " of structure initializer"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'"); + + $$ = ConstantStruct::get(STy, *$3); + delete $1; delete $3; + CHECK_FOR_ERROR + } + | Types '{' '}' { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); + const StructType *STy = dyn_cast($1->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*$1)->getDescription() + "'"); + + if (STy->getNumContainedTypes() != 0) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'"); + + $$ = ConstantStruct::get(STy, std::vector()); + delete $1; + CHECK_FOR_ERROR + } + | Types '<' '{' ConstVector '}' '>' { + const StructType *STy = dyn_cast($1->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*$1)->getDescription() + "'"); - if ($3->size() != STy->getNumContainedTypes()) - GEN_ERROR("Illegal number of initializers for structure type!"); + if ($4->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); // Check to ensure that constants are compatible with the type initializer! - for (unsigned i = 0, e = $3->size(); i != e; ++i) - if ((*$3)[i]->getType() != STy->getElementType(i)) + for (unsigned i = 0, e = $4->size(); i != e; ++i) + if ((*$4)[i]->getType() != STy->getElementType(i)) GEN_ERROR("Expected type '" + STy->getElementType(i)->getDescription() + "' for element #" + utostr(i) + - " of structure initializer!"); + " of structure initializer"); - $$ = ConstantStruct::get(STy, *$3); - delete $1; delete $3; + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); + + $$ = ConstantStruct::get(STy, *$4); + delete $1; delete $4; CHECK_FOR_ERROR } - | Types '{' '}' { + | Types '<' '{' '}' '>' { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const StructType *STy = dyn_cast($1->get()); if (STy == 0) GEN_ERROR("Cannot make struct constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); if (STy->getNumContainedTypes() != 0) - GEN_ERROR("Illegal number of initializers for structure type!"); + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); $$ = ConstantStruct::get(STy, std::vector()); delete $1; CHECK_FOR_ERROR } | Types NULL_TOK { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const PointerType *PTy = dyn_cast($1->get()); if (PTy == 0) GEN_ERROR("Cannot make null pointer constant with type: '" + - (*$1)->getDescription() + "'!"); + (*$1)->getDescription() + "'"); $$ = ConstantPointerNull::get(PTy); delete $1; CHECK_FOR_ERROR } | Types UNDEF { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); $$ = UndefValue::get($1->get()); delete $1; CHECK_FOR_ERROR } | Types SymbolicValueRef { + if (!UpRefs.empty()) + 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"); // 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; @@ -1520,7 +1727,10 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $2.destroy(); } else { std::string Name; - if ($2.Type == ValID::NameVal) Name = $2.Name; + if ($2.Type == ValID::GlobalName) + Name = $2.Name; + else if ($2.Type != ValID::GlobalID) + GEN_ERROR("Invalid reference to global"); // Create the forward referenced global. GlobalValue *GV; @@ -1545,162 +1755,159 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr CHECK_FOR_ERROR } | Types ConstExpr { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); if ($1->get() != $2->getType()) - GEN_ERROR("Mismatched types for constant expression!"); + GEN_ERROR("Mismatched types for constant expression: " + + (*$1)->getDescription() + " and " + $2->getType()->getDescription()); $$ = $2; delete $1; CHECK_FOR_ERROR } | Types ZEROINITIALIZER { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); const Type *Ty = $1->get(); if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) - GEN_ERROR("Cannot create a null initialized value of this type!"); + GEN_ERROR("Cannot create a null initialized value of this type"); $$ = Constant::getNullValue(Ty); delete $1; CHECK_FOR_ERROR - }; - -ConstVal : SIntType EINT64VAL { // integral constants - if (!ConstantSInt::isValueValidForType($1, $2)) - GEN_ERROR("Constant value doesn't fit in type!"); - $$ = ConstantSInt::get($1, $2); + } + | IntType ESINT64VAL { // integral constants + if (!ConstantInt::isValueValidForType($1, $2)) + GEN_ERROR("Constant value doesn't fit in type"); + $$ = ConstantInt::get($1, $2, true); CHECK_FOR_ERROR } - | UIntType EUINT64VAL { // integral constants - if (!ConstantUInt::isValueValidForType($1, $2)) - GEN_ERROR("Constant value doesn't fit in type!"); - $$ = ConstantUInt::get($1, $2); + | 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, false); CHECK_FOR_ERROR } - | BOOL TRUETOK { // Boolean constants - $$ = ConstantBool::getTrue(); + | 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 + assert(cast($1)->getBitWidth() == 1 && "Not Bool?"); + $$ = ConstantInt::getTrue(); CHECK_FOR_ERROR } - | BOOL FALSETOK { // Boolean constants - $$ = ConstantBool::getFalse(); + | INTTYPE FALSETOK { // Boolean constants + assert(cast($1)->getBitWidth() == 1 && "Not Bool?"); + $$ = ConstantInt::getFalse(); CHECK_FOR_ERROR } | FPType FPVAL { // Float & Double constants if (!ConstantFP::isValueValidForType($1, $2)) - GEN_ERROR("Floating point constant invalid for type!!"); + GEN_ERROR("Floating point constant invalid for type"); $$ = ConstantFP::get($1, $2); CHECK_FOR_ERROR }; -ConstExpr: CAST '(' ConstVal TO Types ')' { - if (!$3->getType()->isFirstClassType()) - GEN_ERROR("cast constant expression from a non-primitive type: '" + - $3->getType()->getDescription() + "'!"); - if (!$5->get()->isFirstClassType()) - GEN_ERROR("cast constant expression to a non-primitive type: '" + - $5->get()->getDescription() + "'!"); - $$ = ConstantExpr::getCast($3, $5->get()); +ConstExpr: CastOps '(' ConstVal TO Types ')' { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription()); + 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); delete $5; - CHECK_FOR_ERROR } | GETELEMENTPTR '(' ConstVal IndexList ')' { if (!isa($3->getType())) - GEN_ERROR("GetElementPtr requires a pointer operand!"); - - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct - // indices to uint struct indices for compatibility. - generic_gep_type_iterator::iterator> - GTI = gep_type_begin($3->getType(), $4->begin(), $4->end()), - GTE = gep_type_end($3->getType(), $4->begin(), $4->end()); - for (unsigned i = 0, e = $4->size(); i != e && GTI != GTE; ++i, ++GTI) - if (isa(*GTI)) // Only change struct indices - if (ConstantUInt *CUI = dyn_cast((*$4)[i])) - if (CUI->getType() == Type::UByteTy) - (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy); + GEN_ERROR("GetElementPtr requires a pointer operand"); const Type *IdxTy = - GetElementPtrInst::getIndexedType($3->getType(), *$4, true); + GetElementPtrInst::getIndexedType($3->getType(), &(*$4)[0], $4->size(), + true); if (!IdxTy) - GEN_ERROR("Index list invalid for constant getelementptr!"); + GEN_ERROR("Index list invalid for constant getelementptr"); - std::vector IdxVec; + SmallVector IdxVec; for (unsigned i = 0, e = $4->size(); i != e; ++i) if (Constant *C = dyn_cast((*$4)[i])) IdxVec.push_back(C); else - GEN_ERROR("Indices to constant getelementptr must be constants!"); + GEN_ERROR("Indices to constant getelementptr must be constants"); delete $4; - $$ = ConstantExpr::getGetElementPtr($3, IdxVec); + $$ = ConstantExpr::getGetElementPtr($3, &IdxVec[0], IdxVec.size()); CHECK_FOR_ERROR } | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' { - if ($3->getType() != Type::BoolTy) - GEN_ERROR("Select condition must be of boolean type!"); + if ($3->getType() != Type::Int1Ty) + GEN_ERROR("Select condition must be of boolean type"); if ($5->getType() != $7->getType()) - GEN_ERROR("Select operand types must match!"); + GEN_ERROR("Select operand types must match"); $$ = ConstantExpr::getSelect($3, $5, $7); CHECK_FOR_ERROR } | ArithmeticOps '(' ConstVal ',' ConstVal ')' { if ($3->getType() != $5->getType()) - GEN_ERROR("Binary operator types must match!"); - // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs. - // To retain backward compatibility with these early compilers, we emit a - // cast to the appropriate integer type automatically if we are in the - // broken case. See PR424 for more information. - if (!isa($3->getType())) { - $$ = ConstantExpr::get($1, $3, $5); - } else { - const Type *IntPtrTy = 0; - switch (CurModule.CurrentModule->getPointerSize()) { - case Module::Pointer32: IntPtrTy = Type::IntTy; break; - case Module::Pointer64: IntPtrTy = Type::LongTy; break; - default: GEN_ERROR("invalid pointer binary constant expr!"); - } - $$ = ConstantExpr::get($1, ConstantExpr::getCast($3, IntPtrTy), - ConstantExpr::getCast($5, IntPtrTy)); - $$ = ConstantExpr::getCast($$, $3->getType()); - } - CHECK_FOR_ERROR + GEN_ERROR("Binary operator types must match"); + CHECK_FOR_ERROR; + $$ = ConstantExpr::get($1, $3, $5); } | LogicalOps '(' ConstVal ',' ConstVal ')' { if ($3->getType() != $5->getType()) - GEN_ERROR("Logical operator types must match!"); - if (!$3->getType()->isIntegral()) { - if (!isa($3->getType()) || - !cast($3->getType())->getElementType()->isIntegral()) - GEN_ERROR("Logical operator requires integral operands!"); + GEN_ERROR("Logical operator types must match"); + if (!$3->getType()->isInteger()) { + if (Instruction::isShift($1) || !isa($3->getType()) || + !cast($3->getType())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); } $$ = ConstantExpr::get($1, $3, $5); CHECK_FOR_ERROR } - | SetCondOps '(' ConstVal ',' ConstVal ')' { - if ($3->getType() != $5->getType()) - GEN_ERROR("setcc operand types must match!"); - $$ = ConstantExpr::get($1, $3, $5); - CHECK_FOR_ERROR + | ICMP IPredicates '(' ConstVal ',' ConstVal ')' { + if ($4->getType() != $6->getType()) + GEN_ERROR("icmp operand types must match"); + $$ = ConstantExpr::getICmp($2, $4, $6); } - | ShiftOps '(' ConstVal ',' ConstVal ')' { - if ($5->getType() != Type::UByteTy) - GEN_ERROR("Shift count for shift constant must be unsigned byte!"); - if (!$3->getType()->isInteger()) - GEN_ERROR("Shift constant expression requires integer operand!"); - $$ = ConstantExpr::get($1, $3, $5); - CHECK_FOR_ERROR + | FCMP FPredicates '(' ConstVal ',' ConstVal ')' { + if ($4->getType() != $6->getType()) + GEN_ERROR("fcmp operand types must match"); + $$ = ConstantExpr::getFCmp($2, $4, $6); } | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' { if (!ExtractElementInst::isValidOperands($3, $5)) - GEN_ERROR("Invalid extractelement operands!"); + GEN_ERROR("Invalid extractelement operands"); $$ = ConstantExpr::getExtractElement($3, $5); CHECK_FOR_ERROR } | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' { if (!InsertElementInst::isValidOperands($3, $5, $7)) - GEN_ERROR("Invalid insertelement operands!"); + GEN_ERROR("Invalid insertelement operands"); $$ = ConstantExpr::getInsertElement($3, $5, $7); CHECK_FOR_ERROR } | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' { if (!ShuffleVectorInst::isValidOperands($3, $5, $7)) - GEN_ERROR("Invalid shufflevector operands!"); + GEN_ERROR("Invalid shufflevector operands"); $$ = ConstantExpr::getShuffleVector($3, $5, $7); CHECK_FOR_ERROR }; @@ -1721,6 +1928,9 @@ ConstVector : ConstVector ',' ConstVal { // GlobalType - Match either GLOBAL or CONSTANT for global declarations... GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; +// ThreadLocal +ThreadLocal : THREAD_LOCAL { $$ = true; } | { $$ = false; }; + //===----------------------------------------------------------------------===// // Rules to match Modules @@ -1729,47 +1939,38 @@ GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; // Module rule: Capture the result of parsing the whole file into a result // variable... // -Module : FunctionList { - $$ = ParserResult = $1; - CurModule.ModuleDone(); - CHECK_FOR_ERROR; -}; +Module + : DefinitionList { + $$ = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + } + | /*empty*/ { + $$ = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + } + ; -// FunctionList - A list of functions, preceeded by a constant pool. -// -FunctionList : FunctionList Function { - $$ = $1; +DefinitionList + : Definition + | DefinitionList Definition + ; + +Definition + : DEFINE { CurFun.isDeclare = false; } Function { CurFun.FunctionDone(); CHECK_FOR_ERROR - } - | FunctionList FunctionProto { - $$ = $1; - CHECK_FOR_ERROR } - | FunctionList MODULE ASM_TOK AsmBlock { - $$ = $1; - CHECK_FOR_ERROR - } - | FunctionList IMPLEMENTATION { - $$ = $1; + | DECLARE { CurFun.isDeclare = true; } FunctionProto { CHECK_FOR_ERROR } - | ConstPool { - $$ = CurModule.CurrentModule; - // 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::NameVal) { - GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'"); - } else { - GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num)); - } - } + | MODULE ASM_TOK AsmBlock { CHECK_FOR_ERROR - }; - -// ConstPool - Constants with optional names assigned to them. -ConstPool : ConstPool OptAssign TYPE TypesV { + } + | OptLocalAssign TYPE Types { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); // Eagerly resolve types. This is not an optimization, this is a // requirement that is due to the fact that we could have this: // @@ -1779,65 +1980,64 @@ ConstPool : ConstPool OptAssign TYPE TypesV { // If types are not resolved eagerly, then the two types will not be // determined to be the same type! // - ResolveTypeTo($2, *$4); + ResolveTypeTo($1, *$3); - if (!setTypeName(*$4, $2) && !$2) { + if (!setTypeName(*$3, $1) && !$1) { CHECK_FOR_ERROR // If this is a named type that is not a redefinition, add it to the slot // table. - CurModule.Types.push_back(*$4); + CurModule.Types.push_back(*$3); } - delete $4; - CHECK_FOR_ERROR - } - | ConstPool FunctionProto { // Function prototypes can be in const pool + delete $3; CHECK_FOR_ERROR } - | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool + | OptLocalAssign TYPE VOID { + ResolveTypeTo($1, $3); + + if (!setTypeName($3, $1) && !$1) { + CHECK_FOR_ERROR + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back($3); + } CHECK_FOR_ERROR } - | ConstPool OptAssign OptLinkage GlobalType ConstVal { + | OptGlobalAssign GVVisibilityStyle ThreadLocal GlobalType ConstVal { + /* "Externally Visible" Linkage */ if ($5 == 0) - GEN_ERROR("Global value initializer is not a constant!"); - CurGV = ParseGlobalVariable($2, $3, $4, $5->getType(), $5); - CHECK_FOR_ERROR - } GlobalVarAttributes { - CurGV = 0; - } - | ConstPool OptAssign EXTERNAL GlobalType Types { - CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0); + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage, + $2, $4, $5->getType(), $5, $3); CHECK_FOR_ERROR - delete $5; } GlobalVarAttributes { CurGV = 0; - CHECK_FOR_ERROR } - | ConstPool OptAssign DLLIMPORT GlobalType Types { - CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, *$5, 0); + | OptGlobalAssign GVInternalLinkage GVVisibilityStyle ThreadLocal GlobalType ConstVal { + if ($6 == 0) + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable($1, $2, $3, $5, $6->getType(), $6, $4); CHECK_FOR_ERROR - delete $5; } GlobalVarAttributes { CurGV = 0; - CHECK_FOR_ERROR } - | ConstPool OptAssign EXTERN_WEAK GlobalType Types { - CurGV = - ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, *$5, 0); + | OptGlobalAssign GVExternalLinkage GVVisibilityStyle ThreadLocal GlobalType Types { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$6)->getDescription()); + CurGV = ParseGlobalVariable($1, $2, $3, $5, *$6, 0, $4); CHECK_FOR_ERROR - delete $5; + delete $6; } GlobalVarAttributes { CurGV = 0; CHECK_FOR_ERROR } - | ConstPool TARGET TargetDefinition { + | TARGET TargetDefinition { CHECK_FOR_ERROR } - | ConstPool DEPLIBS '=' LibrariesDefinition { + | DEPLIBS '=' LibrariesDefinition { CHECK_FOR_ERROR } - | /* empty: end of list */ { - }; + ; AsmBlock : STRINGCONSTANT { @@ -1853,31 +2053,13 @@ AsmBlock : STRINGCONSTANT { CHECK_FOR_ERROR }; -BigOrLittle : BIG { $$ = Module::BigEndian; }; -BigOrLittle : LITTLE { $$ = Module::LittleEndian; }; - -TargetDefinition : ENDIAN '=' BigOrLittle { - CurModule.CurrentModule->setEndianness($3); - CHECK_FOR_ERROR - } - | POINTERSIZE '=' EUINT64VAL { - if ($3 == 32) - CurModule.CurrentModule->setPointerSize(Module::Pointer32); - else if ($3 == 64) - CurModule.CurrentModule->setPointerSize(Module::Pointer64); - else - GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!"); - CHECK_FOR_ERROR - } - | TRIPLE '=' STRINGCONSTANT { +TargetDefinition : TRIPLE '=' STRINGCONSTANT { CurModule.CurrentModule->setTargetTriple($3); free($3); - CHECK_FOR_ERROR - }; - | DATA '=' STRINGCONSTANT { + } + | DATALAYOUT '=' STRINGCONSTANT { CurModule.CurrentModule->setDataLayout($3); free($3); - CHECK_FOR_ERROR }; LibrariesDefinition : '[' LibList ']'; @@ -1901,26 +2083,24 @@ LibList : LibList ',' STRINGCONSTANT { // Rules to match Function Headers //===----------------------------------------------------------------------===// -Name : VAR_ID | STRINGCONSTANT; -OptName : Name | /*empty*/ { $$ = 0; }; - -ArgVal : Types OptName { - if (*$1 == Type::VoidTy) - GEN_ERROR("void typed arguments are invalid!"); - $$ = new std::pair($1, $2); - CHECK_FOR_ERROR -}; - -ArgListH : ArgListH ',' ArgVal { +ArgListH : ArgListH ',' Types OptParamAttrs OptLocalName { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); + if (*$3 == Type::VoidTy) + GEN_ERROR("void typed arguments are invalid"); + ArgListEntry E; E.Attrs = $4; E.Ty = $3; E.Name = $5; $$ = $1; - $1->push_back(*$3); - delete $3; + $1->push_back(E); CHECK_FOR_ERROR } - | ArgVal { - $$ = new std::vector >(); - $$->push_back(*$1); - delete $1; + | Types OptParamAttrs OptLocalName { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); + if (*$1 == Type::VoidTy) + GEN_ERROR("void typed arguments are invalid"); + ArgListEntry E; E.Attrs = $2; E.Ty = $1; E.Name = $3; + $$ = new ArgListType; + $$->push_back(E); CHECK_FOR_ERROR }; @@ -1930,13 +2110,20 @@ ArgList : ArgListH { } | ArgListH ',' DOTDOTDOT { $$ = $1; - $$->push_back(std::pair(new PATypeHolder(Type::VoidTy), 0)); + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = ParamAttr::None; + $$->push_back(E); CHECK_FOR_ERROR } | DOTDOTDOT { - $$ = new std::vector >(); - $$->push_back(std::make_pair(new PATypeHolder(Type::VoidTy), (char*)0)); + $$ = new ArgListType; + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = ParamAttr::None; + $$->push_back(E); CHECK_FOR_ERROR } | /* empty */ { @@ -1944,34 +2131,54 @@ ArgList : ArgListH { CHECK_FOR_ERROR }; -FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' - OptSection OptAlign { +FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' + OptFuncAttrs OptSection OptAlign { UnEscapeLexed($3); std::string FunctionName($3); free($3); // Free strdup'd memory! - if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) - GEN_ERROR("LLVM functions cannot return aggregate types!"); + // Check the function result for abstractness if this is a define. We should + // have no abstract types at this point + if (!CurFun.isDeclare && CurModule.TypeIsUnresolved($2)) + GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription()); std::vector ParamTypeList; + 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 (std::vector >::iterator I = $5->begin(); - I != $5->end(); ++I) - ParamTypeList.push_back(I->first->get()); + 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) + 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(); - const FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg); + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + + FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, PAL); const PointerType *PFT = PointerType::get(FT); delete $2; ValID ID; if (!FunctionName.empty()) { - ID = ValID::create((char*)FunctionName.c_str()); + ID = ValID::createGlobalName((char*)FunctionName.c_str()); } else { - ID = ValID::create((int)CurModule.Values[PFT].size()); + ID = ValID::createGlobalID(CurModule.Values.size()); } Function *Fn = 0; @@ -1983,17 +2190,21 @@ FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' CurModule.CurrentModule->getFunctionList().remove(Fn); CurModule.CurrentModule->getFunctionList().push_back(Fn); } else if (!FunctionName.empty() && // Merge with an earlier prototype? - (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) { - // If this is the case, either we need to be a forward decl, or it needs - // to be. - if (!CurFun.isDeclare && !Fn->isExternal()) - GEN_ERROR("Redefinition of function '" + FunctionName + "'!"); - - // Make sure to strip off any argument names so we can't get conflicts. - if (Fn->isExternal()) + (Fn = CurModule.CurrentModule->getFunction(FunctionName))) { + if (Fn->getFunctionType() != FT ) { + // The existing function doesn't have the same type. 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()) { + // 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, CurModule.CurrentModule); @@ -2008,30 +2219,33 @@ FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' // correctly handle cases, when pointer to function is passed as argument to // another function. Fn->setLinkage(CurFun.Linkage); + Fn->setVisibility(CurFun.Visibility); } Fn->setCallingConv($1); - Fn->setAlignment($8); - if ($7) { - Fn->setSection($7); - free($7); + Fn->setAlignment($9); + if ($8) { + Fn->setSection($8); + free($8); } // Add all of the arguments we parsed to the function... if ($5) { // Is null if empty... if (isVarArg) { // Nuke the last entry - assert($5->back().first->get() == Type::VoidTy && $5->back().second == 0&& + assert($5->back().Ty->get() == Type::VoidTy && $5->back().Name == 0 && "Not a varargs marker!"); - delete $5->back().first; + delete $5->back().Ty; $5->pop_back(); // Delete the last entry } Function::arg_iterator ArgIt = Fn->arg_begin(); - for (std::vector >::iterator I = $5->begin(); - I != $5->end(); ++I, ++ArgIt) { - delete I->first; // Delete the typeholder... - - setValueName(ArgIt, I->second); // Insert arg into symtab... + Function::arg_iterator ArgEnd = Fn->arg_end(); + unsigned Idx = 1; + 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... CHECK_FOR_ERROR InsertValue(ArgIt); + Idx++; } delete $5; // We're now done with the argument list @@ -2041,12 +2255,13 @@ FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' BEGIN : BEGINTOK | '{'; // Allow BEGIN or '{' to start a function -FunctionHeader : OptLinkage FunctionHeaderH BEGIN { +FunctionHeader : FunctionDefineLinkage GVVisibilityStyle FunctionHeaderH BEGIN { $$ = CurFun.CurrentFunction; // Make sure that we keep track of the linkage type even if there was a // previous "declare". $$->setLinkage($1); + $$->setVisibility($2); }; END : ENDTOK | '}'; // Allow end of '}' to end a function @@ -2056,11 +2271,9 @@ Function : BasicBlockList END { CHECK_FOR_ERROR }; -FnDeclareLinkage: /*default*/ | - DLLIMPORT { CurFun.Linkage = GlobalValue::DLLImportLinkage } | - EXTERN_WEAK { CurFun.Linkage = GlobalValue::DLLImportLinkage }; - -FunctionProto : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH { +FunctionProto : FunctionDeclareLinkage GVVisibilityStyle FunctionHeaderH { + CurFun.CurrentFunction->setLinkage($1); + CurFun.CurrentFunction->setVisibility($2); $$ = CurFun.CurrentFunction; CurFun.FunctionDone(); CHECK_FOR_ERROR @@ -2092,11 +2305,11 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant CHECK_FOR_ERROR } | TRUETOK { - $$ = ValID::create(ConstantBool::getTrue()); + $$ = ValID::create(ConstantInt::getTrue()); CHECK_FOR_ERROR } | FALSETOK { - $$ = ValID::create(ConstantBool::getFalse()); + $$ = ValID::create(ConstantInt::getFalse()); CHECK_FOR_ERROR } | NULL_TOK { @@ -2115,10 +2328,10 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant const Type *ETy = (*$2)[0]->getType(); int NumElements = $2->size(); - PackedType* pt = PackedType::get(ETy, NumElements); + VectorType* pt = VectorType::get(ETy, NumElements); PATypeHolder* PTy = new PATypeHolder( HandleUpRefs( - PackedType::get( + VectorType::get( ETy, NumElements) ) @@ -2132,7 +2345,7 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant (*$2)[i]->getType()->getDescription() + "'."); } - $$ = ValID::create(ConstantPacked::get(pt, *$2)); + $$ = ValID::create(ConstantVector::get(pt, *$2)); delete PTy; delete $2; CHECK_FOR_ERROR } @@ -2154,12 +2367,20 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant // SymbolicValueRef - Reference to one of two ways of symbolically refering to // another value. // -SymbolicValueRef : INTVAL { // Is it an integer reference...? - $$ = ValID::create($1); +SymbolicValueRef : LOCALVAL_ID { // Is it an integer reference...? + $$ = ValID::createLocalID($1); CHECK_FOR_ERROR } - | Name { // Is it a named reference...? - $$ = ValID::create($1); + | GLOBALVAL_ID { + $$ = ValID::createGlobalID($1); + CHECK_FOR_ERROR + } + | LocalName { // Is it a named reference...? + $$ = ValID::createLocalName($1); + CHECK_FOR_ERROR + } + | GlobalName { // Is it a named reference...? + $$ = ValID::createGlobalName($1); CHECK_FOR_ERROR }; @@ -2171,9 +2392,13 @@ ValueRef : SymbolicValueRef | ConstValueRef; // type immediately preceeds the value reference, and allows complex constant // pool references (for things like: 'ret [2 x int] [ int 12, int 42]') ResolvedVal : Types ValueRef { - $$ = getVal(*$1, $2); delete $1; + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); + $$ = getVal(*$1, $2); + delete $1; CHECK_FOR_ERROR - }; + } + ; BasicBlockList : BasicBlockList BasicBlock { $$ = $1; @@ -2188,44 +2413,30 @@ BasicBlockList : BasicBlockList BasicBlock { // Basic blocks are terminated by branching instructions: // br, br/cc, switch, ret // -BasicBlock : InstructionList OptAssign BBTerminatorInst { +BasicBlock : InstructionList OptLocalAssign BBTerminatorInst { setValueName($3, $2); CHECK_FOR_ERROR InsertValue($3); - $1->getInstList().push_back($3); - InsertValue($1); $$ = $1; CHECK_FOR_ERROR }; InstructionList : InstructionList Inst { + if (CastInst *CI1 = dyn_cast($2)) + if (CastInst *CI2 = dyn_cast(CI1->getOperand(0))) + if (CI2->getParent() == 0) + $1->getInstList().push_back(CI2); $1->getInstList().push_back($2); $$ = $1; CHECK_FOR_ERROR } - | /* empty */ { - $$ = CurBB = getBBVal(ValID::create((int)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 { - $$ = CurBB = getBBVal(ValID::create($1), 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, $$); + | LABELSTR { // Labelled (named) basic block + $$ = defineBBVal(ValID::createLocalName($1)); CHECK_FOR_ERROR }; @@ -2233,21 +2444,22 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = new ReturnInst($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... - | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { + } // Conditional Branch... + | BR INTTYPE ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { + assert(cast($2)->getBitWidth() == 1 && "Not Bool?"); BasicBlock* tmpBBA = getBBVal($6); CHECK_FOR_ERROR BasicBlock* tmpBBB = getBBVal($9); CHECK_FOR_ERROR - Value* tmpVal = getVal(Type::BoolTy, $3); + Value* tmpVal = getVal(Type::Int1Ty, $3); CHECK_FOR_ERROR $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal); } @@ -2265,7 +2477,7 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... if (ConstantInt *CI = dyn_cast(I->first)) S->addCase(CI, I->second); else - GEN_ERROR("Switch case is constant, but not a simple integer!"); + GEN_ERROR("Switch case is constant, but not a simple integer"); } delete $8; CHECK_FOR_ERROR @@ -2279,59 +2491,83 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = S; CHECK_FOR_ERROR } - | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')' + | INVOKE OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' OptFuncAttrs TO LABEL ValueRef UNWIND LABEL ValueRef { - const PointerType *PFTy; - const FunctionType *Ty; + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; if (!(PFTy = dyn_cast($3->get())) || !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - if ($6) { - for (std::vector::iterator I = $6->begin(), E = $6->end(); - I != E; ++I) - ParamTypes.push_back((*I)->getType()); + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = 8; + Attrs.push_back(PAWI); + } + ValueRefList::iterator I = $6->begin(), E = $6->end(); + unsigned index = 1; + for (; I != E; ++I, ++index) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } } - bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; - if (isVarArg) ParamTypes.pop_back(); - - Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + Ty = FunctionType::get($3->get(), ParamTypes, false, PAL); PFTy = PointerType::get(Ty); } + delete $3; + Value *V = getVal(PFTy, $4); // Get the function we're calling... CHECK_FOR_ERROR - BasicBlock *Normal = getBBVal($10); + BasicBlock *Normal = getBBVal($11); CHECK_FOR_ERROR - BasicBlock *Except = getBBVal($13); + BasicBlock *Except = getBBVal($14); CHECK_FOR_ERROR - // Create the call node... - if (!$6) { // Has no arguments? - $$ = new InvokeInst(V, Normal, Except, std::vector()); + // Check the arguments + ValueList Args; + if ($6->empty()) { // Has no arguments? + // Make sure no arguments is a good thing! + if (Ty->getNumParams() != 0) + GEN_ERROR("No arguments passed to a function that " + "expects arguments"); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified // correctly! - // FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); + ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); - for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); - - if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - GEN_ERROR("Invalid number of parameters detected!"); + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + } - $$ = new InvokeInst(V, Normal, Except, *$6); + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI) + Args.push_back(ArgI->Val); // push the remaining varargs + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); } - cast($$)->setCallingConv($2); - - delete $3; + + // Create the InvokeInst + InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); + II->setCallingConv($2); + $$ = II; delete $6; CHECK_FOR_ERROR } @@ -2348,10 +2584,10 @@ 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!"); + GEN_ERROR("May only switch on a constant pool value"); BasicBlock* tmpBB = getBBVal($6); CHECK_FOR_ERROR @@ -2359,27 +2595,30 @@ 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) - GEN_ERROR("May only switch on a constant pool value!"); + GEN_ERROR("May only switch on a constant pool value"); BasicBlock* tmpBB = getBBVal($5); CHECK_FOR_ERROR $$->push_back(std::make_pair(V, tmpBB)); }; -Inst : OptAssign InstVal { - // Is this definition named?? if so, assign the name... - setValueName($2, $1); - CHECK_FOR_ERROR - InsertValue($2); - $$ = $2; - CHECK_FOR_ERROR -}; +Inst : OptLocalAssign InstVal { + // Is this definition named?? if so, assign the name... + setValueName($2, $1); + CHECK_FOR_ERROR + InsertValue($2); + $$ = $2; + CHECK_FOR_ERROR + }; + PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); $$ = new std::list >(); Value* tmpVal = getVal(*$1, $3); CHECK_FOR_ERROR @@ -2398,18 +2637,34 @@ PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes }; -ValueRefList : ResolvedVal { // Used for call statements, and memory insts... - $$ = new std::vector(); - $$->push_back($1); +ValueRefList : Types ValueRef OptParamAttrs { + 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); + $$->push_back(E); + delete $1; } - | ValueRefList ',' ResolvedVal { + | ValueRefList ',' Types ValueRef OptParamAttrs { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); $$ = $1; - $1->push_back($3); + ValueRefListEntry E; E.Attrs = $5; E.Val = getVal($3->get(), $4); + $$->push_back(E); + delete $3; CHECK_FOR_ERROR - }; + } + | /*empty*/ { $$ = new ValueRefList(); }; -// ValueRefListE - Just like ValueRefList, except that it may also be empty! -ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; }; +IndexList // Used for gep instructions and constant expressions + : /*empty*/ { $$ = new std::vector(); } + | IndexList ',' ResolvedVal { + $$ = $1; + $$->push_back($3); + CHECK_FOR_ERROR + } + ; OptTailCall : TAIL CALL { $$ = true; @@ -2421,26 +2676,33 @@ OptTailCall : TAIL CALL { }; InstVal : ArithmeticOps Types ValueRef ',' ValueRef { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() && - !isa((*$2).get())) + !isa((*$2).get())) GEN_ERROR( - "Arithmetic operator requires integer, FP, or packed operands!"); - if (isa((*$2).get()) && $1 == Instruction::Rem) - GEN_ERROR("Rem not supported on packed types!"); + "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 vector types"); Value* val1 = getVal(*$2, $3); CHECK_FOR_ERROR Value* val2 = getVal(*$2, $5); CHECK_FOR_ERROR $$ = BinaryOperator::create($1, val1, val2); if ($$ == 0) - GEN_ERROR("binary operator returned null!"); + GEN_ERROR("binary operator returned null"); delete $2; } | LogicalOps Types ValueRef ',' ValueRef { - if (!(*$2)->isIntegral()) { - if (!isa($2->get()) || - !cast($2->get())->getElementType()->isIntegral()) - GEN_ERROR("Logical operator requires integral operands!"); + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); + if (!(*$2)->isInteger()) { + if (Instruction::isShift($1) || !isa($2->get()) || + !cast($2->get())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); } Value* tmpVal1 = getVal(*$2, $3); CHECK_FOR_ERROR @@ -2448,199 +2710,180 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { CHECK_FOR_ERROR $$ = BinaryOperator::create($1, tmpVal1, tmpVal2); if ($$ == 0) - GEN_ERROR("binary operator returned null!"); + GEN_ERROR("binary operator returned null"); delete $2; } - | SetCondOps Types ValueRef ',' ValueRef { - if(isa((*$2).get())) { - GEN_ERROR( - "PackedTypes currently not supported in setcc instructions!"); - } - Value* tmpVal1 = getVal(*$2, $3); + | ICMP IPredicates Types ValueRef ',' ValueRef { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); + if (isa((*$3).get())) + GEN_ERROR("Vector types not supported by icmp instruction"); + Value* tmpVal1 = getVal(*$3, $4); CHECK_FOR_ERROR - Value* tmpVal2 = getVal(*$2, $5); + Value* tmpVal2 = getVal(*$3, $6); CHECK_FOR_ERROR - $$ = new SetCondInst($1, tmpVal1, tmpVal2); + $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); if ($$ == 0) - GEN_ERROR("binary operator returned null!"); - delete $2; + GEN_ERROR("icmp operator returned null"); + delete $3; } - | NOT ResolvedVal { - std::cerr << "WARNING: Use of eliminated 'not' instruction:" - << " Replacing with 'xor'.\n"; - - Value *Ones = ConstantIntegral::getAllOnesValue($2->getType()); - if (Ones == 0) - GEN_ERROR("Expected integral type for not instruction!"); - - $$ = BinaryOperator::create(Instruction::Xor, $2, Ones); - if ($$ == 0) - GEN_ERROR("Could not create a xor instruction!"); + | FCMP FPredicates Types ValueRef ',' ValueRef { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription()); + if (isa((*$3).get())) + GEN_ERROR("Vector types not supported by fcmp instruction"); + Value* tmpVal1 = getVal(*$3, $4); CHECK_FOR_ERROR - } - | ShiftOps ResolvedVal ',' ResolvedVal { - if ($4->getType() != Type::UByteTy) - GEN_ERROR("Shift amount must be ubyte!"); - if (!$2->getType()->isInteger()) - GEN_ERROR("Shift constant expression requires integer operand!"); - $$ = new ShiftInst($1, $2, $4); + Value* tmpVal2 = getVal(*$3, $6); CHECK_FOR_ERROR + $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); + if ($$ == 0) + GEN_ERROR("fcmp operator returned null"); + delete $3; } - | CAST ResolvedVal TO Types { - if (!$4->get()->isFirstClassType()) - GEN_ERROR("cast instruction to a non-primitive type: '" + - $4->get()->getDescription() + "'!"); - $$ = new CastInst($2, *$4); + | CastOps ResolvedVal TO Types { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription()); + Value* Val = $2; + const Type* DestTy = $4->get(); + if (!CastInst::castIsValid($1, Val, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + $$ = CastInst::create($1, Val, DestTy); delete $4; - CHECK_FOR_ERROR } | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal { - if ($2->getType() != Type::BoolTy) - GEN_ERROR("select condition must be boolean!"); + if ($2->getType() != Type::Int1Ty) + GEN_ERROR("select condition must be boolean"); if ($4->getType() != $6->getType()) - GEN_ERROR("select value types should match!"); + GEN_ERROR("select value types should match"); $$ = new SelectInst($2, $4, $6); CHECK_FOR_ERROR } | VAARG ResolvedVal ',' Types { - NewVarArgs = true; + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription()); $$ = new VAArgInst($2, *$4); delete $4; CHECK_FOR_ERROR } - | VAARG_old ResolvedVal ',' Types { - ObsoleteVarArgs = true; - const Type* ArgTy = $2->getType(); - Function* NF = CurModule.CurrentModule-> - getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0); - - //b = vaarg a, t -> - //foo = alloca 1 of t - //bar = vacopy a - //store bar -> foo - //b = vaarg foo, t - AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix"); - CurBB->getInstList().push_back(foo); - CallInst* bar = new CallInst(NF, $2); - CurBB->getInstList().push_back(bar); - CurBB->getInstList().push_back(new StoreInst(bar, foo)); - $$ = new VAArgInst(foo, *$4); - delete $4; - CHECK_FOR_ERROR - } - | VANEXT_old ResolvedVal ',' Types { - ObsoleteVarArgs = true; - const Type* ArgTy = $2->getType(); - Function* NF = CurModule.CurrentModule-> - getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0); - - //b = vanext a, t -> - //foo = alloca 1 of t - //bar = vacopy a - //store bar -> foo - //tmp = vaarg foo, t - //b = load foo - AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix"); - CurBB->getInstList().push_back(foo); - CallInst* bar = new CallInst(NF, $2); - CurBB->getInstList().push_back(bar); - CurBB->getInstList().push_back(new StoreInst(bar, foo)); - Instruction* tmp = new VAArgInst(foo, *$4); - CurBB->getInstList().push_back(tmp); - $$ = new LoadInst(foo); - delete $4; - CHECK_FOR_ERROR - } | EXTRACTELEMENT ResolvedVal ',' ResolvedVal { if (!ExtractElementInst::isValidOperands($2, $4)) - GEN_ERROR("Invalid extractelement operands!"); + GEN_ERROR("Invalid extractelement operands"); $$ = new ExtractElementInst($2, $4); CHECK_FOR_ERROR } | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal { if (!InsertElementInst::isValidOperands($2, $4, $6)) - GEN_ERROR("Invalid insertelement operands!"); + GEN_ERROR("Invalid insertelement operands"); $$ = new InsertElementInst($2, $4, $6); CHECK_FOR_ERROR } | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal { if (!ShuffleVectorInst::isValidOperands($2, $4, $6)) - GEN_ERROR("Invalid shufflevector operands!"); + GEN_ERROR("Invalid shufflevector operands"); $$ = new ShuffleVectorInst($2, $4, $6); CHECK_FOR_ERROR } | PHI_TOK PHIList { const Type *Ty = $2->front().first->getType(); if (!Ty->isFirstClassType()) - GEN_ERROR("PHI node operands must be of first class type!"); + GEN_ERROR("PHI node operands must be of first class type"); $$ = new PHINode(Ty); ((PHINode*)$$)->reserveOperandSpace($2->size()); while ($2->begin() != $2->end()) { if ($2->front().first->getType() != Ty) - GEN_ERROR("All elements of a PHI node must be of the same type!"); + GEN_ERROR("All elements of a PHI node must be of the same type"); cast($$)->addIncoming($2->front().first, $2->front().second); $2->pop_front(); } delete $2; // Free the list... CHECK_FOR_ERROR } - | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { - const PointerType *PFTy; - const FunctionType *Ty; + | OptTailCall OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' + OptFuncAttrs { + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; if (!(PFTy = dyn_cast($3->get())) || !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - if ($6) { - for (std::vector::iterator I = $6->begin(), E = $6->end(); - I != E; ++I) - ParamTypes.push_back((*I)->getType()); + ParamAttrsVector Attrs; + if ($8 != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = $8; + Attrs.push_back(PAWI); + } + unsigned index = 1; + ValueRefList::iterator I = $6->begin(), E = $6->end(); + for (; I != E; ++I, ++index) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } } - bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; - if (isVarArg) ParamTypes.pop_back(); - - if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy) - GEN_ERROR("LLVM functions cannot return aggregate types!"); + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); - Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); + Ty = FunctionType::get($3->get(), ParamTypes, false, PAL); PFTy = PointerType::get(Ty); } Value *V = getVal(PFTy, $4); // Get the function we're calling... CHECK_FOR_ERROR - // Create the call node... - if (!$6) { // Has no arguments? + // 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() + "'"); + } + + // Check the arguments + ValueList Args; + if ($6->empty()) { // Has no arguments? // Make sure no arguments is a good thing! if (Ty->getNumParams() != 0) GEN_ERROR("No arguments passed to a function that " - "expects arguments!"); - - $$ = new CallInst(V, std::vector()); + "expects arguments"); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified // correctly! // FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); - - for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); - - if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - GEN_ERROR("Invalid number of parameters detected!"); + ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end(); - $$ = new CallInst(V, *$6); + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + } + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI) + Args.push_back(ArgI->Val); // push the remaining varargs + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); } - cast($$)->setTailCall($1); - cast($$)->setCallingConv($2); - delete $3; + // Create the call node + CallInst *CI = new CallInst(V, &Args[0], Args.size()); + CI->setTailCall($1); + CI->setCallingConv($2); + $$ = CI; delete $6; + delete $3; CHECK_FOR_ERROR } | MemoryInst { @@ -2648,16 +2891,6 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { CHECK_FOR_ERROR }; - -// IndexList - List of indices for GEP based instructions... -IndexList : ',' ValueRefList { - $$ = $2; - CHECK_FOR_ERROR - } | /* empty */ { - $$ = new std::vector(); - CHECK_FOR_ERROR - }; - OptVolatile : VOLATILE { $$ = true; CHECK_FOR_ERROR @@ -2670,22 +2903,30 @@ OptVolatile : VOLATILE { MemoryInst : MALLOC Types OptCAlign { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); $$ = new MallocInst(*$2, 0, $3); delete $2; CHECK_FOR_ERROR } - | MALLOC Types ',' UINT ValueRef OptCAlign { + | MALLOC Types ',' INTTYPE ValueRef OptCAlign { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); Value* tmpVal = getVal($4, $5); CHECK_FOR_ERROR $$ = new MallocInst(*$2, tmpVal, $6); delete $2; } | ALLOCA Types OptCAlign { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); $$ = new AllocaInst(*$2, 0, $3); delete $2; CHECK_FOR_ERROR } - | ALLOCA Types ',' UINT ValueRef OptCAlign { + | ALLOCA Types ',' INTTYPE ValueRef OptCAlign { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription()); Value* tmpVal = getVal($4, $5); CHECK_FOR_ERROR $$ = new AllocaInst(*$2, tmpVal, $6); @@ -2694,12 +2935,14 @@ MemoryInst : MALLOC Types OptCAlign { | FREE ResolvedVal { if (!isa($2->getType())) GEN_ERROR("Trying to free nonpointer type " + - $2->getType()->getDescription() + "!"); + $2->getType()->getDescription() + ""); $$ = new FreeInst($2); 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())) GEN_ERROR("Can't load from nonpointer type: " + (*$3)->getDescription()); @@ -2708,10 +2951,12 @@ 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()); if (!PT) GEN_ERROR("Can't store to a nonpointer type: " + @@ -2719,34 +2964,25 @@ MemoryInst : MALLOC Types OptCAlign { const Type *ElTy = PT->getElementType(); if (ElTy != $3->getType()) GEN_ERROR("Can't store '" + $3->getType()->getDescription() + - "' into space of type '" + ElTy->getDescription() + "'!"); + "' into space of type '" + ElTy->getDescription() + "'"); Value* tmpVal = getVal(*$5, $6); CHECK_FOR_ERROR - $$ = new StoreInst($3, tmpVal, $1); + $$ = new StoreInst($3, tmpVal, $1, $7); delete $5; } | 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!"); - - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct - // indices to uint struct indices for compatibility. - generic_gep_type_iterator::iterator> - GTI = gep_type_begin($2->get(), $4->begin(), $4->end()), - GTE = gep_type_end($2->get(), $4->begin(), $4->end()); - for (unsigned i = 0, e = $4->size(); i != e && GTI != GTE; ++i, ++GTI) - if (isa(*GTI)) // Only change struct indices - if (ConstantUInt *CUI = dyn_cast((*$4)[i])) - if (CUI->getType() == Type::UByteTy) - (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy); - - if (!GetElementPtrInst::getIndexedType(*$2, *$4, true)) + GEN_ERROR("getelementptr insn requires pointer operand"); + + if (!GetElementPtrInst::getIndexedType(*$2, &(*$4)[0], $4->size(), true)) GEN_ERROR("Invalid getelementptr indices for type '" + - (*$2)->getDescription()+ "'!"); + (*$2)->getDescription()+ "'"); Value* tmpVal = getVal(*$2, $3); CHECK_FOR_ERROR - $$ = new GetElementPtrInst(tmpVal, *$4); + $$ = new GetElementPtrInst(tmpVal, &(*$4)[0], $4->size()); delete $2; delete $4; }; @@ -2754,6 +2990,65 @@ 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) + delete ParserResult; + 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; + + // Reset ParserResult variable while saving its value for the result. + Module *Result = ParserResult; + ParserResult = 0; + + return Result; +} + void llvm::GenerateError(const std::string &message, int LineNo) { if (LineNo == -1) LineNo = llvmAsmlineno; // TODO: column number in exception @@ -2766,11 +3061,10 @@ int yyerror(const char *ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) + ":" + utostr((unsigned) llvmAsmlineno) + ": "; - std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading "; - if (yychar == YYEMPTY || yychar == 0) - errMsg += "end-of-file."; - else - errMsg += "token: '" + std::string(llvmAsmtext, llvmAsmleng) + "'"; + std::string errMsg = where + "error: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+ + "'"; GenerateError(errMsg); return 0; }