X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y;h=b8ac7f2867a9a4d1274448e331c66f8d839bae2e;hb=aa3c1410b427909da350f2b5e8d4ec3db62a3618;hp=c8304d75cc3f0a3c8cde9693964ed71ffe382c9f;hpb=f57a43da9c0198b8958df464755b556c83a65dd0;p=oota-llvm.git diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index c8304d75cc3..b8ac7f2867a 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -1,10 +1,10 @@ //===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the bison parser for LLVM assembly languages files. @@ -13,26 +13,30 @@ %{ #include "ParserInternals.h" -#include "llvm/SymbolTable.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" #include "llvm/Module.h" -#include "llvm/iTerminators.h" -#include "llvm/iMemory.h" -#include "llvm/iOperators.h" -#include "llvm/iPHINode.h" +#include "llvm/SymbolTable.h" +#include "llvm/Assembly/AutoUpgrade.h" #include "llvm/Support/GetElementPtrTypeIterator.h" -#include "Support/STLExtras.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" +#include +#include #include #include -#include int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); namespace llvm { + std::string CurFilename; +} +using namespace llvm; static Module *ParserResult; -std::string CurFilename; // DEBUG_UPREFS - Define this symbol if you want to enable debugging output // relating to upreferences in the input stream. @@ -46,32 +50,36 @@ std::string CurFilename; #define YYERROR_VERBOSE 1 -// HACK ALERT: This variable is used to implement the automatic conversion of -// variable argument instructions from their old to new forms. When this -// compatiblity "Feature" is removed, this should be too. -// -static BasicBlock *CurBB; static bool ObsoleteVarArgs; +static bool NewVarArgs; +static BasicBlock *CurBB; +static GlobalVariable *CurGV; // This contains info used when building the body of a function. It is // destroyed when the function is completed. // typedef std::vector ValueList; // Numbered defs -static void ResolveDefinitions(std::map &LateResolvers, - std::map *FutureLateResolvers = 0); +static void +ResolveDefinitions(std::map &LateResolvers, + std::map *FutureLateResolvers = 0); static struct PerModuleInfo { Module *CurrentModule; - std::map Values; // Module level numbered definitions - std::map LateResolveValues; + std::map Values; // Module level numbered definitions + std::map LateResolveValues; std::vector Types; std::map LateResolveTypes; + /// PlaceHolderInfo - When temporary placeholder objects are created, remember + /// how they were referenced and on which line of the input they came from so + /// that we can resolve them later and print error messages as appropriate. + std::map > PlaceHolderInfo; + // GlobalRefs - This maintains a mapping between 's and forward // references to global values. Global values may be referenced before they // are defined, and if so, the temporary object that they represent is held - // here. This is used for forward references of ConstantPointerRefs. + // here. This is used for forward references of GlobalValues. // typedef std::map, GlobalValue*> GlobalRefsType; @@ -89,7 +97,7 @@ static struct PerModuleInfo { // if (!GlobalRefs.empty()) { std::string UndefinedReferences = "Unresolved global references exist:\n"; - + for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end(); I != E; ++I) { UndefinedReferences += " " + I->first.first->getDescription() + " " + @@ -98,60 +106,45 @@ static struct PerModuleInfo { ThrowException(UndefinedReferences); } + // 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; } - - // DeclareNewGlobalValue - Called every time a new GV has been defined. This - // is used to remove things from the forward declaration map, resolving them - // to the correct thing as needed. - // - void DeclareNewGlobalValue(GlobalValue *GV, ValID D) { + // GetForwardRefForGlobal - Check to see if there is a forward reference + // for this global. If so, remove it from the GlobalRefs map and return it. + // If not, just return null. + GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) { // Check to see if there is a forward reference to this global variable... // if there is, eliminate it and patch the reference to use the new def'n. - GlobalRefsType::iterator I = - GlobalRefs.find(std::make_pair(GV->getType(), D)); - + GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID)); + GlobalValue *Ret = 0; if (I != GlobalRefs.end()) { - GlobalValue *OldGV = I->second; // Get the placeholder... - I->first.second.destroy(); // Free string memory if necessary - - // Loop over all of the uses of the GlobalValue. The only thing they are - // allowed to be is ConstantPointerRef's. - assert(OldGV->hasOneUse() && "Only one reference should exist!"); - User *U = OldGV->use_back(); // Must be a ConstantPointerRef... - ConstantPointerRef *CPR = cast(U); - - // Change the const pool reference to point to the real global variable - // now. This should drop a use from the OldGV. - CPR->replaceUsesOfWithOnConstant(OldGV, GV); - assert(OldGV->use_empty() && "All uses should be gone now!"); - - // Remove OldGV from the module... - if (GlobalVariable *GVar = dyn_cast(OldGV)) - CurrentModule->getGlobalList().erase(GVar); - else - CurrentModule->getFunctionList().erase(cast(OldGV)); - - // Remove the map entry for the global now that it has been created... + Ret = I->second; GlobalRefs.erase(I); } + return Ret; } - } CurModule; static struct PerFunctionInfo { Function *CurrentFunction; // Pointer to current function being created - std::map Values; // Keep track of numbered definitions - std::map LateResolveValues; - std::vector Types; - std::map LateResolveTypes; - SymbolTable LocalSymtab; + std::map Values; // Keep track of #'d definitions + std::map LateResolveValues; bool isDeclare; // Is this function a forward declararation? + /// BBForwardRefs - When we see forward references to basic blocks, keep + /// track of them here. + std::map > BBForwardRefs; + std::vector NumberedBlocks; + unsigned NextBBNum; + inline PerFunctionInfo() { CurrentFunction = 0; isDeclare = false; @@ -159,35 +152,21 @@ static struct PerFunctionInfo { inline void FunctionStart(Function *M) { CurrentFunction = M; + NextBBNum = 0; } void FunctionDone() { - // If we could not resolve some blocks at parsing time (forward branches) - // resolve the branches now... - ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); + NumberedBlocks.clear(); - // Make sure to resolve any constant expr references that might exist within - // the function we just declared itself. - ValID FID; - if (CurrentFunction->hasName()) { - FID = ValID::create((char*)CurrentFunction->getName().c_str()); - } else { - unsigned Slot = CurrentFunction->getType()->getUniqueID(); - // Figure out which slot number if is... - ValueList &List = CurModule.Values[Slot]; - for (unsigned i = 0; ; ++i) { - assert(i < List.size() && "Function not found!"); - if (List[i] == CurrentFunction) { - FID = ValID::create((int)i); - break; - } - } - } - CurModule.DeclareNewGlobalValue(CurrentFunction, FID); + // Any forward referenced blocks left? + if (!BBForwardRefs.empty()) + ThrowException("Undefined reference to label " + + BBForwardRefs.begin()->first->getName()); + + // Resolve all forward references now. + ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); Values.clear(); // Clear out function local definitions - Types.clear(); // Clear out function local types - LocalSymtab.clear(); // Clear out function local symbol table CurrentFunction = 0; isDeclare = false; } @@ -200,60 +179,29 @@ static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } // Code to handle definitions of all the types //===----------------------------------------------------------------------===// -static int InsertValue(Value *D, - std::map &ValueTab = CurFun.Values) { - if (D->hasName()) return -1; // Is this a numbered definition? +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... - unsigned type = D->getType()->getUniqueID(); - //printf("Values[%d][%d] = %d\n", type, ValueTab[type].size(), D); - ValueList &List = ValueTab[type]; - List.push_back(D); + ValueList &List = ValueTab[V->getType()]; + List.push_back(V); return List.size()-1; } -// TODO: FIXME when Type are not const -static void InsertType(const Type *Ty, std::vector &Types) { - Types.push_back(Ty); -} - static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { switch (D.Type) { - case ValID::NumberVal: { // Is it a numbered definition? - unsigned Num = (unsigned)D.Num; - + case ValID::NumberVal: // Is it a numbered definition? // Module constants occupy the lowest numbered slots... - if (Num < CurModule.Types.size()) - return CurModule.Types[Num]; - - Num -= CurModule.Types.size(); - - // Check that the number is within bounds... - if (Num <= CurFun.Types.size()) - return CurFun.Types[Num]; + if ((unsigned)D.Num < CurModule.Types.size()) + return CurModule.Types[(unsigned)D.Num]; break; - } - case ValID::NameVal: { // Is it a named definition? - std::string Name(D.Name); - SymbolTable *SymTab = 0; - Value *N = 0; - if (inFunctionScope()) { - SymTab = &CurFun.CurrentFunction->getSymbolTable(); - N = SymTab->lookup(Type::TypeTy, Name); - } - - if (N == 0) { - // Symbol table doesn't automatically chain yet... because the function - // hasn't been added to the module... - // - SymTab = &CurModule.CurrentModule->getSymbolTable(); - N = SymTab->lookup(Type::TypeTy, Name); - if (N == 0) break; + case ValID::NameVal: // Is it a named definition? + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { + D.destroy(); // Free old strdup'd memory... + return N; } - - D.destroy(); // Free old strdup'd memory... - return cast(N); - } + break; default: ThrowException("Internal parser error: Invalid symbol type reference!"); } @@ -264,21 +212,25 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { // if (DoNotImprovise) return 0; // Do we just want a null to be returned? - std::map &LateResolver = inFunctionScope() ? - CurFun.LateResolveTypes : CurModule.LateResolveTypes; - - std::map::iterator I = LateResolver.find(D); - if (I != LateResolver.end()) { - return I->second; + + if (inFunctionScope()) { + if (D.Type == ValID::NameVal) + ThrowException("Reference to an undefined type: '" + D.getName() + "'"); + else + ThrowException("Reference to an undefined type: #" + itostr(D.Num)); } + std::map::iterator I =CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) + return I->second; + Type *Typ = OpaqueType::get(); - LateResolver.insert(std::make_pair(D, Typ)); + CurModule.LateResolveTypes.insert(std::make_pair(D, Typ)); return Typ; -} + } static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { - SymbolTable &SymTab = + SymbolTable &SymTab = inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : CurModule.CurrentModule->getSymbolTable(); return SymTab.lookup(Ty, Name); @@ -295,24 +247,23 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { switch (D.Type) { case ValID::NumberVal: { // Is it a numbered definition? - unsigned type = Ty->getUniqueID(); unsigned Num = (unsigned)D.Num; // Module constants occupy the lowest numbered slots... - std::map::iterator VI = CurModule.Values.find(type); + std::map::iterator VI = CurModule.Values.find(Ty); if (VI != CurModule.Values.end()) { - if (Num < VI->second.size()) + if (Num < VI->second.size()) return VI->second[Num]; Num -= VI->second.size(); } // Make sure that our type is within bounds - VI = CurFun.Values.find(type); + 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]; } @@ -324,22 +275,22 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { return N; } - // Check to make sure that "Ty" is an integral type, and that our + // 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)) ThrowException("Signed integral constant '" + - itostr(D.ConstPool64) + "' is invalid for type '" + + itostr(D.ConstPool64) + "' is invalid for type '" + Ty->getDescription() + "'!"); return ConstantSInt::get(Ty, D.ConstPool64); case ValID::ConstUIntVal: // Is it an unsigned const pool reference? if (!ConstantUInt::isValueValidForType(Ty, D.UConstPool64)) { if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64)) { - ThrowException("Integral constant '" + utostr(D.UConstPool64) + + ThrowException("Integral constant '" + utostr(D.UConstPool64) + "' is invalid or out of range!"); } else { // This is really a signed reference. Transmogrify. - return ConstantSInt::get(Ty, D.ConstPool64); + return ConstantSInt::get(Ty, D.ConstPool64); } } else { return ConstantUInt::get(Ty, D.UConstPool64); @@ -349,17 +300,34 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) ThrowException("FP constant invalid for type!!"); return ConstantFP::get(Ty, D.ConstPoolFP); - + case ValID::ConstNullVal: // Is it a null value? if (!isa(Ty)) ThrowException("Cannot create a a non pointer null!"); return ConstantPointerNull::get(cast(Ty)); + + case ValID::ConstUndefVal: // Is it an undef value? + return UndefValue::get(Ty); + + case ValID::ConstZeroVal: // Is it a zero value? + return Constant::getNullValue(Ty); case ValID::ConstantVal: // Fully resolved constant? if (D.ConstantValue->getType() != Ty) ThrowException("Constant expression type different from required type!"); return D.ConstantValue; + case ValID::InlineAsmVal: { // Inline asm expression + const PointerType *PTy = dyn_cast(Ty); + const FunctionType *FTy = + PTy ? dyn_cast(PTy->getElementType()) : 0; + if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) + ThrowException("Invalid type for asm constraint string!"); + InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints, + D.IAD->HasSideEffects); + D.destroy(); // Free InlineAsmDescriptor. + return IA; + } default: assert(0 && "Unhandled case!"); return 0; @@ -369,36 +337,101 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { return 0; } - // getVal - This function is identical to getValNonImprovising, 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 // real thing. // -static Value *getVal(const Type *Ty, const ValID &D) { - assert(Ty != Type::TypeTy && "Should use getTypeVal for types!"); +static Value *getVal(const Type *Ty, const ValID &ID) { + if (Ty == Type::LabelTy) + ThrowException("Cannot use a basic block here"); - // See if the value has already been defined... - Value *V = getValNonImprovising(Ty, D); + // See if the value has already been defined. + Value *V = getValNonImprovising(Ty, ID); if (V) return V; + if (!Ty->isFirstClassType() && !isa(Ty)) + ThrowException("Invalid use of a composite type!"); + // If we reached here, we referenced either a symbol that we don't know about // or an id number that hasn't been read yet. We may be referencing something // forward, so just create an entry to be resolved later and get to it... // - Value *d = 0; - switch (Ty->getPrimitiveID()) { - case Type::LabelTyID: d = new BBPlaceHolder(Ty, D); break; - default: d = new ValuePlaceHolder(Ty, D); break; - } + V = new Argument(Ty); + + // Remember where this forward reference came from. FIXME, shouldn't we try + // to recycle these things?? + CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, + llvmAsmlineno))); - assert(d != 0 && "How did we not make something?"); if (inFunctionScope()) - InsertValue(d, CurFun.LateResolveValues); - else - InsertValue(d, CurModule.LateResolveValues); - return d; + InsertValue(V, CurFun.LateResolveValues); + else + InsertValue(V, CurModule.LateResolveValues); + 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) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + std::string Name; + BasicBlock *BB = 0; + switch (ID.Type) { + default: ThrowException("Illegal label reference " + ID.getName()); + 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. + ThrowException("Redefinition of label " + ID.getName()); + + ID.destroy(); // Free strdup'd memory. + return BB; + } + + // Otherwise this block has not been seen before. + BB = new BasicBlock("", CurFun.CurrentFunction); + if (ID.Type == ValID::NameVal) { + BB->setName(ID.Name); + } else { + CurFun.NumberedBlocks[ID.Num] = BB; + } + + // 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); + } + ID.destroy(); + return BB; } @@ -414,41 +447,46 @@ static Value *getVal(const Type *Ty, const ValID &D) { // and back patchs after we are done. // -// ResolveDefinitions - If we could not resolve some defs at parsing -// time (forward branches, phi functions for loops, etc...) resolve the +// ResolveDefinitions - If we could not resolve some defs at parsing +// time (forward branches, phi functions for loops, etc...) resolve the // defs now... // -static void ResolveDefinitions(std::map &LateResolvers, - std::map *FutureLateResolvers) { +static void +ResolveDefinitions(std::map &LateResolvers, + std::map *FutureLateResolvers) { // Loop over LateResolveDefs fixing up stuff that couldn't be resolved - for (std::map::iterator LRI = LateResolvers.begin(), + 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(); - assert(!isa(V) && "Types should be in LateResolveTypes!"); - ValID &DID = getValIDFromPlaceHolder(V); - Value *TheRealValue = - getValNonImprovising(Type::getUniqueIDType(LRI->first), DID); + std::map >::iterator PHI = + CurModule.PlaceHolderInfo.find(V); + assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!"); + + ValID &DID = PHI->second.first; + + Value *TheRealValue = getValNonImprovising(LRI->first, DID); 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) - ThrowException("Reference to an invalid definition: '" +DID.getName()+ - "' of type '" + V->getType()->getDescription() + "'", - getLineNumFromPlaceHolder(V)); - else - ThrowException("Reference to an invalid definition: #" + - itostr(DID.Num) + " of type '" + - V->getType()->getDescription() + "'", - getLineNumFromPlaceHolder(V)); + if (DID.Type == ValID::NameVal) + ThrowException("Reference to an invalid definition: '" +DID.getName()+ + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); + else + ThrowException("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", + PHI->second.second); } } } @@ -461,131 +499,165 @@ static void ResolveDefinitions(std::map &LateResolvers, // refering to the number can be resolved. Do this now. // static void ResolveTypeTo(char *Name, const Type *ToTy) { - std::vector &Types = inFunctionScope() ? - CurFun.Types : CurModule.Types; + ValID D; + if (Name) D = ValID::create(Name); + else D = ValID::create((int)CurModule.Types.size()); - ValID D; - if (Name) D = ValID::create(Name); - else D = ValID::create((int)Types.size()); - - std::map &LateResolver = inFunctionScope() ? - CurFun.LateResolveTypes : CurModule.LateResolveTypes; - - std::map::iterator I = LateResolver.find(D); - if (I != LateResolver.end()) { - ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); - LateResolver.erase(I); - } + std::map::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); + } } -// ResolveTypes - At this point, all types should be resolved. Any that aren't -// are errors. +// setValueName - Set the specified value to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is free'd by this function. // -static void ResolveTypes(std::map &LateResolveTypes) { - if (!LateResolveTypes.empty()) { - const ValID &DID = LateResolveTypes.begin()->first; +static void setValueName(Value *V, char *NameStr) { + if (NameStr) { + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string - if (DID.Type == ValID::NameVal) - ThrowException("Reference to an invalid type: '" +DID.getName() + "'"); - else - ThrowException("Reference to an invalid type: #" + itostr(DID.Num)); + if (V->getType() == Type::VoidTy) + ThrowException("Can't assign name '" + Name+"' to value with void type!"); + + assert(inFunctionScope() && "Must be in function scope!"); + SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); + if (ST.lookup(V->getType(), Name)) + ThrowException("Redefinition of value named '" + Name + "' in the '" + + V->getType()->getDescription() + "' type plane!"); + + // 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, + bool isConstantGlobal, const Type *Ty, + Constant *Initializer) { + if (isa(Ty)) + ThrowException("Cannot declare global vars of function type!"); + + const PointerType *PTy = PointerType::get(Ty); + + std::string Name; + if (NameStr) { + Name = NameStr; // Copy string + free(NameStr); // Free old string + } + + // See if this global value was forward referenced. If so, recycle the + // object. + ValID ID; + if (!Name.empty()) { + ID = ValID::create((char*)Name.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PTy].size()); + } + + if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { + // Move the global to the end of the list, from whereever it was + // previously inserted. + GlobalVariable *GV = cast(FWGV); + CurModule.CurrentModule->getGlobalList().remove(GV); + CurModule.CurrentModule->getGlobalList().push_back(GV); + GV->setInitializer(Initializer); + GV->setLinkage(Linkage); + GV->setConstant(isConstantGlobal); + 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 (!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; + } + + ThrowException("Redefinition of global variable named '" + Name + + "' in the '" + Ty->getDescription() + "' type plane!"); + } + } -// setValueName - Set the specified value to the name given. The name may be + // Otherwise there is no existing GV to use, create one now. + GlobalVariable *GV = + new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, + CurModule.CurrentModule); + InsertValue(GV, CurModule.Values); + return GV; +} + +// setTypeName - Set the specified type to the name given. The name may be // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is freed by this function. // -// This function returns true if the value has already been defined, but is +// This function returns true if the type has already been defined, but is // allowed to be redefined in the specified context. If the name is a new name -// for the typeplane, false is returned. -// -static bool setValueName(Value *V, char *NameStr) { +// for the type plane, it is inserted and false is returned. +static bool setTypeName(const Type *T, char *NameStr) { + assert(!inFunctionScope() && "Can't give types function-local names!"); if (NameStr == 0) return false; - + std::string Name(NameStr); // Copy string free(NameStr); // Free old string - if (V->getType() == Type::VoidTy) - ThrowException("Can't assign name '" + Name + - "' to a null valued instruction!"); + // We don't allow assigning names to void type + if (T == Type::VoidTy) + ThrowException("Can't assign name '" + Name + "' to the void type!"); + + // Set the type name, checking for conflicts as we do so. + bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T); - SymbolTable &ST = inFunctionScope() ? - CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); + if (AlreadyExists) { // Inserting a name that is already defined??? + const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); + assert(Existing && "Conflict but no matching type?"); - Value *Existing = ST.lookup(V->getType(), Name); - if (Existing) { // Inserting a name that is already defined??? // 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. - if (const Type *Ty = dyn_cast(Existing)) { - if (const OpaqueType *OpTy = dyn_cast(Ty)) { - // We ARE replacing an opaque type! - ((OpaqueType*)OpTy)->refineAbstractTypeTo(cast(V)); - return true; - } + if (const OpaqueType *OpTy = dyn_cast(Existing)) { + // We ARE replacing an opaque type! + const_cast(OpTy)->refineAbstractTypeTo(T); + return true; } - // Otherwise, we are a simple redefinition of a value, check to see if it - // is defined the same as the old one... - if (const Type *Ty = dyn_cast(Existing)) { - if (Ty == cast(V)) return true; // Yes, it's equal. - // std::cerr << "Type: " << Ty->getDescription() << " != " - // << cast(V)->getDescription() << "!\n"; - } else if (const Constant *C = dyn_cast(Existing)) { - if (C == V) return true; // Constants are equal to themselves - } else if (GlobalVariable *EGV = dyn_cast(Existing)) { - // 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 (GlobalVariable *GV = dyn_cast(V)) { - if (!EGV->hasInitializer() || !GV->hasInitializer() || - EGV->getInitializer() == GV->getInitializer()) { - - // Make sure the existing global version gets the initializer! Make - // sure that it also gets marked const if the new version is. - if (GV->hasInitializer() && !EGV->hasInitializer()) - EGV->setInitializer(GV->getInitializer()); - if (GV->isConstant()) - EGV->setConstant(true); - EGV->setLinkage(GV->getLinkage()); - - delete GV; // Destroy the duplicate! - return true; // They are equivalent! - } - } - } + // Otherwise, this is an attempt to redefine a type. That's okay if + // the redefinition is identical to the original. This will be so if + // Existing and T point to the same Type object. In this one case we + // allow the equivalent redefinition. + if (Existing == T) return true; // Yes, it's equal. - ThrowException("Redefinition of value named '" + Name + "' in the '" + - V->getType()->getDescription() + "' type plane!"); + // Any other kind of (non-equivalent) redefinition is an error. + ThrowException("Redefinition of type named '" + Name + "' in the '" + + T->getDescription() + "' type plane!"); } - // Set the name - V->setName(Name, &ST); - - // If we're in function scope - if (inFunctionScope()) { - // Look up the symbol in the function's local symboltable - Existing = CurFun.LocalSymtab.lookup(V->getType(),Name); - - // If it already exists - if (Existing) { - // Bail - ThrowException("Redefinition of value named '" + Name + "' in the '" + - V->getType()->getDescription() + "' type plane!"); - - // otherwise, since it doesn't exist - } else { - // Insert it. - CurFun.LocalSymtab.insert(V); - } - } return false; } - //===----------------------------------------------------------------------===// // Code for handling upreferences in type names... // @@ -593,7 +665,8 @@ static bool setValueName(Value *V, char *NameStr) { // TypeContains - Returns true if Ty directly contains E in it. // static bool TypeContains(const Type *Ty, const Type *E) { - return find(Ty->subtype_begin(), Ty->subtype_end(), E) != Ty->subtype_end(); + return std::find(Ty->subtype_begin(), Ty->subtype_end(), + E) != Ty->subtype_end(); } namespace { @@ -601,7 +674,7 @@ namespace { // NestingLevel - The number of nesting levels that need to be popped before // this type is resolved. unsigned NestingLevel; - + // LastContainedTy - This is the type at the current binding level for the // type. Every time we reduce the nesting level, this gets updated. const Type *LastContainedTy; @@ -628,7 +701,7 @@ static std::vector UpRefs; static PATypeHolder HandleUpRefs(const Type *ty) { if (!ty->isAbstract()) return ty; PATypeHolder Ty(ty); - UR_OUT("Type '" << Ty->getDescription() << + UR_OUT("Type '" << Ty->getDescription() << "' newly formed. Resolving upreferences.\n" << UpRefs.size() << " upreferences active!\n"); @@ -639,15 +712,15 @@ static PATypeHolder HandleUpRefs(const Type *ty) { OpaqueType *TypeToResolve = 0; for (unsigned i = 0; i != UpRefs.size(); ++i) { - UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " - << UpRefs[i].second->getDescription() << ") = " - << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); + UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].second->getDescription() << ") = " + << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); if (TypeContains(Ty, UpRefs[i].LastContainedTy)) { // Decrement level of upreference unsigned Level = --UpRefs[i].NestingLevel; UpRefs[i].LastContainedTy = Ty; UR_OUT(" Uplevel Ref Level = " << Level << "\n"); - if (Level == 0) { // Upreference should be resolved! + if (Level == 0) { // Upreference should be resolved! if (!TypeToResolve) { TypeToResolve = UpRefs[i].UpRefTy; } else { @@ -658,7 +731,7 @@ static PATypeHolder HandleUpRefs(const Type *ty) { UR_OUT(" * Type '" << OldName << "' refined upreference to: " << (const void*)Ty << ", " << Ty->getDescription() << "\n"); } - UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... + UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... --i; // Do not skip the next element... } } @@ -675,101 +748,142 @@ static PATypeHolder HandleUpRefs(const Type *ty) { } -//===----------------------------------------------------------------------===// -// RunVMAsmParser - Define an interface to this parser -//===----------------------------------------------------------------------===// -// -Module *RunVMAsmParser(const std::string &Filename, FILE *F) { - llvmAsmin = F; - CurFilename = Filename; +// common code from the two 'RunVMAsmParser' functions + static Module * RunParser(Module * M) { + llvmAsmlineno = 1; // Reset the current line number... ObsoleteVarArgs = false; + NewVarArgs = false; - // Allocate a new module to read - CurModule.CurrentModule = new Module(Filename); - - try { - yyparse(); // Parse the file. - } catch (...) { - // Clear the symbol table so it doesn't complain when it - // gets destructed - CurFun.LocalSymtab.clear(); - throw; - } + CurModule.CurrentModule = M; + yyparse(); // Parse the file, potentially throwing exception Module *Result = ParserResult; + ParserResult = 0; - // Check to see if they called va_start but not va_arg.. - if (!ObsoleteVarArgs) - if (Function *F = Result->getNamedFunction("llvm.va_start")) - if (F->asize() == 1) { - std::cerr << "WARNING: this file uses obsolete features. " - << "Assemble and disassemble to update it.\n"; - ObsoleteVarArgs = true; - } - + //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) { - // If the user is making use of obsolete varargs intrinsics, adjust them for - // the user. - if (Function *F = Result->getNamedFunction("llvm.va_start")) { - assert(F->asize() == 1 && "Obsolete va_start takes 1 argument!"); + if (ObsoleteVarArgs && NewVarArgs) + ThrowException("This file is corrupt: it uses both new and old style varargs"); - const Type *RetTy = F->getFunctionType()->getParamType(0); - RetTy = cast(RetTy)->getElementType(); - Function *NF = Result->getOrInsertFunction("llvm.va_start", RetTy, 0); + if(ObsoleteVarArgs) { + if(Function* F = Result->getNamedFunction("llvm.va_start")) { + if (F->arg_size() != 0) + ThrowException("Obsolete va_start takes 0 argument!"); + //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()); - Value *V = new CallInst(NF, "", CI); - new StoreInst(V, CI->getOperand(1), CI); + 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")) { - assert(F->asize() == 1 && "Obsolete va_end takes 1 argument!"); - const Type *ArgTy = F->getFunctionType()->getParamType(0); - ArgTy = cast(ArgTy)->getElementType(); - Function *NF = Result->getOrInsertFunction("llvm.va_end", Type::VoidTy, - ArgTy, 0); + if(Function* F = Result->getNamedFunction("llvm.va_end")) { + if(F->arg_size() != 1) + ThrowException("Obsolete va_end takes 1 argument!"); + + //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()); - Value *V = new LoadInst(CI->getOperand(1), "", CI); - new CallInst(NF, V, "", CI); + 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")) { - assert(F->asize() == 2 && "Obsolete va_copy takes 2 argument!"); - const Type *ArgTy = F->getFunctionType()->getParamType(0); - ArgTy = cast(ArgTy)->getElementType(); - Function *NF = Result->getOrInsertFunction("llvm.va_copy", ArgTy, - ArgTy, 0); + if(Function* F = Result->getNamedFunction("llvm.va_copy")) { + if(F->arg_size() != 1) + ThrowException("Obsolete va_copy takes 1 argument!"); + //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()); - Value *V = new CallInst(NF, CI->getOperand(2), "", CI); - new StoreInst(V, CI->getOperand(1), CI); + 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); } } - llvmAsmin = stdin; // F is about to go away, don't use it anymore... - ParserResult = 0; - return Result; + + } + +//===----------------------------------------------------------------------===// +// RunVMAsmParser - Define an interface to this parser +//===----------------------------------------------------------------------===// +// +Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { + set_scan_file(F); + + CurFilename = Filename; + return RunParser(new Module(CurFilename)); } -} // End llvm namespace +Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { + set_scan_string(AsmString); -using namespace llvm; + CurFilename = "from_memory"; + if (M == NULL) { + return RunParser(new Module (CurFilename)); + } else { + return RunParser(M); + } +} %} @@ -789,8 +903,9 @@ using namespace llvm; std::vector > *ArgList; std::vector *ValueList; std::list *TypeList; + // Represent the RHS of PHI node std::list > *PHIList; // Represent the RHS of PHI node + llvm::BasicBlock*> > *PHIList; std::vector > *JumpTable; std::vector *ConstVector; @@ -828,6 +943,8 @@ using namespace llvm; %type JumpTable %type GlobalType // GLOBAL or CONSTANT? %type OptVolatile // 'volatile' or not +%type OptTailCall // TAIL CALL or plain CALL. +%type OptSideEffect // 'sideeffect' or not. %type OptLinkage %type BigOrLittle @@ -856,18 +973,21 @@ using namespace llvm; %token VAR_ID LABELSTR STRINGCONSTANT %type Name OptName OptAssign - +%type OptAlign OptCAlign +%type OptSection SectionString %token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK -%token DECLARE GLOBAL CONSTANT VOLATILE -%token TO DOTDOTDOT NULL_TOK CONST INTERNAL LINKONCE WEAK APPENDING -%token OPAQUE NOT EXTERNAL TARGET ENDIAN POINTERSIZE LITTLE BIG +%token DECLARE GLOBAL CONSTANT SECTION VOLATILE +%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING +%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN +%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT +%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK +%type OptCallingConv -// Basic Block Terminating Operators -%token RET BR SWITCH INVOKE UNWIND +// Basic Block Terminating Operators +%token RET BR SWITCH INVOKE UNWIND UNREACHABLE -// Binary Operators -%type BinaryOps // all the binary operators +// 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 @@ -877,8 +997,10 @@ using namespace llvm; // Other Operators %type ShiftOps -%token PHI_TOK CALL CAST SELECT SHL SHR VAARG VANEXT -%token VA_ARG // FIXME: OBSOLETE +%token PHI_TOK CAST SELECT SHL SHR VAARG +%token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR +%token VAARG_old VANEXT_old //OBSOLETE + %start Module %% @@ -900,13 +1022,12 @@ EINT64VAL : EUINT64VAL { $$ = (int64_t)$1; }; -// Operations that are notably excluded from this list include: +// 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; -BinaryOps : ArithmeticOps | LogicalOps | SetCondOps; ShiftOps : SHL | SHR; @@ -921,8 +1042,8 @@ FPType : FLOAT | DOUBLE; OptAssign : Name '=' { $$ = $1; } - | /*empty*/ { - $$ = 0; + | /*empty*/ { + $$ = 0; }; OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | @@ -931,6 +1052,58 @@ OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | APPENDING { $$ = GlobalValue::AppendingLinkage; } | /*empty*/ { $$ = GlobalValue::ExternalLinkage; }; +OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | + CCC_TOK { $$ = CallingConv::C; } | + CSRETCC_TOK { $$ = CallingConv::CSRet; } | + FASTCC_TOK { $$ = CallingConv::Fast; } | + COLDCC_TOK { $$ = CallingConv::Cold; } | + CC_TOK EUINT64VAL { + if ((unsigned)$2 != $2) + ThrowException("Calling conv too large!"); + $$ = $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($$)) + ThrowException("Alignment must be a power of two!"); +}; +OptCAlign : /*empty*/ { $$ = 0; } | + ',' ALIGN EUINT64VAL { + $$ = $3; + if ($$ != 0 && !isPowerOf2_32($$)) + ThrowException("Alignment must be a power of two!"); +}; + + +SectionString : SECTION STRINGCONSTANT { + for (unsigned i = 0, e = strlen($2); i != e; ++i) + if ($2[i] == '"' || $2[i] == '\\') + ThrowException("Invalid character in section name!"); + $$ = $2; +}; + +OptSection : /*empty*/ { $$ = 0; } | + SectionString { $$ = $1; }; + +// GlobalVarAttributes - Used to pass the attributes string on a global. CurGV +// is set to be the global we are processing. +// +GlobalVarAttributes : /* empty */ {} | + ',' GlobalVarAttribute GlobalVarAttributes {}; +GlobalVarAttribute : SectionString { + CurGV->setSection($1); + free($1); + } + | ALIGN EUINT64VAL { + if ($2 != 0 && !isPowerOf2_32($2)) + ThrowException("Alignment must be a power of two!"); + CurGV->setAlignment($2); + }; + //===----------------------------------------------------------------------===// // Types includes all predefined types... except void, because it can only be // used in specific contexts (function returning void for example). To have @@ -973,8 +1146,9 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference } | UpRTypesV '(' ArgTypeListI ')' { // Function derived type? std::vector Params; - mapto($3->begin(), $3->end(), std::back_inserter(Params), - std::mem_fun_ref(&PATypeHolder::get)); + for (std::list::iterator I = $3->begin(), + E = $3->end(); I != E; ++I) + Params.push_back(*I); bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); @@ -986,10 +1160,22 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2))); delete $4; } + | '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type? + const llvm::Type* ElemTy = $4->get(); + if ((unsigned)$2 != $2) + ThrowException("Unsigned result not equal to signed result"); + if (!ElemTy->isPrimitiveType()) + ThrowException("Elemental type of a PackedType must be primitive"); + if (!isPowerOf2_32($2)) + ThrowException("Vector length should be a power of 2!"); + $$ = new PATypeHolder(HandleUpRefs(PackedType::get(*$4, (unsigned)$2))); + delete $4; + } | '{' TypeListI '}' { // Structure type? std::vector Elements; - mapto($2->begin(), $2->end(), std::back_inserter(Elements), - std::mem_fun_ref(&PATypeHolder::get)); + for (std::list::iterator I = $2->begin(), + E = $2->end(); I != E; ++I) + Elements.push_back(*I); $$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements))); delete $2; @@ -1042,15 +1228,15 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // Verify that we have the correct size... if (NumElements != -1 && NumElements != (int)$3->size()) ThrowException("Type mismatch: constant sized array initialized with " + - utostr($3->size()) + " arguments, but has size of " + - itostr(NumElements) + "!"); + utostr($3->size()) + " arguments, but has size of " + + itostr(NumElements) + "!"); // Verify all elements are correct type! for (unsigned i = 0; i < $3->size(); i++) { if (ETy != (*$3)[i]->getType()) - ThrowException("Element #" + utostr(i) + " is not of type '" + - ETy->getDescription() +"' as required!\nIt is of type '"+ - (*$3)[i]->getType()->getDescription() + "'."); + ThrowException("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*$3)[i]->getType()->getDescription() + "'."); } $$ = ConstantArray::get(ATy, *$3); @@ -1065,7 +1251,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr int NumElements = ATy->getNumElements(); if (NumElements != -1 && NumElements != 0) ThrowException("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; } @@ -1080,15 +1266,16 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr char *EndStr = UnEscapeLexed($3, true); if (NumElements != -1 && NumElements != (EndStr-$3)) ThrowException("Can't build string constant of size " + - itostr((int)(EndStr-$3)) + - " when array has size " + itostr(NumElements) + "!"); + itostr((int)(EndStr-$3)) + + " when array has size " + itostr(NumElements) + "!"); std::vector Vals; if (ETy == Type::SByteTy) { - for (char *C = $3; C != EndStr; ++C) - Vals.push_back(ConstantSInt::get(ETy, *C)); + for (signed char *C = (signed char *)$3; C != (signed char *)EndStr; ++C) + Vals.push_back(ConstantSInt::get(ETy, *C)); } else if (ETy == Type::UByteTy) { - for (char *C = $3; C != EndStr; ++C) - Vals.push_back(ConstantUInt::get(ETy, (unsigned char)*C)); + for (unsigned char *C = (unsigned char *)$3; + C != (unsigned char*)EndStr; ++C) + Vals.push_back(ConstantUInt::get(ETy, *C)); } else { free($3); ThrowException("Cannot build string arrays of non byte sized elements!"); @@ -1097,6 +1284,31 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $$ = ConstantArray::get(ATy, Vals); delete $1; } + | Types '<' ConstVector '>' { // Nonempty unsized arr + const PackedType *PTy = dyn_cast($1->get()); + if (PTy == 0) + ThrowException("Cannot make packed constant with type: '" + + (*$1)->getDescription() + "'!"); + const Type *ETy = PTy->getElementType(); + int NumElements = PTy->getNumElements(); + + // Verify that we have the correct size... + if (NumElements != -1 && NumElements != (int)$3->size()) + ThrowException("Type mismatch: constant sized packed initialized with " + + utostr($3->size()) + " arguments, but has size of " + + itostr(NumElements) + "!"); + + // Verify all elements are correct type! + for (unsigned i = 0; i < $3->size(); i++) { + if (ETy != (*$3)[i]->getType()) + ThrowException("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*$3)[i]->getType()->getDescription() + "'."); + } + + $$ = ConstantPacked::get(PTy, *$3); + delete $1; delete $3; + } | Types '{' ConstVector '}' { const StructType *STy = dyn_cast($1->get()); if (STy == 0) @@ -1138,13 +1350,17 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $$ = ConstantPointerNull::get(PTy); delete $1; } + | Types UNDEF { + $$ = UndefValue::get($1->get()); + delete $1; + } | Types SymbolicValueRef { const PointerType *Ty = dyn_cast($1->get()); if (Ty == 0) ThrowException("Global const reference must be a pointer type!"); // ConstExprs can exist in the body of a function, thus creating - // ConstantPointerRefs whenever they refer to a variable. Because we are in + // GlobalValues whenever they refer to a variable. Because we are in // the context of a function, getValNonImprovising 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 @@ -1167,27 +1383,34 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr // First check to see if the forward references value is already created! PerModuleInfo::GlobalRefsType::iterator I = - CurModule.GlobalRefs.find(std::make_pair(PT, $2)); + CurModule.GlobalRefs.find(std::make_pair(PT, $2)); if (I != CurModule.GlobalRefs.end()) { - V = I->second; // Placeholder already exists, use it... + V = I->second; // Placeholder already exists, use it... $2.destroy(); } else { - // Create a placeholder for the global variable reference... - GlobalVariable *GV = new GlobalVariable(PT->getElementType(), - false, - GlobalValue::ExternalLinkage); - // Keep track of the fact that we have a forward ref to recycle it - CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV)); - - // Must temporarily push this value into the module table... - CurModule.CurrentModule->getGlobalList().push_back(GV); - V = GV; + std::string Name; + if ($2.Type == ValID::NameVal) Name = $2.Name; + + // Create the forward referenced global. + GlobalValue *GV; + if (const FunctionType *FTy = + dyn_cast(PT->getElementType())) { + GV = new Function(FTy, GlobalValue::ExternalLinkage, Name, + CurModule.CurrentModule); + } else { + GV = new GlobalVariable(PT->getElementType(), false, + GlobalValue::ExternalLinkage, 0, + Name, CurModule.CurrentModule); + } + + // Keep track of the fact that we have a forward ref to recycle it + CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV)); + V = GV; } } - GlobalValue *GV = cast(V); - $$ = ConstantPointerRef::get(GV); + $$ = cast(V); delete $1; // Free the type handle } | Types ConstExpr { @@ -1197,7 +1420,10 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr delete $1; } | Types ZEROINITIALIZER { - $$ = Constant::getNullValue($1->get()); + const Type *Ty = $1->get(); + if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) + ThrowException("Cannot create a null initialized value of this type!"); + $$ = Constant::getNullValue(Ty); delete $1; }; @@ -1218,6 +1444,8 @@ ConstVal : SIntType EINT64VAL { // integral constants $$ = ConstantBool::False; } | FPType FPVAL { // Float & Double constants + if (!ConstantFP::isValueValidForType($1, $2)) + ThrowException("Floating point constant invalid for type!!"); $$ = ConstantFP::get($1, $2); }; @@ -1270,9 +1498,40 @@ ConstExpr: CAST '(' ConstVal TO Types ')' { ThrowException("Select operand types must match!"); $$ = ConstantExpr::getSelect($3, $5, $7); } - | BinaryOps '(' ConstVal ',' ConstVal ')' { + | ArithmeticOps '(' ConstVal ',' ConstVal ')' { if ($3->getType() != $5->getType()) ThrowException("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: ThrowException("invalid pointer binary constant expr!"); + } + $$ = ConstantExpr::get($1, ConstantExpr::getCast($3, IntPtrTy), + ConstantExpr::getCast($5, IntPtrTy)); + $$ = ConstantExpr::getCast($$, $3->getType()); + } + } + | LogicalOps '(' ConstVal ',' ConstVal ')' { + if ($3->getType() != $5->getType()) + ThrowException("Logical operator types must match!"); + if (!$3->getType()->isIntegral()) { + if (!isa($3->getType()) || + !cast($3->getType())->getElementType()->isIntegral()) + ThrowException("Logical operator requires integral operands!"); + } + $$ = ConstantExpr::get($1, $3, $5); + } + | SetCondOps '(' ConstVal ',' ConstVal ')' { + if ($3->getType() != $5->getType()) + ThrowException("setcc operand types must match!"); $$ = ConstantExpr::get($1, $3, $5); } | ShiftOps '(' ConstVal ',' ConstVal ')' { @@ -1281,6 +1540,21 @@ ConstExpr: CAST '(' ConstVal TO Types ')' { if (!$3->getType()->isInteger()) ThrowException("Shift constant expression requires integer operand!"); $$ = ConstantExpr::get($1, $3, $5); + } + | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' { + if (!ExtractElementInst::isValidOperands($3, $5)) + ThrowException("Invalid extractelement operands!"); + $$ = ConstantExpr::getExtractElement($3, $5); + } + | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' { + if (!InsertElementInst::isValidOperands($3, $5, $7)) + ThrowException("Invalid insertelement operands!"); + $$ = ConstantExpr::getInsertElement($3, $5, $7); + } + | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' { + if (!ShuffleVectorInst::isValidOperands($3, $5, $7)) + ThrowException("Invalid shufflevector operands!"); + $$ = ConstantExpr::getShuffleVector($3, $5, $7); }; @@ -1319,21 +1593,26 @@ FunctionList : FunctionList Function { | FunctionList FunctionProto { $$ = $1; } + | FunctionList MODULE ASM_TOK AsmBlock { + $$ = $1; + } | FunctionList IMPLEMENTATION { $$ = $1; } | ConstPool { $$ = CurModule.CurrentModule; - // Resolve circular types before we parse the body of the module - ResolveTypes(CurModule.LateResolveTypes); + // 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) + ThrowException("Reference to an undefined type: '"+DID.getName() + "'"); + else + ThrowException("Reference to an undefined type: #" + itostr(DID.Num)); + } }; // ConstPool - Constants with optional names assigned to them. -ConstPool : ConstPool OptAssign CONST ConstVal { - if (!setValueName($4, $2)) - InsertValue($4); - } - | ConstPool OptAssign TYPE TypesV { // Types can be defined in the const pool +ConstPool : ConstPool OptAssign TYPE TypesV { // Eagerly resolve types. This is not an optimization, this is a // requirement that is due to the fact that we could have this: // @@ -1343,65 +1622,52 @@ ConstPool : ConstPool OptAssign CONST ConstVal { // If types are not resolved eagerly, then the two types will not be // determined to be the same type! // - ResolveTypeTo($2, $4->get()); - - // TODO: FIXME when Type are not const - if (!setValueName(const_cast($4->get()), $2)) { - // If this is not a redefinition of a type... - if (!$2) { - InsertType($4->get(), - inFunctionScope() ? CurFun.Types : CurModule.Types); - } + ResolveTypeTo($2, *$4); + + if (!setTypeName(*$4, $2) && !$2) { + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back(*$4); } delete $4; } | ConstPool FunctionProto { // Function prototypes can be in const pool } + | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool + } | ConstPool OptAssign OptLinkage GlobalType ConstVal { - const Type *Ty = $5->getType(); - // Global declarations appear in Constant Pool - Constant *Initializer = $5; - if (Initializer == 0) - ThrowException("Global value initializer is not a constant!"); - - GlobalVariable *GV = new GlobalVariable(Ty, $4, $3, Initializer); - if (!setValueName(GV, $2)) { // If not redefining... - CurModule.CurrentModule->getGlobalList().push_back(GV); - int Slot = InsertValue(GV, CurModule.Values); - - if (Slot != -1) { - CurModule.DeclareNewGlobalValue(GV, ValID::create(Slot)); - } else { - CurModule.DeclareNewGlobalValue(GV, ValID::create( - (char*)GV->getName().c_str())); - } - } + if ($5 == 0) ThrowException("Global value initializer is not a constant!"); + CurGV = ParseGlobalVariable($2, $3, $4, $5->getType(), $5); + } GlobalVarAttributes { + CurGV = 0; } | ConstPool OptAssign EXTERNAL GlobalType Types { - const Type *Ty = *$5; - // Global declarations appear in Constant Pool - GlobalVariable *GV = new GlobalVariable(Ty,$4,GlobalValue::ExternalLinkage); - if (!setValueName(GV, $2)) { // If not redefining... - CurModule.CurrentModule->getGlobalList().push_back(GV); - int Slot = InsertValue(GV, CurModule.Values); - - if (Slot != -1) { - CurModule.DeclareNewGlobalValue(GV, ValID::create(Slot)); - } else { - assert(GV->hasName() && "Not named and not numbered!?"); - CurModule.DeclareNewGlobalValue(GV, ValID::create( - (char*)GV->getName().c_str())); - } - } + CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, + $4, *$5, 0); delete $5; + } GlobalVarAttributes { + CurGV = 0; } | ConstPool TARGET TargetDefinition { } + | ConstPool DEPLIBS '=' LibrariesDefinition { + } | /* empty: end of list */ { }; +AsmBlock : STRINGCONSTANT { + const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); + char *EndStr = UnEscapeLexed($1, true); + std::string NewAsm($1, EndStr); + free($1); + + if (AsmSoFar.empty()) + CurModule.CurrentModule->setModuleInlineAsm(NewAsm); + else + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm); +}; BigOrLittle : BIG { $$ = Module::BigEndian; }; BigOrLittle : LITTLE { $$ = Module::LittleEndian; }; @@ -1416,8 +1682,25 @@ TargetDefinition : ENDIAN '=' BigOrLittle { CurModule.CurrentModule->setPointerSize(Module::Pointer64); else ThrowException("Invalid pointer size: '" + utostr($3) + "'!"); + } + | TRIPLE '=' STRINGCONSTANT { + CurModule.CurrentModule->setTargetTriple($3); + free($3); }; +LibrariesDefinition : '[' LibList ']'; + +LibList : LibList ',' STRINGCONSTANT { + CurModule.CurrentModule->addLibrary($3); + free($3); + } + | STRINGCONSTANT { + CurModule.CurrentModule->addLibrary($1); + free($1); + } + | /* empty: end of list */ { + } + ; //===----------------------------------------------------------------------===// // Rules to match Function Headers @@ -1459,69 +1742,89 @@ ArgList : ArgListH { $$ = 0; }; -FunctionHeaderH : TypesV Name '(' ArgList ')' { - UnEscapeLexed($2); - std::string FunctionName($2); +FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' + OptSection OptAlign { + UnEscapeLexed($3); + std::string FunctionName($3); + free($3); // Free strdup'd memory! - if (!(*$1)->isFirstClassType() && *$1 != Type::VoidTy) + if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) ThrowException("LLVM functions cannot return aggregate types!"); std::vector ParamTypeList; - if ($4) { // If there are arguments... - for (std::vector >::iterator I = $4->begin(); - I != $4->end(); ++I) + if ($5) { // If there are arguments... + for (std::vector >::iterator I = $5->begin(); + I != $5->end(); ++I) ParamTypeList.push_back(I->first->get()); } bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; if (isVarArg) ParamTypeList.pop_back(); - const FunctionType *FT = FunctionType::get(*$1, ParamTypeList, isVarArg); + const FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg); const PointerType *PFT = PointerType::get(FT); - delete $1; + delete $2; + + ValID ID; + if (!FunctionName.empty()) { + ID = ValID::create((char*)FunctionName.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PFT].size()); + } Function *Fn = 0; - // Is the function already in symtab? - if ((Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) { - // Yes it is. If this is the case, either we need to be a forward decl, - // or it needs to be. + // See if this function was forward referenced. If so, recycle the object. + if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { + // Move the function to the end of the list, from whereever it was + // previously inserted. + Fn = cast(FWRef); + 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()) ThrowException("Redefinition of function '" + FunctionName + "'!"); - // Make sure to strip off any argument names so we can't get conflicts... - for (Function::aiterator AI = Fn->abegin(), AE = Fn->aend(); AI != AE; ++AI) - AI->setName(""); + // Make sure to strip off any argument names so we can't get conflicts. + if (Fn->isExternal()) + 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); InsertValue(Fn, CurModule.Values); - CurModule.DeclareNewGlobalValue(Fn, ValID::create($2)); } - free($2); // Free strdup'd memory! CurFun.FunctionStart(Fn); + Fn->setCallingConv($1); + Fn->setAlignment($8); + if ($7) { + Fn->setSection($7); + free($7); + } // Add all of the arguments we parsed to the function... - if ($4) { // Is null if empty... + if ($5) { // Is null if empty... if (isVarArg) { // Nuke the last entry - assert($4->back().first->get() == Type::VoidTy && $4->back().second == 0&& + assert($5->back().first->get() == Type::VoidTy && $5->back().second == 0&& "Not a varargs marker!"); - delete $4->back().first; - $4->pop_back(); // Delete the last entry + delete $5->back().first; + $5->pop_back(); // Delete the last entry } - Function::aiterator ArgIt = Fn->abegin(); - for (std::vector >::iterator I =$4->begin(); - I != $4->end(); ++I, ++ArgIt) { + 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... - if (setValueName(ArgIt, I->second)) // Insert arg into symtab... - assert(0 && "No arg redef allowed!"); - + setValueName(ArgIt, I->second); // Insert arg into symtab... InsertValue(ArgIt); } - delete $4; // We're now done with the argument list + delete $5; // We're now done with the argument list } }; @@ -1533,9 +1836,6 @@ FunctionHeader : OptLinkage FunctionHeaderH BEGIN { // Make sure that we keep track of the linkage type even if there was a // previous "declare". $$->setLinkage($1); - - // Resolve circular types before we parse the body of the function. - ResolveTypes(CurFun.LateResolveTypes); }; END : ENDTOK | '}'; // Allow end of '}' to end a function @@ -1553,6 +1853,13 @@ FunctionProto : DECLARE { CurFun.isDeclare = true; } FunctionHeaderH { // Rules to match Basic Blocks //===----------------------------------------------------------------------===// +OptSideEffect : /* empty */ { + $$ = false; + } + | SIDEEFFECT { + $$ = true; + }; + ConstValueRef : ESINT64VAL { // A reference to a direct constant $$ = ValID::create($1); } @@ -1571,8 +1878,47 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant | NULL_TOK { $$ = ValID::createNull(); } + | UNDEF { + $$ = ValID::createUndef(); + } + | ZEROINITIALIZER { // A vector zero constant. + $$ = ValID::createZeroInit(); + } + | '<' ConstVector '>' { // Nonempty unsized packed vector + const Type *ETy = (*$2)[0]->getType(); + int NumElements = $2->size(); + + PackedType* pt = PackedType::get(ETy, NumElements); + PATypeHolder* PTy = new PATypeHolder( + HandleUpRefs( + PackedType::get( + ETy, + NumElements) + ) + ); + + // Verify all elements are correct type! + for (unsigned i = 0; i < $2->size(); i++) { + if (ETy != (*$2)[i]->getType()) + ThrowException("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '" + + (*$2)[i]->getType()->getDescription() + "'."); + } + + $$ = ValID::create(ConstantPacked::get(pt, *$2)); + delete PTy; delete $2; + } | ConstExpr { $$ = ValID::create($1); + } + | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT { + char *End = UnEscapeLexed($3, true); + std::string AsmStr = std::string($3, End); + End = UnEscapeLexed($5, true); + std::string Constraints = std::string($5, End); + $$ = ValID::createInlineAsm(AsmStr, Constraints, $2); + free($3); + free($5); }; // SymbolicValueRef - Reference to one of two ways of symbolically refering to @@ -1597,10 +1943,10 @@ ResolvedVal : Types ValueRef { }; BasicBlockList : BasicBlockList BasicBlock { - ($$ = $1)->getBasicBlockList().push_back($2); + $$ = $1; } | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks - ($$ = $1)->getBasicBlockList().push_back($2); + $$ = $1; }; @@ -1608,22 +1954,12 @@ BasicBlockList : BasicBlockList BasicBlock { // br, br/cc, switch, ret // BasicBlock : InstructionList OptAssign BBTerminatorInst { - if (setValueName($3, $2)) { assert(0 && "No redefn allowed!"); } + setValueName($3, $2); InsertValue($3); $1->getInstList().push_back($3); InsertValue($1); $$ = $1; - } - | LABELSTR InstructionList OptAssign BBTerminatorInst { - if (setValueName($4, $3)) { assert(0 && "No redefn allowed!"); } - InsertValue($4); - - $2->getInstList().push_back($4); - if (setValueName($2, $1)) { assert(0 && "No label redef allowed!"); } - - InsertValue($2); - $$ = $2; }; InstructionList : InstructionList Inst { @@ -1631,7 +1967,24 @@ InstructionList : InstructionList Inst { $$ = $1; } | /* empty */ { - $$ = CurBB = new BasicBlock(); + $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true); + + // 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 { + $$ = CurBB = getBBVal(ValID::create($1), true); + + // 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, $$); }; BBTerminatorInst : RET ResolvedVal { // Return with a result... @@ -1641,40 +1994,40 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = new ReturnInst(); } | BR LABEL ValueRef { // Unconditional Branch... - $$ = new BranchInst(cast(getVal(Type::LabelTy, $3))); + $$ = new BranchInst(getBBVal($3)); } // Conditional Branch... | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { - $$ = new BranchInst(cast(getVal(Type::LabelTy, $6)), - cast(getVal(Type::LabelTy, $9)), - getVal(Type::BoolTy, $3)); + $$ = new BranchInst(getBBVal($6), getBBVal($9), getVal(Type::BoolTy, $3)); } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' { - SwitchInst *S = new SwitchInst(getVal($2, $3), - cast(getVal(Type::LabelTy, $6))); + SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6), $8->size()); $$ = S; std::vector >::iterator I = $8->begin(), E = $8->end(); - for (; I != E; ++I) - S->addCase(I->first, I->second); + for (; I != E; ++I) { + if (ConstantInt *CI = dyn_cast(I->first)) + S->addCase(CI, I->second); + else + ThrowException("Switch case is constant, but not a simple integer!"); + } delete $8; } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' { - SwitchInst *S = new SwitchInst(getVal($2, $3), - cast(getVal(Type::LabelTy, $6))); + SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6), 0); $$ = S; } - | INVOKE TypesV ValueRef '(' ValueRefListE ')' TO ResolvedVal - UNWIND ResolvedVal { + | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')' + TO LABEL ValueRef UNWIND LABEL ValueRef { const PointerType *PFTy; const FunctionType *Ty; - if (!(PFTy = dyn_cast($2->get())) || + if (!(PFTy = dyn_cast($3->get())) || !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - if ($5) { - for (std::vector::iterator I = $5->begin(), E = $5->end(); + if ($6) { + for (std::vector::iterator I = $6->begin(), E = $6->end(); I != E; ++I) ParamTypes.push_back((*I)->getType()); } @@ -1682,20 +2035,17 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; if (isVarArg) ParamTypes.pop_back(); - Ty = FunctionType::get($2->get(), ParamTypes, isVarArg); + Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); PFTy = PointerType::get(Ty); } - Value *V = getVal(PFTy, $3); // Get the function we're calling... + Value *V = getVal(PFTy, $4); // Get the function we're calling... - BasicBlock *Normal = dyn_cast($8); - BasicBlock *Except = dyn_cast($10); - - if (Normal == 0 || Except == 0) - ThrowException("Invoke instruction without label destinations!"); + BasicBlock *Normal = getBBVal($10); + BasicBlock *Except = getBBVal($13); // Create the call node... - if (!$5) { // Has no arguments? + if (!$6) { // Has no arguments? $$ = new InvokeInst(V, Normal, Except, std::vector()); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified @@ -1703,23 +2053,28 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... // FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - std::vector::iterator ArgI = $5->begin(), ArgE = $5->end(); + std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); + if ((*ArgI)->getType() != *I) + ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" + + (*I)->getDescription() + "'!"); if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - ThrowException("Invalid number of parameters detected!"); + ThrowException("Invalid number of parameters detected!"); - $$ = new InvokeInst(V, Normal, Except, *$5); + $$ = new InvokeInst(V, Normal, Except, *$6); } - delete $2; - delete $5; + cast($$)->setCallingConv($2); + + delete $3; + delete $6; } | UNWIND { $$ = new UnwindInst(); + } + | UNREACHABLE { + $$ = new UnreachableInst(); }; @@ -1730,7 +2085,7 @@ JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { if (V == 0) ThrowException("May only switch on a constant pool value!"); - $$->push_back(std::make_pair(V, cast(getVal($5, $6)))); + $$->push_back(std::make_pair(V, getBBVal($6))); } | IntType ConstValueRef ',' LABEL ValueRef { $$ = new std::vector >(); @@ -1739,26 +2094,25 @@ JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { if (V == 0) ThrowException("May only switch on a constant pool value!"); - $$->push_back(std::make_pair(V, cast(getVal($4, $5)))); + $$->push_back(std::make_pair(V, getBBVal($5))); }; Inst : OptAssign InstVal { // Is this definition named?? if so, assign the name... - if (setValueName($2, $1)) { assert(0 && "No redefin allowed!"); } + setValueName($2, $1); InsertValue($2); $$ = $2; }; PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes $$ = new std::list >(); - $$->push_back(std::make_pair(getVal(*$1, $3), - cast(getVal(Type::LabelTy, $5)))); + $$->push_back(std::make_pair(getVal(*$1, $3), getBBVal($5))); delete $1; } | PHIList ',' '[' ValueRef ',' ValueRef ']' { $$ = $1; $1->push_back(std::make_pair(getVal($1->front().first->getType(), $4), - cast(getVal(Type::LabelTy, $6)))); + getBBVal($6))); }; @@ -1774,23 +2128,43 @@ ValueRefList : ResolvedVal { // Used for call statements, and memory insts... // ValueRefListE - Just like ValueRefList, except that it may also be empty! ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; }; +OptTailCall : TAIL CALL { + $$ = true; + } + | CALL { + $$ = false; + }; + + + InstVal : ArithmeticOps Types ValueRef ',' ValueRef { - if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint()) - ThrowException("Arithmetic operator requires integer or FP operands!"); + if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() && + !isa((*$2).get())) + ThrowException( + "Arithmetic operator requires integer, FP, or packed operands!"); + if (isa((*$2).get()) && $1 == Instruction::Rem) + ThrowException("Rem not supported on packed types!"); $$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5)); if ($$ == 0) ThrowException("binary operator returned null!"); delete $2; } | LogicalOps Types ValueRef ',' ValueRef { - if (!(*$2)->isIntegral()) - ThrowException("Logical operator requires integral operands!"); + if (!(*$2)->isIntegral()) { + if (!isa($2->get()) || + !cast($2->get())->getElementType()->isIntegral()) + ThrowException("Logical operator requires integral operands!"); + } $$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5)); if ($$ == 0) ThrowException("binary operator returned null!"); delete $2; } | SetCondOps Types ValueRef ',' ValueRef { + if(isa((*$2).get())) { + ThrowException( + "PackedTypes currently not supported in setcc instructions!"); + } $$ = new SetCondInst($1, getVal(*$2, $3), getVal(*$2, $5)); if ($$ == 0) ThrowException("binary operator returned null!"); @@ -1829,61 +2203,91 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { ThrowException("select value types should match!"); $$ = new SelectInst($2, $4, $6); } - | VA_ARG ResolvedVal ',' Types { - // FIXME: This is emulation code for an obsolete syntax. This should be - // removed at some point. - if (!ObsoleteVarArgs) { - std::cerr << "WARNING: this file uses obsolete features. " - << "Assemble and disassemble to update it.\n"; - ObsoleteVarArgs = true; - } - - // First, load the valist... - Instruction *CurVAList = new LoadInst($2, ""); - CurBB->getInstList().push_back(CurVAList); - - // Emit the vaarg instruction. - $$ = new VAArgInst(CurVAList, *$4); - - // Now we must advance the pointer and update it in memory. - Instruction *TheVANext = new VANextInst(CurVAList, *$4); - CurBB->getInstList().push_back(TheVANext); - - CurBB->getInstList().push_back(new StoreInst(TheVANext, $2)); - delete $4; - } | VAARG ResolvedVal ',' Types { + NewVarArgs = true; $$ = new VAArgInst($2, *$4); delete $4; } - | VANEXT ResolvedVal ',' Types { - $$ = new VANextInst($2, *$4); + | 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; } + | 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; + } + | EXTRACTELEMENT ResolvedVal ',' ResolvedVal { + if (!ExtractElementInst::isValidOperands($2, $4)) + ThrowException("Invalid extractelement operands!"); + $$ = new ExtractElementInst($2, $4); + } + | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal { + if (!InsertElementInst::isValidOperands($2, $4, $6)) + ThrowException("Invalid insertelement operands!"); + $$ = new InsertElementInst($2, $4, $6); + } + | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal { + if (!ShuffleVectorInst::isValidOperands($2, $4, $6)) + ThrowException("Invalid shufflevector operands!"); + $$ = new ShuffleVectorInst($2, $4, $6); + } | PHI_TOK PHIList { const Type *Ty = $2->front().first->getType(); if (!Ty->isFirstClassType()) ThrowException("PHI node operands must be of first class type!"); $$ = new PHINode(Ty); - $$->op_reserve($2->size()*2); + ((PHINode*)$$)->reserveOperandSpace($2->size()); while ($2->begin() != $2->end()) { if ($2->front().first->getType() != Ty) - ThrowException("All elements of a PHI node must be of the same type!"); + ThrowException("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... - } - | CALL TypesV ValueRef '(' ValueRefListE ')' { + } + | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { const PointerType *PFTy; const FunctionType *Ty; - if (!(PFTy = dyn_cast($2->get())) || + if (!(PFTy = dyn_cast($3->get())) || !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; - if ($5) { - for (std::vector::iterator I = $5->begin(), E = $5->end(); + if ($6) { + for (std::vector::iterator I = $6->begin(), E = $6->end(); I != E; ++I) ParamTypes.push_back((*I)->getType()); } @@ -1891,14 +2295,17 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; if (isVarArg) ParamTypes.pop_back(); - Ty = FunctionType::get($2->get(), ParamTypes, isVarArg); + if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy) + ThrowException("LLVM functions cannot return aggregate types!"); + + Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); PFTy = PointerType::get(Ty); } - Value *V = getVal(PFTy, $3); // Get the function we're calling... + Value *V = getVal(PFTy, $4); // Get the function we're calling... // Create the call node... - if (!$5) { // Has no arguments? + if (!$6) { // Has no arguments? // Make sure no arguments is a good thing! if (Ty->getNumParams() != 0) ThrowException("No arguments passed to a function that " @@ -1911,20 +2318,22 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { // FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator E = Ty->param_end(); - std::vector::iterator ArgI = $5->begin(), ArgE = $5->end(); + std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); + if ((*ArgI)->getType() != *I) + ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" + + (*I)->getDescription() + "'!"); if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - ThrowException("Invalid number of parameters detected!"); + ThrowException("Invalid number of parameters detected!"); - $$ = new CallInst(V, *$5); + $$ = new CallInst(V, *$6); } - delete $2; - delete $5; + cast($$)->setTailCall($1); + cast($$)->setCallingConv($2); + delete $3; + delete $6; } | MemoryInst { $$ = $1; @@ -1946,20 +2355,21 @@ OptVolatile : VOLATILE { }; -MemoryInst : MALLOC Types { - $$ = new MallocInst(*$2); + +MemoryInst : MALLOC Types OptCAlign { + $$ = new MallocInst(*$2, 0, $3); delete $2; } - | MALLOC Types ',' UINT ValueRef { - $$ = new MallocInst(*$2, getVal($4, $5)); + | MALLOC Types ',' UINT ValueRef OptCAlign { + $$ = new MallocInst(*$2, getVal($4, $5), $6); delete $2; } - | ALLOCA Types { - $$ = new AllocaInst(*$2); + | ALLOCA Types OptCAlign { + $$ = new AllocaInst(*$2, 0, $3); delete $2; } - | ALLOCA Types ',' UINT ValueRef { - $$ = new AllocaInst(*$2, getVal($4, $5)); + | ALLOCA Types ',' UINT ValueRef OptCAlign { + $$ = new AllocaInst(*$2, getVal($4, $5), $6); delete $2; } | FREE ResolvedVal { @@ -1972,7 +2382,10 @@ MemoryInst : MALLOC Types { | OptVolatile LOAD Types ValueRef { if (!isa($3->get())) ThrowException("Can't load from nonpointer type: " + - (*$3)->getDescription()); + (*$3)->getDescription()); + if (!cast($3->get())->getElementType()->isFirstClassType()) + ThrowException("Can't load from pointer of non-first-class type: " + + (*$3)->getDescription()); $$ = new LoadInst(getVal(*$3, $4), "", $1); delete $3; }