X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y;h=51fe7c9cc5c707af04549bba38ae1003124a48d5;hb=b775bbc12156448e12f15762c29ba68bc5d37f1c;hp=1fd8782daea2d570b09494ef3b1cb1d9a6d31168;hpb=551ccae044b0ff658fe629dd67edd5ffe75d10e8;p=oota-llvm.git diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 1fd8782daea..51fe7c9cc5c 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,16 +13,34 @@ %{ #include "ParserInternals.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" #include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Streams.h" #include -#include #include #include +// 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 +// an error situation. So, whenever we want an error to occur, the GenerateError +// function (see bottom of file) sets TriggerError. Then, at the end of each +// production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR +// (a goto) to put YACC in error state. Furthermore, several calls to +// GenerateError are made from inside productions and they must simulate the +// previous exception behavior by exiting the production immediately. We have +// replaced these with the GEN_ERROR macro which calls GeneratError and then +// immediately invokes YYERROR. This would be so much cleaner if it was a +// recursive descent parser. +static bool TriggerError = false; +#define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } } +#define GEN_ERROR(msg) { GenerateError(msg); YYERROR; } + int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); @@ -39,27 +57,24 @@ static Module *ParserResult; // //#define DEBUG_UPREFS 1 #ifdef DEBUG_UPREFS -#define UR_OUT(X) std::cerr << X +#define UR_OUT(X) llvm_cerr << X #else #define UR_OUT(X) #endif #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 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; @@ -69,7 +84,7 @@ static struct PerModuleInfo { std::map LateResolveTypes; /// PlaceHolderInfo - When temporary placeholder objects are created, remember - /// how they were referenced and one which line of the input they came from so + /// 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; @@ -88,19 +103,22 @@ static struct PerModuleInfo { // are resolved when the constant pool has been completely parsed. // ResolveDefinitions(LateResolveValues); + if (TriggerError) + return; // Check to make sure that all global value forward references have been // resolved! // 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() + " " + I->first.second.getName() + "\n"; } - ThrowException(UndefinedReferences); + GenerateError(UndefinedReferences); + return; } Values.clear(); // Clear out function local definitions @@ -108,7 +126,6 @@ static struct PerModuleInfo { CurrentModule = 0; } - // 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. @@ -128,11 +145,10 @@ static struct PerModuleInfo { static struct PerFunctionInfo { Function *CurrentFunction; // Pointer to current function being created - std::map Values; // Keep track of #'d definitions + std::map Values; // Keep track of #'d definitions std::map LateResolveValues; - std::vector Types; - std::map LateResolveTypes; - bool isDeclare; // Is this function a forward declararation? + bool isDeclare; // Is this function a forward declararation? + GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration. /// BBForwardRefs - When we see forward references to basic blocks, keep /// track of them here. @@ -143,6 +159,7 @@ static struct PerFunctionInfo { inline PerFunctionInfo() { CurrentFunction = 0; isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; } inline void FunctionStart(Function *M) { @@ -154,17 +171,19 @@ static struct PerFunctionInfo { NumberedBlocks.clear(); // Any forward referenced blocks left? - if (!BBForwardRefs.empty()) - ThrowException("Undefined reference to label " + - BBForwardRefs.begin()->second.first.getName()); + if (!BBForwardRefs.empty()) { + GenerateError("Undefined reference to label " + + BBForwardRefs.begin()->first->getName()); + return; + } // Resolve all forward references now. ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); Values.clear(); // Clear out function local definitions - Types.clear(); // Clear out function local types CurrentFunction = 0; isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; } } CurFun; // Info for the current function... @@ -189,7 +208,7 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { switch (D.Type) { case ValID::NumberVal: // Is it a numbered definition? // Module constants occupy the lowest numbered slots... - if ((unsigned)D.Num < CurModule.Types.size()) + if ((unsigned)D.Num < CurModule.Types.size()) return CurModule.Types[(unsigned)D.Num]; break; case ValID::NameVal: // Is it a named definition? @@ -199,7 +218,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { } break; default: - ThrowException("Internal parser error: Invalid symbol type reference!"); + GenerateError("Internal parser error: Invalid symbol type reference!"); + return 0; } // If we reached here, we referenced either a symbol that we don't know about @@ -208,21 +228,28 @@ 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) { + GenerateError("Reference to an undefined type: '" + D.getName() + "'"); + return 0; + } else { + GenerateError("Reference to an undefined type: #" + itostr(D.Num)); + return 0; + } } + 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); @@ -233,9 +260,11 @@ static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { // it. Otherwise return null. // static Value *getValNonImprovising(const Type *Ty, const ValID &D) { - if (isa(Ty)) - ThrowException("Functions are not values and " + if (isa(Ty)) { + GenerateError("Functions are not values and " "must be referenced as pointers"); + return 0; + } switch (D.Type) { case ValID::NumberVal: { // Is it a numbered definition? @@ -244,7 +273,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { // 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()) + if (Num < VI->second.size()) return VI->second[Num]; Num -= VI->second.size(); } @@ -255,7 +284,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { // Check that the number is within bounds... if (VI->second.size() <= Num) return 0; - + return VI->second[Num]; } @@ -267,42 +296,70 @@ 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 '" + + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Signed integral constant '" + + itostr(D.ConstPool64) + "' is invalid for type '" + Ty->getDescription() + "'!"); - return ConstantSInt::get(Ty, D.ConstPool64); + return 0; + } + return ConstantInt::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) + + if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) { + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Integral constant '" + utostr(D.UConstPool64) + "' is invalid or out of range!"); + return 0; } else { // This is really a signed reference. Transmogrify. - return ConstantSInt::get(Ty, D.ConstPool64); + return ConstantInt::get(Ty, D.ConstPool64); } } 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)) - ThrowException("FP constant invalid for type!!"); + if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { + 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)) - ThrowException("Cannot create a a non pointer null!"); + if (!isa(Ty)) { + GenerateError("Cannot create a a non pointer null!"); + return 0; + } 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!"); + if (D.ConstantValue->getType() != Ty) { + GenerateError("Constant expression type different from required type!"); + return 0; + } 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)) { + GenerateError("Invalid type for asm constraint string!"); + return 0; + } + 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; @@ -319,12 +376,20 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) { // real thing. // static Value *getVal(const Type *Ty, const ValID &ID) { - if (Ty == Type::LabelTy) - ThrowException("Cannot use a basic block here"); + if (Ty == Type::LabelTy) { + GenerateError("Cannot use a basic block here"); + return 0; + } // See if the value has already been defined. Value *V = getValNonImprovising(Ty, ID); if (V) return V; + if (TriggerError) return 0; + + if (!Ty->isFirstClassType() && !isa(Ty)) { + GenerateError("Invalid use of a composite type!"); + return 0; + } // 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 @@ -339,7 +404,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); - else + else InsertValue(V, CurModule.LateResolveValues); return V; } @@ -356,7 +421,9 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { std::string Name; BasicBlock *BB = 0; switch (ID.Type) { - default: ThrowException("Illegal label reference " + ID.getName()); + 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); @@ -375,9 +442,11 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { // 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)) + if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) { // The existing value was a definition, not a forward reference. - ThrowException("Redefinition of label " + ID.getName()); + GenerateError("Redefinition of label " + ID.getName()); + return 0; + } ID.destroy(); // Free strdup'd memory. return BB; @@ -402,7 +471,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { CurFun.CurrentFunction->getBasicBlockList().remove(BB); CurFun.CurrentFunction->getBasicBlockList().push_back(BB); } - + ID.destroy(); return BB; } @@ -419,12 +488,13 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { // 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(), E = LateResolvers.end(); LRI != E; ++LRI) { @@ -440,6 +510,8 @@ static void ResolveDefinitions(std::map &LateResolvers, ValID &DID = PHI->second.first; Value *TheRealValue = getValNonImprovising(LRI->first, DID); + if (TriggerError) + return; if (TheRealValue) { V->replaceAllUsesWith(TheRealValue); delete V; @@ -449,15 +521,18 @@ static void ResolveDefinitions(std::map &LateResolvers, // resolver table InsertValue(V, *FutureLateResolvers); } else { - if (DID.Type == ValID::NameVal) - ThrowException("Reference to an invalid definition: '" +DID.getName()+ + if (DID.Type == ValID::NameVal) { + GenerateError("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 '" + + return; + } else { + GenerateError("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + V->getType()->getDescription() + "'", PHI->second.second); + return; + } } } } @@ -470,34 +545,15 @@ 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)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); - } -} + ValID D; + if (Name) D = ValID::create(Name); + else D = ValID::create((int)CurModule.Types.size()); -// ResolveTypes - At this point, all types should be resolved. Any that aren't -// are errors. -// -static void ResolveTypes(std::map &LateResolveTypes) { - if (!LateResolveTypes.empty()) { - const ValID &DID = LateResolveTypes.begin()->first; - - if (DID.Type == ValID::NameVal) - ThrowException("Reference to an invalid type: '" +DID.getName() + "'"); - else - ThrowException("Reference to an invalid type: #" + itostr(DID.Num)); + std::map::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); } } @@ -510,29 +566,36 @@ static void setValueName(Value *V, char *NameStr) { std::string Name(NameStr); // Copy string free(NameStr); // Free old string - if (V->getType() == Type::VoidTy) - ThrowException("Can't assign name '" + Name+"' to value with void type!"); - + if (V->getType() == Type::VoidTy) { + GenerateError("Can't assign name '" + Name+"' to value with void type!"); + return; + } + 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 '" + + if (ST.lookup(V->getType(), Name)) { + GenerateError("Redefinition of value named '" + Name + "' in the '" + V->getType()->getDescription() + "' type plane!"); - + return; + } + // Set the name. - V->setName(Name, &ST); + V->setName(Name); } } /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, /// this is a declaration, otherwise it is a definition. -static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, - bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { - if (isa(Ty)) - ThrowException("Cannot declare global vars of function type!"); +static GlobalVariable * +ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, + bool isConstantGlobal, const Type *Ty, + Constant *Initializer) { + if (isa(Ty)) { + GenerateError("Cannot declare global vars of function type!"); + return 0; + } - const PointerType *PTy = PointerType::get(Ty); + const PointerType *PTy = PointerType::get(Ty); std::string Name; if (NameStr) { @@ -542,7 +605,7 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, // See if this global value was forward referenced. If so, recycle the // object. - ValID ID; + ValID ID; if (!Name.empty()) { ID = ValID::create((char*)Name.c_str()); } else { @@ -550,7 +613,7 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, } if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { - // Move the global to the end of the list, from whereever it was + // Move the global to the end of the list, from whereever it was // previously inserted. GlobalVariable *GV = cast(FWGV); CurModule.CurrentModule->getGlobalList().remove(GV); @@ -559,7 +622,7 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, GV->setLinkage(Linkage); GV->setConstant(isConstantGlobal); InsertValue(GV, CurModule.Values); - return; + return GV; } // If this global has a name, check to see if there is already a definition @@ -568,10 +631,10 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, 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 = + 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 + // 1. If at least one of the globals is uninitialized or // 2. If both initializers have the same value. // if (!EGV->hasInitializer() || !Initializer || @@ -584,19 +647,21 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, if (isConstantGlobal) EGV->setConstant(true); EGV->setLinkage(Linkage); - return; + return EGV; } - ThrowException("Redefinition of global variable named '" + Name + + 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, + 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 @@ -609,13 +674,15 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, 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 // We don't allow assigning names to void type - if (T == Type::VoidTy) - ThrowException("Can't assign name '" + Name + "' to the void type!"); + if (T == Type::VoidTy) { + GenerateError("Can't assign name '" + Name + "' to the void type!"); + return false; + } // Set the type name, checking for conflicts as we do so. bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T); @@ -639,7 +706,7 @@ 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. - ThrowException("Redefinition of type named '" + Name + "' in the '" + + GenerateError("Redefinition of type named '" + Name + "' in the '" + T->getDescription() + "' type plane!"); } @@ -653,7 +720,8 @@ static bool setTypeName(const Type *T, 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 { @@ -661,7 +729,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; @@ -686,9 +754,12 @@ static std::vector UpRefs; /// thus we can complete the cycle. /// static PATypeHolder HandleUpRefs(const Type *ty) { - if (!ty->isAbstract()) return ty; + // If Ty isn't abstract, or if there are no up-references in it, then there is + // nothing to resolve here. + if (!ty->isAbstract() || UpRefs.empty()) return ty; + PATypeHolder Ty(ty); - UR_OUT("Type '" << Ty->getDescription() << + UR_OUT("Type '" << Ty->getDescription() << "' newly formed. Resolving upreferences.\n" << UpRefs.size() << " upreferences active!\n"); @@ -699,15 +770,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() << ") = " + 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 { @@ -734,89 +805,51 @@ static PATypeHolder HandleUpRefs(const Type *ty) { return Ty; } +// common code from the two 'RunVMAsmParser' functions +static Module* RunParser(Module * M) { -//===----------------------------------------------------------------------===// -// RunVMAsmParser - Define an interface to this parser -//===----------------------------------------------------------------------===// -// -Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { - llvmAsmin = F; - CurFilename = Filename; llvmAsmlineno = 1; // Reset the current line number... - ObsoleteVarArgs = false; + NewVarArgs = false; + CurModule.CurrentModule = M; - // Allocate a new module to read - CurModule.CurrentModule = new Module(Filename); + // Check to make sure the parser succeeded + if (yyparse()) { + if (ParserResult) + delete ParserResult; + return 0; + } - yyparse(); // Parse the file, potentially throwing exception + // 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; - // 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; - } + return Result; +} - 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!"); - - const Type *RetTy = F->getFunctionType()->getParamType(0); - RetTy = cast(RetTy)->getElementType(); - Function *NF = Result->getOrInsertFunction("llvm.va_start", RetTy, 0); - - while (!F->use_empty()) { - CallInst *CI = cast(F->use_back()); - Value *V = new CallInst(NF, "", CI); - new StoreInst(V, CI->getOperand(1), CI); - 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); - - while (!F->use_empty()) { - CallInst *CI = cast(F->use_back()); - Value *V = new LoadInst(CI->getOperand(1), "", CI); - new CallInst(NF, V, "", CI); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } +//===----------------------------------------------------------------------===// +// RunVMAsmParser - Define an interface to this parser +//===----------------------------------------------------------------------===// +// +Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { + set_scan_file(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); - - 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); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - } + CurFilename = Filename; + return RunParser(new Module(CurFilename)); +} - llvmAsmin = stdin; // F is about to go away, don't use it anymore... - ParserResult = 0; +Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { + set_scan_string(AsmString); - return Result; + CurFilename = "from_memory"; + if (M == NULL) { + return RunParser(new Module (CurFilename)); + } else { + return RunParser(M); + } } %} @@ -837,8 +870,9 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { 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; @@ -851,13 +885,16 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { 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::Module::Endianness Endianness; + llvm::ICmpInst::Predicate IPredicate; + llvm::FCmpInst::Predicate FPredicate; } %type Module FunctionList @@ -876,6 +913,8 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { %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 @@ -904,29 +943,46 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { %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 TRIPLE ENDIAN POINTERSIZE LITTLE BIG -%token DEPLIBS - -// Basic Block Terminating Operators -%token RET BR SWITCH INVOKE UNWIND - -// Binary Operators +%token DECLARE GLOBAL CONSTANT SECTION VOLATILE +%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING +%token DLLIMPORT DLLEXPORT EXTERN_WEAK +%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 +%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK +%token DATALAYOUT +%type OptCallingConv + +// 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 +%token ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR +%token SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comparators +%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 CALL CAST SELECT SHL SHR VAARG VANEXT -%token VA_ARG // FIXME: OBSOLETE +%token PHI_TOK SELECT SHL LSHR ASHR VAARG +%token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR + %start Module %% @@ -936,26 +992,48 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { INTVAL : SINTVAL; INTVAL : UINTVAL { if ($1 > (uint32_t)INT32_MAX) // Outside of my range! - ThrowException("Value too large for type!"); + 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! - ThrowException("Value too large for type!"); + GEN_ERROR("Value too large for type!"); $$ = (int64_t)$1; + CHECK_FOR_ERROR }; -// 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; +ArithmeticOps: ADD | SUB | MUL | UDIV | SDIV | FDIV | UREM | SREM | FREM; LogicalOps : AND | OR | XOR; SetCondOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE; - -ShiftOps : SHL | SHR; +CastOps : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | BITCAST | + UITOFP | SITOFP | FPTOUI | FPTOSI | INTTOPTR | PTRTOINT; +ShiftOps : SHL | LSHR | ASHR; +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. @@ -967,16 +1045,81 @@ FPType : FLOAT | DOUBLE; // OptAssign - Value producing statements have an optional assignment component OptAssign : Name '=' { $$ = $1; + CHECK_FOR_ERROR } - | /*empty*/ { - $$ = 0; + | /*empty*/ { + $$ = 0; + CHECK_FOR_ERROR }; -OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | - LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } | - WEAK { $$ = GlobalValue::WeakLinkage; } | - APPENDING { $$ = GlobalValue::AppendingLinkage; } | - /*empty*/ { $$ = GlobalValue::ExternalLinkage; }; +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; }; + +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!"); + $$ = $2; + CHECK_FOR_ERROR + }; + +// 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!"); + CHECK_FOR_ERROR +}; +OptCAlign : /*empty*/ { $$ = 0; } | + ',' ALIGN EUINT64VAL { + $$ = $3; + if ($$ != 0 && !isPowerOf2_32($$)) + GEN_ERROR("Alignment must be a power of two!"); + CHECK_FOR_ERROR +}; + + +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!"); + $$ = $2; + CHECK_FOR_ERROR +}; + +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); + CHECK_FOR_ERROR + } + | ALIGN EUINT64VAL { + if ($2 != 0 && !isPowerOf2_32($2)) + 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 @@ -990,8 +1133,9 @@ UpRTypesV : UpRTypes | VOID { $$ = new PATypeHolder($1); }; Types : UpRTypes { if (!UpRefs.empty()) - ThrowException("Invalid upreference in type: " + (*$1)->getDescription()); + GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); $$ = $1; + CHECK_FOR_ERROR }; @@ -1001,63 +1145,78 @@ PrimType : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT ; PrimType : LONG | ULONG | FLOAT | DOUBLE | TYPE | LABEL; UpRTypes : OPAQUE { $$ = new PATypeHolder(OpaqueType::get()); + CHECK_FOR_ERROR } | PrimType { $$ = new PATypeHolder($1); + CHECK_FOR_ERROR }; UpRTypes : SymbolicValueRef { // Named types are also simple types... - $$ = new PATypeHolder(getTypeVal($1)); + 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) ThrowException("Value out of range!"); + 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? 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(); $$ = new PATypeHolder(HandleUpRefs(FunctionType::get(*$1,Params,isVarArg))); delete $3; // Delete the argument list delete $1; // Delete the return type handle + CHECK_FOR_ERROR } | '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type? $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2))); delete $4; + CHECK_FOR_ERROR } | '<' 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 ((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 (!isPowerOf2_32($2)) + GEN_ERROR("Vector length should be a power of 2!"); $$ = new PATypeHolder(HandleUpRefs(PackedType::get(*$4, (unsigned)$2))); delete $4; + CHECK_FOR_ERROR } | '{' 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; + CHECK_FOR_ERROR } | '{' '}' { // Empty structure type? $$ = 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; + CHECK_FOR_ERROR }; // TypeList - Used for struct declarations and as a basis for function type @@ -1066,21 +1225,26 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference TypeListI : UpRTypes { $$ = new std::list(); $$->push_back(*$1); delete $1; + CHECK_FOR_ERROR } | TypeListI ',' UpRTypes { ($$=$1)->push_back(*$3); delete $3; + CHECK_FOR_ERROR }; // ArgTypeList - List of types for a function type declaration... ArgTypeListI : TypeListI | TypeListI ',' DOTDOTDOT { ($$=$1)->push_back(Type::VoidTy); + CHECK_FOR_ERROR } | DOTDOTDOT { ($$ = new std::list())->push_back(Type::VoidTy); + CHECK_FOR_ERROR } | /*empty*/ { $$ = new std::list(); + CHECK_FOR_ERROR }; // ConstVal - The various declarations that go into the constant pool. This @@ -1092,139 +1256,152 @@ ArgTypeListI : TypeListI ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) - ThrowException("Cannot make array constant with type: '" + + GEN_ERROR("Cannot make array constant with type: '" + (*$1)->getDescription() + "'!"); const Type *ETy = ATy->getElementType(); int NumElements = ATy->getNumElements(); // Verify that we have the correct size... if (NumElements != -1 && NumElements != (int)$3->size()) - ThrowException("Type mismatch: constant sized array initialized with " + + GEN_ERROR("Type mismatch: constant sized array 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 '" + + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + ETy->getDescription() +"' as required!\nIt is of type '"+ (*$3)[i]->getType()->getDescription() + "'."); } $$ = ConstantArray::get(ATy, *$3); delete $1; delete $3; + CHECK_FOR_ERROR } | Types '[' ']' { const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) - ThrowException("Cannot make array constant with type: '" + + GEN_ERROR("Cannot make array constant with type: '" + (*$1)->getDescription() + "'!"); int NumElements = ATy->getNumElements(); if (NumElements != -1 && NumElements != 0) - ThrowException("Type mismatch: constant sized array initialized with 0" + GEN_ERROR("Type mismatch: constant sized array initialized with 0" " arguments, but has size of " + itostr(NumElements) +"!"); $$ = ConstantArray::get(ATy, std::vector()); delete $1; + CHECK_FOR_ERROR } | Types 'c' STRINGCONSTANT { const ArrayType *ATy = dyn_cast($1->get()); if (ATy == 0) - ThrowException("Cannot make array constant with type: '" + + GEN_ERROR("Cannot make array constant with type: '" + (*$1)->getDescription() + "'!"); int NumElements = ATy->getNumElements(); const Type *ETy = ATy->getElementType(); char *EndStr = UnEscapeLexed($3, true); if (NumElements != -1 && NumElements != (EndStr-$3)) - ThrowException("Can't build string constant of size " + + GEN_ERROR("Can't build string constant of size " + 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(ConstantInt::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(ConstantInt::get(ETy, *C)); } else { free($3); - ThrowException("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); delete $1; + CHECK_FOR_ERROR } | Types '<' ConstVector '>' { // Nonempty unsized arr const PackedType *PTy = dyn_cast($1->get()); if (PTy == 0) - ThrowException("Cannot make packed constant with type: '" + + GEN_ERROR("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 " + + GEN_ERROR("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 '" + + GEN_ERROR("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; + CHECK_FOR_ERROR } | Types '{' ConstVector '}' { const StructType *STy = dyn_cast($1->get()); if (STy == 0) - ThrowException("Cannot make struct constant with type: '" + + GEN_ERROR("Cannot make struct constant with type: '" + (*$1)->getDescription() + "'!"); if ($3->size() != STy->getNumContainedTypes()) - ThrowException("Illegal number of initializers for structure type!"); + 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)) - ThrowException("Expected type '" + + GEN_ERROR("Expected type '" + STy->getElementType(i)->getDescription() + "' for element #" + utostr(i) + " of structure initializer!"); $$ = ConstantStruct::get(STy, *$3); delete $1; delete $3; + CHECK_FOR_ERROR } | Types '{' '}' { const StructType *STy = dyn_cast($1->get()); if (STy == 0) - ThrowException("Cannot make struct constant with type: '" + + GEN_ERROR("Cannot make struct constant with type: '" + (*$1)->getDescription() + "'!"); if (STy->getNumContainedTypes() != 0) - ThrowException("Illegal number of initializers for structure type!"); + GEN_ERROR("Illegal number of initializers for structure type!"); $$ = ConstantStruct::get(STy, std::vector()); delete $1; + CHECK_FOR_ERROR } | Types NULL_TOK { const PointerType *PTy = dyn_cast($1->get()); if (PTy == 0) - ThrowException("Cannot make null pointer constant with type: '" + + GEN_ERROR("Cannot make null pointer constant with type: '" + (*$1)->getDescription() + "'!"); $$ = ConstantPointerNull::get(PTy); delete $1; + CHECK_FOR_ERROR + } + | Types UNDEF { + $$ = UndefValue::get($1->get()); + delete $1; + CHECK_FOR_ERROR } | Types SymbolicValueRef { const PointerType *Ty = dyn_cast($1->get()); if (Ty == 0) - ThrowException("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 @@ -1237,6 +1414,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr CurFun.CurrentFunction = 0; Value *V = getValNonImprovising(Ty, $2); + CHECK_FOR_ERROR CurFun.CurrentFunction = SavedCurFn; @@ -1279,136 +1457,163 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr $$ = cast(V); delete $1; // Free the type handle + CHECK_FOR_ERROR } | Types ConstExpr { if ($1->get() != $2->getType()) - ThrowException("Mismatched types for constant expression!"); + GEN_ERROR("Mismatched types for constant expression!"); $$ = $2; delete $1; + CHECK_FOR_ERROR } | Types ZEROINITIALIZER { - $$ = Constant::getNullValue($1->get()); + const Type *Ty = $1->get(); + if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) + GEN_ERROR("Cannot create a null initialized value of this type!"); + $$ = Constant::getNullValue(Ty); delete $1; - }; - -ConstVal : SIntType EINT64VAL { // integral constants - if (!ConstantSInt::isValueValidForType($1, $2)) - ThrowException("Constant value doesn't fit in type!"); - $$ = ConstantSInt::get($1, $2); + CHECK_FOR_ERROR + } + | SIntType EINT64VAL { // integral constants + if (!ConstantInt::isValueValidForType($1, $2)) + GEN_ERROR("Constant value doesn't fit in type!"); + $$ = ConstantInt::get($1, $2); + CHECK_FOR_ERROR } | UIntType EUINT64VAL { // integral constants - if (!ConstantUInt::isValueValidForType($1, $2)) - ThrowException("Constant value doesn't fit in type!"); - $$ = ConstantUInt::get($1, $2); + if (!ConstantInt::isValueValidForType($1, $2)) + GEN_ERROR("Constant value doesn't fit in type!"); + $$ = ConstantInt::get($1, $2); + CHECK_FOR_ERROR } | BOOL TRUETOK { // Boolean constants - $$ = ConstantBool::True; + $$ = ConstantBool::getTrue(); + CHECK_FOR_ERROR } | BOOL FALSETOK { // Boolean constants - $$ = ConstantBool::False; + $$ = ConstantBool::getFalse(); + CHECK_FOR_ERROR } | FPType FPVAL { // Float & Double constants + if (!ConstantFP::isValueValidForType($1, $2)) + GEN_ERROR("Floating point constant invalid for type!!"); $$ = ConstantFP::get($1, $2); + CHECK_FOR_ERROR }; -ConstExpr: CAST '(' ConstVal TO Types ')' { - if (!$3->getType()->isFirstClassType()) - ThrowException("cast constant expression from a non-primitive type: '" + - $3->getType()->getDescription() + "'!"); - if (!$5->get()->isFirstClassType()) - ThrowException("cast constant expression to a non-primitive type: '" + - $5->get()->getDescription() + "'!"); - $$ = ConstantExpr::getCast($3, $5->get()); +ConstExpr: CastOps '(' ConstVal TO Types ')' { + Constant *Val = $3; + const Type *Ty = $5->get(); + if (!Val->getType()->isFirstClassType()) + GEN_ERROR("cast constant expression from a non-primitive type: '" + + Val->getType()->getDescription() + "'!"); + if (!Ty->isFirstClassType()) + GEN_ERROR("cast constant expression to a non-primitive type: '" + + Ty->getDescription() + "'!"); + $$ = ConstantExpr::getCast($1, $3, $5->get()); delete $5; } | GETELEMENTPTR '(' ConstVal IndexList ')' { if (!isa($3->getType())) - ThrowException("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); if (!IdxTy) - ThrowException("Index list invalid for constant getelementptr!"); + GEN_ERROR("Index list invalid for constant getelementptr!"); std::vector IdxVec; for (unsigned i = 0, e = $4->size(); i != e; ++i) if (Constant *C = dyn_cast((*$4)[i])) IdxVec.push_back(C); else - ThrowException("Indices to constant getelementptr must be constants!"); + GEN_ERROR("Indices to constant getelementptr must be constants!"); delete $4; $$ = ConstantExpr::getGetElementPtr($3, IdxVec); + CHECK_FOR_ERROR } | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' { if ($3->getType() != Type::BoolTy) - ThrowException("Select condition must be of boolean type!"); + GEN_ERROR("Select condition must be of boolean type!"); if ($5->getType() != $7->getType()) - ThrowException("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()) - 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()); - } + GEN_ERROR("Binary operator types must match!"); + CHECK_FOR_ERROR; + $$ = ConstantExpr::get($1, $3, $5); } | LogicalOps '(' ConstVal ',' ConstVal ')' { if ($3->getType() != $5->getType()) - ThrowException("Logical operator types must match!"); - if (!$3->getType()->isIntegral()) - ThrowException("Logical operands must have integral types!"); + 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!"); + } $$ = ConstantExpr::get($1, $3, $5); + CHECK_FOR_ERROR } | SetCondOps '(' ConstVal ',' ConstVal ')' { if ($3->getType() != $5->getType()) - ThrowException("setcc operand types must match!"); + 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); + } + | FCMP FPredicates '(' ConstVal ',' ConstVal ')' { + if ($4->getType() != $6->getType()) + GEN_ERROR("fcmp operand types must match!"); + $$ = ConstantExpr::getFCmp($2, $4, $6); } | ShiftOps '(' ConstVal ',' ConstVal ')' { if ($5->getType() != Type::UByteTy) - ThrowException("Shift count for shift constant must be unsigned byte!"); + GEN_ERROR("Shift count for shift constant must be unsigned byte!"); if (!$3->getType()->isInteger()) - ThrowException("Shift constant expression requires integer operand!"); + GEN_ERROR("Shift constant expression requires integer operand!"); + CHECK_FOR_ERROR; $$ = ConstantExpr::get($1, $3, $5); + CHECK_FOR_ERROR + } + | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' { + if (!ExtractElementInst::isValidOperands($3, $5)) + 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!"); + $$ = ConstantExpr::getInsertElement($3, $5, $7); + CHECK_FOR_ERROR + } + | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' { + if (!ShuffleVectorInst::isValidOperands($3, $5, $7)) + GEN_ERROR("Invalid shufflevector operands!"); + $$ = ConstantExpr::getShuffleVector($3, $5, $7); + CHECK_FOR_ERROR }; // ConstVector - A list of comma separated constants. ConstVector : ConstVector ',' ConstVal { ($$ = $1)->push_back($3); + CHECK_FOR_ERROR } | ConstVal { $$ = new std::vector(); $$->push_back($1); + CHECK_FOR_ERROR }; @@ -1426,6 +1631,7 @@ GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; Module : FunctionList { $$ = ParserResult = $1; CurModule.ModuleDone(); + CHECK_FOR_ERROR; }; // FunctionList - A list of functions, preceeded by a constant pool. @@ -1433,21 +1639,36 @@ Module : FunctionList { FunctionList : FunctionList Function { $$ = $1; CurFun.FunctionDone(); + CHECK_FOR_ERROR } | FunctionList FunctionProto { $$ = $1; + CHECK_FOR_ERROR } + | FunctionList MODULE ASM_TOK AsmBlock { + $$ = $1; + CHECK_FOR_ERROR + } | FunctionList IMPLEMENTATION { $$ = $1; + CHECK_FOR_ERROR } | 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) { + GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'"); + } else { + GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num)); + } + } + CHECK_FOR_ERROR }; // ConstPool - Constants with optional names assigned to them. -ConstPool : 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: // @@ -1460,40 +1681,83 @@ ConstPool : ConstPool OptAssign TYPE TypesV { // Types can be defined in the co ResolveTypeTo($2, *$4); if (!setTypeName(*$4, $2) && !$2) { + CHECK_FOR_ERROR // If this is a named type that is not a redefinition, add it to the slot // table. - if (inFunctionScope()) - CurFun.Types.push_back(*$4); - else - CurModule.Types.push_back(*$4); + CurModule.Types.push_back(*$4); } delete $4; + CHECK_FOR_ERROR } | ConstPool FunctionProto { // Function prototypes can be in const pool + CHECK_FOR_ERROR + } + | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool + CHECK_FOR_ERROR } | ConstPool OptAssign OptLinkage GlobalType ConstVal { - if ($5 == 0) ThrowException("Global value initializer is not a constant!"); - ParseGlobalVariable($2, $3, $4, $5->getType(), $5); + 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 { - ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0); + CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0); + CHECK_FOR_ERROR + delete $5; + } GlobalVarAttributes { + CurGV = 0; + CHECK_FOR_ERROR + } + | ConstPool OptAssign DLLIMPORT GlobalType Types { + CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, *$5, 0); + 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); + CHECK_FOR_ERROR + delete $5; + } GlobalVarAttributes { + CurGV = 0; + CHECK_FOR_ERROR } | ConstPool TARGET TargetDefinition { + CHECK_FOR_ERROR } | ConstPool DEPLIBS '=' LibrariesDefinition { + CHECK_FOR_ERROR } | /* 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); + 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) @@ -1501,11 +1765,16 @@ TargetDefinition : ENDIAN '=' BigOrLittle { else if ($3 == 64) CurModule.CurrentModule->setPointerSize(Module::Pointer64); else - ThrowException("Invalid pointer size: '" + utostr($3) + "'!"); + GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!"); + CHECK_FOR_ERROR } | TRIPLE '=' STRINGCONSTANT { CurModule.CurrentModule->setTargetTriple($3); free($3); + } + | DATALAYOUT '=' STRINGCONSTANT { + CurModule.CurrentModule->setDataLayout($3); + free($3); }; LibrariesDefinition : '[' LibList ']'; @@ -1513,12 +1782,15 @@ LibrariesDefinition : '[' LibList ']'; LibList : LibList ',' STRINGCONSTANT { CurModule.CurrentModule->addLibrary($3); free($3); + CHECK_FOR_ERROR } | STRINGCONSTANT { CurModule.CurrentModule->addLibrary($1); free($1); + CHECK_FOR_ERROR } | /* empty: end of list */ { + CHECK_FOR_ERROR } ; @@ -1531,58 +1803,66 @@ OptName : Name | /*empty*/ { $$ = 0; }; ArgVal : Types OptName { if (*$1 == Type::VoidTy) - ThrowException("void typed arguments are invalid!"); + GEN_ERROR("void typed arguments are invalid!"); $$ = new std::pair($1, $2); + CHECK_FOR_ERROR }; ArgListH : ArgListH ',' ArgVal { $$ = $1; $1->push_back(*$3); delete $3; + CHECK_FOR_ERROR } | ArgVal { $$ = new std::vector >(); $$->push_back(*$1); delete $1; + CHECK_FOR_ERROR }; ArgList : ArgListH { $$ = $1; + CHECK_FOR_ERROR } | ArgListH ',' DOTDOTDOT { $$ = $1; $$->push_back(std::pair(new PATypeHolder(Type::VoidTy), 0)); + CHECK_FOR_ERROR } | DOTDOTDOT { $$ = new std::vector >(); $$->push_back(std::make_pair(new PATypeHolder(Type::VoidTy), (char*)0)); + CHECK_FOR_ERROR } | /* empty */ { $$ = 0; + CHECK_FOR_ERROR }; -FunctionHeaderH : TypesV Name '(' ArgList ')' { - UnEscapeLexed($2); - std::string FunctionName($2); - free($2); // Free strdup'd memory! +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) - ThrowException("LLVM functions cannot return aggregate types!"); + if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) + GEN_ERROR("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()) { @@ -1604,41 +1884,56 @@ FunctionHeaderH : TypesV Name '(' ArgList ')' { // 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 + "'!"); + GEN_ERROR("Redefinition of function '" + FunctionName + "'!"); // Make sure to strip off any argument names so we can't get conflicts. if (Fn->isExternal()) - for (Function::aiterator AI = Fn->abegin(), AE = Fn->aend(); + 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); } CurFun.FunctionStart(Fn); + if (CurFun.isDeclare) { + // If we have declaration, always overwrite linkage. This will allow us to + // correctly handle cases, when pointer to function is passed as argument to + // another function. + Fn->setLinkage(CurFun.Linkage); + } + 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... setValueName(ArgIt, I->second); // Insert arg into symtab... + CHECK_FOR_ERROR InsertValue(ArgIt); } - delete $4; // We're now done with the argument list + delete $5; // We're now done with the argument list } + CHECK_FOR_ERROR }; BEGIN : BEGINTOK | '{'; // Allow BEGIN or '{' to start a function @@ -1649,43 +1944,69 @@ 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 Function : BasicBlockList END { $$ = $1; + CHECK_FOR_ERROR }; -FunctionProto : DECLARE { CurFun.isDeclare = true; } FunctionHeaderH { - $$ = CurFun.CurrentFunction; - CurFun.FunctionDone(); -}; +FnDeclareLinkage: /*default*/ | + DLLIMPORT { CurFun.Linkage = GlobalValue::DLLImportLinkage; } | + EXTERN_WEAK { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; }; + +FunctionProto : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH { + $$ = CurFun.CurrentFunction; + CurFun.FunctionDone(); + CHECK_FOR_ERROR + }; //===----------------------------------------------------------------------===// // Rules to match Basic Blocks //===----------------------------------------------------------------------===// +OptSideEffect : /* empty */ { + $$ = false; + CHECK_FOR_ERROR + } + | SIDEEFFECT { + $$ = true; + CHECK_FOR_ERROR + }; + ConstValueRef : ESINT64VAL { // A reference to a direct constant $$ = ValID::create($1); + CHECK_FOR_ERROR } | EUINT64VAL { $$ = ValID::create($1); + CHECK_FOR_ERROR } | FPVAL { // Perhaps it's an FP constant? $$ = ValID::create($1); + CHECK_FOR_ERROR } | TRUETOK { - $$ = ValID::create(ConstantBool::True); + $$ = ValID::create(ConstantBool::getTrue()); + CHECK_FOR_ERROR } | FALSETOK { - $$ = ValID::create(ConstantBool::False); + $$ = ValID::create(ConstantBool::getFalse()); + CHECK_FOR_ERROR } | NULL_TOK { $$ = ValID::createNull(); + CHECK_FOR_ERROR + } + | UNDEF { + $$ = ValID::createUndef(); + CHECK_FOR_ERROR + } + | ZEROINITIALIZER { // A vector zero constant. + $$ = ValID::createZeroInit(); + CHECK_FOR_ERROR } | '<' ConstVector '>' { // Nonempty unsized packed vector const Type *ETy = (*$2)[0]->getType(); @@ -1703,16 +2024,28 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant // 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 '" + + GEN_ERROR("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; + CHECK_FOR_ERROR } | ConstExpr { $$ = ValID::create($1); + CHECK_FOR_ERROR + } + | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT { + char *End = UnEscapeLexed($3, true); + std::string AsmStr = std::string($3, End); + End = UnEscapeLexed($5, true); + std::string Constraints = std::string($5, End); + $$ = ValID::createInlineAsm(AsmStr, Constraints, $2); + free($3); + free($5); + CHECK_FOR_ERROR }; // SymbolicValueRef - Reference to one of two ways of symbolically refering to @@ -1720,9 +2053,11 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant // SymbolicValueRef : INTVAL { // Is it an integer reference...? $$ = ValID::create($1); + CHECK_FOR_ERROR } | Name { // Is it a named reference...? $$ = ValID::create($1); + CHECK_FOR_ERROR }; // ValueRef - A reference to a definition... either constant or symbolic @@ -1734,13 +2069,16 @@ ValueRef : SymbolicValueRef | ConstValueRef; // pool references (for things like: 'ret [2 x int] [ int 12, int 42]') ResolvedVal : Types ValueRef { $$ = getVal(*$1, $2); delete $1; + CHECK_FOR_ERROR }; BasicBlockList : BasicBlockList BasicBlock { $$ = $1; + CHECK_FOR_ERROR } | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks $$ = $1; + CHECK_FOR_ERROR }; @@ -1749,73 +2087,110 @@ BasicBlockList : BasicBlockList BasicBlock { // BasicBlock : InstructionList OptAssign 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); + $$ = 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. - CurFun.CurrentFunction->getBasicBlockList().remove(CurBB); - CurFun.CurrentFunction->getBasicBlockList().push_back(CurBB); + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, $$); + CHECK_FOR_ERROR } | LABELSTR { - $$ = CurBB = getBBVal(ValID::create($1), true); + $$ = 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. - CurFun.CurrentFunction->getBasicBlockList().remove(CurBB); - CurFun.CurrentFunction->getBasicBlockList().push_back(CurBB); + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, $$); + CHECK_FOR_ERROR }; BBTerminatorInst : RET ResolvedVal { // Return with a result... $$ = new ReturnInst($2); + CHECK_FOR_ERROR } | RET VOID { // Return with no result... $$ = new ReturnInst(); + CHECK_FOR_ERROR } | BR LABEL ValueRef { // Unconditional Branch... - $$ = new BranchInst(getBBVal($3)); + BasicBlock* tmpBB = getBBVal($3); + CHECK_FOR_ERROR + $$ = new BranchInst(tmpBB); } // Conditional Branch... | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { - $$ = new BranchInst(getBBVal($6), getBBVal($9), getVal(Type::BoolTy, $3)); + BasicBlock* tmpBBA = getBBVal($6); + CHECK_FOR_ERROR + BasicBlock* tmpBBB = getBBVal($9); + CHECK_FOR_ERROR + Value* tmpVal = getVal(Type::BoolTy, $3); + CHECK_FOR_ERROR + $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal); } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' { - SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6)); + Value* tmpVal = getVal($2, $3); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal($6); + CHECK_FOR_ERROR + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $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 + GEN_ERROR("Switch case is constant, but not a simple integer!"); + } delete $8; + CHECK_FOR_ERROR } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' { - SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6)); + Value* tmpVal = getVal($2, $3); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal($6); + CHECK_FOR_ERROR + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0); $$ = S; + CHECK_FOR_ERROR } - | INVOKE TypesV ValueRef '(' ValueRefListE ')' TO LABEL ValueRef - UNWIND LABEL ValueRef { + | 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()); } @@ -1823,17 +2198,19 @@ 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... - - BasicBlock *Normal = getBBVal($9); - BasicBlock *Except = getBBVal($12); + Value *V = getVal(PFTy, $4); // Get the function we're calling... + CHECK_FOR_ERROR + BasicBlock *Normal = getBBVal($10); + CHECK_FOR_ERROR + BasicBlock *Except = getBBVal($13); + CHECK_FOR_ERROR // 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 @@ -1841,23 +2218,31 @@ 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 '" + + GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + (*I)->getDescription() + "'!"); if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - ThrowException("Invalid number of parameters detected!"); + GEN_ERROR("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; + CHECK_FOR_ERROR } | UNWIND { $$ = new UnwindInst(); + CHECK_FOR_ERROR + } + | UNREACHABLE { + $$ = new UnreachableInst(); + CHECK_FOR_ERROR }; @@ -1865,37 +2250,52 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { $$ = $1; Constant *V = cast(getValNonImprovising($2, $3)); + CHECK_FOR_ERROR if (V == 0) - ThrowException("May only switch on a constant pool value!"); + GEN_ERROR("May only switch on a constant pool value!"); - $$->push_back(std::make_pair(V, getBBVal($6))); + BasicBlock* tmpBB = getBBVal($6); + CHECK_FOR_ERROR + $$->push_back(std::make_pair(V, tmpBB)); } | IntType ConstValueRef ',' LABEL ValueRef { $$ = new std::vector >(); Constant *V = cast(getValNonImprovising($1, $2)); + CHECK_FOR_ERROR if (V == 0) - ThrowException("May only switch on a constant pool value!"); + GEN_ERROR("May only switch on a constant pool value!"); - $$->push_back(std::make_pair(V, getBBVal($5))); + 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 }; PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes $$ = new std::list >(); - $$->push_back(std::make_pair(getVal(*$1, $3), getBBVal($5))); + Value* tmpVal = getVal(*$1, $3); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal($5); + CHECK_FOR_ERROR + $$->push_back(std::make_pair(tmpVal, tmpBB)); delete $1; } | PHIList ',' '[' ValueRef ',' ValueRef ']' { $$ = $1; - $1->push_back(std::make_pair(getVal($1->front().first->getType(), $4), - getBBVal($6))); + Value* tmpVal = getVal($1->front().first->getType(), $4); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal($6); + CHECK_FOR_ERROR + $1->push_back(std::make_pair(tmpVal, tmpBB)); }; @@ -1906,131 +2306,181 @@ ValueRefList : ResolvedVal { // Used for call statements, and memory insts... | ValueRefList ',' ResolvedVal { $$ = $1; $1->push_back($3); + CHECK_FOR_ERROR }; // ValueRefListE - Just like ValueRefList, except that it may also be empty! ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; }; +OptTailCall : TAIL CALL { + $$ = true; + CHECK_FOR_ERROR + } + | CALL { + $$ = false; + CHECK_FOR_ERROR + }; + InstVal : ArithmeticOps Types ValueRef ',' ValueRef { if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() && !isa((*$2).get())) - ThrowException( + GEN_ERROR( "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 (isa((*$2).get()) && + ($1 == Instruction::URem || + $1 == Instruction::SRem || + $1 == Instruction::FRem)) + GEN_ERROR("U/S/FRem not supported on packed types!"); + Value* val1 = getVal(*$2, $3); + CHECK_FOR_ERROR + Value* val2 = getVal(*$2, $5); + CHECK_FOR_ERROR + $$ = BinaryOperator::create($1, val1, val2); if ($$ == 0) - ThrowException("binary operator returned null!"); + GEN_ERROR("binary operator returned null!"); delete $2; } | LogicalOps Types ValueRef ',' ValueRef { - if (!(*$2)->isIntegral()) - ThrowException("Logical operator requires integral operands!"); - $$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5)); + if (!(*$2)->isIntegral()) { + if (!isa($2->get()) || + !cast($2->get())->getElementType()->isIntegral()) + GEN_ERROR("Logical operator requires integral operands!"); + } + Value* tmpVal1 = getVal(*$2, $3); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*$2, $5); + CHECK_FOR_ERROR + $$ = BinaryOperator::create($1, tmpVal1, tmpVal2); if ($$ == 0) - ThrowException("binary operator returned null!"); + GEN_ERROR("binary operator returned null!"); delete $2; } | SetCondOps Types ValueRef ',' ValueRef { if(isa((*$2).get())) { - ThrowException( + GEN_ERROR( "PackedTypes currently not supported in setcc instructions!"); } - $$ = new SetCondInst($1, getVal(*$2, $3), getVal(*$2, $5)); + Value* tmpVal1 = getVal(*$2, $3); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*$2, $5); + CHECK_FOR_ERROR + $$ = new SetCondInst($1, tmpVal1, tmpVal2); if ($$ == 0) - ThrowException("binary operator returned null!"); + GEN_ERROR("binary operator returned null!"); delete $2; } + | ICMP IPredicates Types ValueRef ',' ValueRef { + if (isa((*$3).get())) + GEN_ERROR("Packed types not supported by icmp instruction"); + Value* tmpVal1 = getVal(*$3, $4); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*$3, $6); + CHECK_FOR_ERROR + $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); + if ($$ == 0) + GEN_ERROR("icmp operator returned null!"); + } + | FCMP FPredicates Types ValueRef ',' ValueRef { + if (isa((*$3).get())) + GEN_ERROR("Packed types not supported by fcmp instruction"); + Value* tmpVal1 = getVal(*$3, $4); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*$3, $6); + CHECK_FOR_ERROR + $$ = CmpInst::create($1, $2, tmpVal1, tmpVal2); + if ($$ == 0) + GEN_ERROR("fcmp operator returned null!"); + } | NOT ResolvedVal { - std::cerr << "WARNING: Use of eliminated 'not' instruction:" + llvm_cerr << "WARNING: Use of eliminated 'not' instruction:" << " Replacing with 'xor'.\n"; Value *Ones = ConstantIntegral::getAllOnesValue($2->getType()); if (Ones == 0) - ThrowException("Expected integral type for not instruction!"); + GEN_ERROR("Expected integral type for not instruction!"); $$ = BinaryOperator::create(Instruction::Xor, $2, Ones); if ($$ == 0) - ThrowException("Could not create a xor instruction!"); + GEN_ERROR("Could not create a xor instruction!"); + CHECK_FOR_ERROR } | ShiftOps ResolvedVal ',' ResolvedVal { if ($4->getType() != Type::UByteTy) - ThrowException("Shift amount must be ubyte!"); + GEN_ERROR("Shift amount must be ubyte!"); if (!$2->getType()->isInteger()) - ThrowException("Shift constant expression requires integer operand!"); + GEN_ERROR("Shift constant expression requires integer operand!"); + CHECK_FOR_ERROR; $$ = new ShiftInst($1, $2, $4); - } - | CAST ResolvedVal TO Types { - if (!$4->get()->isFirstClassType()) - ThrowException("cast instruction to a non-primitive type: '" + - $4->get()->getDescription() + "'!"); - $$ = new CastInst($2, *$4); + CHECK_FOR_ERROR + } + | CastOps ResolvedVal TO Types { + Value* Val = $2; + const Type* Ty = $4->get(); + if (!Val->getType()->isFirstClassType()) + GEN_ERROR("cast from a non-primitive type: '" + + Val->getType()->getDescription() + "'!"); + if (!Ty->isFirstClassType()) + GEN_ERROR("cast to a non-primitive type: '" + Ty->getDescription() +"'!"); + $$ = CastInst::create($1, $2, $4->get()); delete $4; } | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal { if ($2->getType() != Type::BoolTy) - ThrowException("select condition must be boolean!"); + GEN_ERROR("select condition must be boolean!"); if ($4->getType() != $6->getType()) - ThrowException("select value types should match!"); + GEN_ERROR("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; + CHECK_FOR_ERROR } | VAARG ResolvedVal ',' Types { + NewVarArgs = true; $$ = new VAArgInst($2, *$4); delete $4; - } - | VANEXT ResolvedVal ',' Types { - $$ = new VANextInst($2, *$4); - delete $4; + CHECK_FOR_ERROR + } + | EXTRACTELEMENT ResolvedVal ',' ResolvedVal { + if (!ExtractElementInst::isValidOperands($2, $4)) + 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!"); + $$ = new InsertElementInst($2, $4, $6); + CHECK_FOR_ERROR + } + | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal { + if (!ShuffleVectorInst::isValidOperands($2, $4, $6)) + 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()) - ThrowException("PHI node operands must be of first class type!"); + GEN_ERROR("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!"); + 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... - } - | CALL TypesV ValueRef '(' ValueRefListE ')' { - const PointerType *PFTy; - const FunctionType *Ty; + CHECK_FOR_ERROR + } + | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; - 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()); } @@ -2038,17 +2488,21 @@ 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) + GEN_ERROR("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... + CHECK_FOR_ERROR // 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 " + GEN_ERROR("No arguments passed to a function that " "expects arguments!"); $$ = new CallInst(V, std::vector()); @@ -2058,108 +2512,132 @@ 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 '" + + GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + (*I)->getDescription() + "'!"); if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - ThrowException("Invalid number of parameters detected!"); + GEN_ERROR("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; + CHECK_FOR_ERROR } | MemoryInst { $$ = $1; + 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 } | /* empty */ { $$ = false; + CHECK_FOR_ERROR }; -MemoryInst : MALLOC Types { - $$ = new MallocInst(*$2); + +MemoryInst : MALLOC Types OptCAlign { + $$ = new MallocInst(*$2, 0, $3); delete $2; + CHECK_FOR_ERROR } - | MALLOC Types ',' UINT ValueRef { - $$ = new MallocInst(*$2, getVal($4, $5)); + | MALLOC Types ',' UINT ValueRef OptCAlign { + Value* tmpVal = getVal($4, $5); + CHECK_FOR_ERROR + $$ = new MallocInst(*$2, tmpVal, $6); delete $2; } - | ALLOCA Types { - $$ = new AllocaInst(*$2); + | ALLOCA Types OptCAlign { + $$ = new AllocaInst(*$2, 0, $3); delete $2; + CHECK_FOR_ERROR } - | ALLOCA Types ',' UINT ValueRef { - $$ = new AllocaInst(*$2, getVal($4, $5)); + | ALLOCA Types ',' UINT ValueRef OptCAlign { + Value* tmpVal = getVal($4, $5); + CHECK_FOR_ERROR + $$ = new AllocaInst(*$2, tmpVal, $6); delete $2; } | FREE ResolvedVal { if (!isa($2->getType())) - ThrowException("Trying to free nonpointer type " + + GEN_ERROR("Trying to free nonpointer type " + $2->getType()->getDescription() + "!"); $$ = new FreeInst($2); + CHECK_FOR_ERROR } | OptVolatile LOAD Types ValueRef { if (!isa($3->get())) - ThrowException("Can't load from nonpointer type: " + + GEN_ERROR("Can't load from nonpointer type: " + + (*$3)->getDescription()); + if (!cast($3->get())->getElementType()->isFirstClassType()) + GEN_ERROR("Can't load from pointer of non-first-class type: " + (*$3)->getDescription()); - $$ = new LoadInst(getVal(*$3, $4), "", $1); + Value* tmpVal = getVal(*$3, $4); + CHECK_FOR_ERROR + $$ = new LoadInst(tmpVal, "", $1); delete $3; } | OptVolatile STORE ResolvedVal ',' Types ValueRef { const PointerType *PT = dyn_cast($5->get()); if (!PT) - ThrowException("Can't store to a nonpointer type: " + + GEN_ERROR("Can't store to a nonpointer type: " + (*$5)->getDescription()); const Type *ElTy = PT->getElementType(); if (ElTy != $3->getType()) - ThrowException("Can't store '" + $3->getType()->getDescription() + + GEN_ERROR("Can't store '" + $3->getType()->getDescription() + "' into space of type '" + ElTy->getDescription() + "'!"); - $$ = new StoreInst($3, getVal(*$5, $6), $1); + Value* tmpVal = getVal(*$5, $6); + CHECK_FOR_ERROR + $$ = new StoreInst($3, tmpVal, $1); delete $5; } | GETELEMENTPTR Types ValueRef IndexList { if (!isa($2->get())) - ThrowException("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); + GEN_ERROR("getelementptr insn requires pointer operand!"); if (!GetElementPtrInst::getIndexedType(*$2, *$4, true)) - ThrowException("Invalid getelementptr indices for type '" + + GEN_ERROR("Invalid getelementptr indices for type '" + (*$2)->getDescription()+ "'!"); - $$ = new GetElementPtrInst(getVal(*$2, $3), *$4); - delete $2; delete $4; + Value* tmpVal = getVal(*$2, $3); + CHECK_FOR_ERROR + $$ = new GetElementPtrInst(tmpVal, *$4); + delete $2; + delete $4; }; %% + +void llvm::GenerateError(const std::string &message, int LineNo) { + if (LineNo == -1) LineNo = llvmAsmlineno; + // TODO: column number in exception + if (TheParseError) + TheParseError->setError(CurFilename, message, LineNo); + TriggerError = 1; +} + int yyerror(const char *ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) @@ -2169,6 +2647,6 @@ int yyerror(const char *ErrorMsg) { errMsg += "end-of-file."; else errMsg += "token: '" + std::string(llvmAsmtext, llvmAsmleng) + "'"; - ThrowException(errMsg); + GenerateError(errMsg); return 0; }