X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FllvmAsmParser.y;h=31b286b87edf65ae04f60ca5dd2842131fcff6a6;hb=b7d08a50f527aeb2b4203a74bbeecf294b27e5c1;hp=eb79350eed7c2f7f765fb60d86fb1e22aa4fce44;hpb=e4d5c441e04bdc00ccf1804744af670655123b07;p=oota-llvm.git diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index eb79350eed7..31b286b87ed 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,11 +13,13 @@ %{ #include "ParserInternals.h" +#include "llvm/CallingConv.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 #include #include @@ -46,20 +48,18 @@ static Module *ParserResult; #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; // 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; @@ -94,7 +94,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() + " " + @@ -130,8 +130,6 @@ static struct PerFunctionInfo { 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? /// BBForwardRefs - When we see forward references to basic blocks, keep @@ -162,7 +160,6 @@ static struct PerFunctionInfo { ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); Values.clear(); // Clear out function local definitions - Types.clear(); // Clear out function local types CurrentFunction = 0; isDeclare = false; } @@ -189,7 +186,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? @@ -208,21 +205,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); @@ -244,7 +245,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 +256,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,12 +268,12 @@ 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); @@ -292,15 +293,15 @@ 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::ConstantVal: // Fully resolved constant? if (D.ConstantValue->getType() != Ty) ThrowException("Constant expression type different from required type!"); @@ -329,6 +330,9 @@ static Value *getVal(const Type *Ty, const ValID &ID) { 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... @@ -342,7 +346,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); - else + else InsertValue(V, CurModule.LateResolveValues); return V; } @@ -422,12 +426,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) { @@ -458,7 +463,7 @@ static void ResolveDefinitions(std::map &LateResolvers, PHI->second.second); else ThrowException("Reference to an invalid definition: #" + - itostr(DID.Num) + " of type '" + + itostr(DID.Num) + " of type '" + V->getType()->getDescription() + "'", PHI->second.second); } @@ -473,34 +478,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)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); - } -} - -// 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); } } @@ -513,15 +499,15 @@ static void setValueName(Value *V, char *NameStr) { std::string Name(NameStr); // Copy string free(NameStr); // Free old string - if (V->getType() == Type::VoidTy) + 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); } @@ -531,11 +517,15 @@ static void setValueName(Value *V, char *NameStr) { /// this is a declaration, otherwise it is a definition. static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { + Constant *Initializer, char *Section, + unsigned Align) { + if (Align != 0 && !isPowerOf2_32(Align)) + ThrowException("Global alignment must be a power of two!"); + if (isa(Ty)) ThrowException("Cannot declare global vars of function type!"); - const PointerType *PTy = PointerType::get(Ty); + const PointerType *PTy = PointerType::get(Ty); std::string Name; if (NameStr) { @@ -545,7 +535,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 { @@ -553,7 +543,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); @@ -561,6 +551,11 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, GV->setInitializer(Initializer); GV->setLinkage(Linkage); GV->setConstant(isConstantGlobal); + GV->setAlignment(Align); + if (Section) { + free(Section); + GV->setSection(Section); + } InsertValue(GV, CurModule.Values); return; } @@ -571,10 +566,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 || @@ -587,18 +582,28 @@ static void ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, if (isConstantGlobal) EGV->setConstant(true); EGV->setLinkage(Linkage); + EGV->setAlignment(Align); + if (Section) { + free(Section); + EGV->setSection(Section); + } return; } - ThrowException("Redefinition of global variable named '" + Name + + ThrowException("Redefinition of global variable named '" + Name + "' in the '" + Ty->getDescription() + "' type plane!"); } } // 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); + GV->setAlignment(Align); + if (Section) { + free(Section); + GV->setSection(Section); + } InsertValue(GV, CurModule.Values); } @@ -612,12 +617,12 @@ 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) + 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. @@ -656,7 +661,7 @@ 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 std::find(Ty->subtype_begin(), Ty->subtype_end(), + return std::find(Ty->subtype_begin(), Ty->subtype_end(), E) != Ty->subtype_end(); } @@ -665,7 +670,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; @@ -692,7 +697,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"); @@ -703,15 +708,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 { @@ -739,88 +744,141 @@ static PATypeHolder HandleUpRefs(const Type *ty) { } -//===----------------------------------------------------------------------===// -// RunVMAsmParser - Define an interface to this parser -//===----------------------------------------------------------------------===// -// -Module *llvm::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); - + 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->arg_size() == 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->arg_size() == 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->arg_size() == 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->arg_size() == 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)); +} + +Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { + set_scan_string(AsmString); + + CurFilename = "from_memory"; + if (M == NULL) { + return RunParser(new Module (CurFilename)); + } else { + return RunParser(M); + } } %} @@ -841,8 +899,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; @@ -880,6 +939,7 @@ 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 OptLinkage %type BigOrLittle @@ -908,18 +968,21 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { %token VAR_ID LABELSTR STRINGCONSTANT %type Name OptName OptAssign - +%type OptAlign OptCAlign +%type OptSection OptCSection SectionString %token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK -%token DECLARE GLOBAL CONSTANT VOLATILE +%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 -%token DEPLIBS +%token OPAQUE NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN +%token DEPLIBS CALL TAIL +%token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK +%type OptCallingConv -// Basic Block Terminating Operators +// Basic Block Terminating Operators %token RET BR SWITCH INVOKE UNWIND UNREACHABLE -// 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 @@ -929,8 +992,9 @@ Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { // 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 VAARG_old VANEXT_old //OBSOLETE + %start Module %% @@ -952,7 +1016,7 @@ 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; @@ -972,8 +1036,8 @@ FPType : FLOAT | DOUBLE; OptAssign : Name '=' { $$ = $1; } - | /*empty*/ { - $$ = 0; + | /*empty*/ { + $$ = 0; }; OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | @@ -982,6 +1046,36 @@ OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | APPENDING { $$ = GlobalValue::AppendingLinkage; } | /*empty*/ { $$ = GlobalValue::ExternalLinkage; }; +OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | + CCC_TOK { $$ = CallingConv::C; } | + 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; }; +OptCAlign : /*empty*/ { $$ = 0; } | + ',' ALIGN EUINT64VAL { $$ = $3; }; + +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; }; +OptCSection : /*empty*/ { $$ = 0; } | + ',' SectionString { $$ = $2; }; + + //===----------------------------------------------------------------------===// // Types includes all predefined types... except void, because it can only be // used in specific contexts (function returning void for example). To have @@ -1040,12 +1134,12 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference } | '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type? const llvm::Type* ElemTy = $4->get(); - if ((unsigned)$2 != $2) { + if ((unsigned)$2 != $2) ThrowException("Unsigned result not equal to signed result"); - } - if(!ElemTy->isPrimitiveType()) { + 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; } @@ -1054,7 +1148,7 @@ UpRTypes : '\\' EUINT64VAL { // Type UpReference 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; } @@ -1457,12 +1551,18 @@ FunctionList : FunctionList Function { } | 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 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: // @@ -1477,22 +1577,19 @@ ConstPool : ConstPool OptAssign TYPE TypesV { // Types can be defined in the co if (!setTypeName(*$4, $2) && !$2) { // 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; } | ConstPool FunctionProto { // Function prototypes can be in const pool } - | ConstPool OptAssign OptLinkage GlobalType ConstVal { + | ConstPool OptAssign OptLinkage GlobalType ConstVal OptCSection OptCAlign { if ($5 == 0) ThrowException("Global value initializer is not a constant!"); - ParseGlobalVariable($2, $3, $4, $5->getType(), $5); + ParseGlobalVariable($2, $3, $4, $5->getType(), $5, $6, $7); } - | ConstPool OptAssign EXTERNAL GlobalType Types { - ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0); + | ConstPool OptAssign EXTERNAL GlobalType Types OptCSection OptCAlign { + ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0, $6, $7); delete $5; } | ConstPool TARGET TargetDefinition { @@ -1577,27 +1674,30 @@ ArgList : ArgListH { $$ = 0; }; -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) + if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) ThrowException("LLVM functions cannot return aggregate types!"); + if ($8 != 0 && !isPowerOf2_32($8)) + ThrowException("Function alignment must be a power of two!"); 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()) { @@ -1634,25 +1734,31 @@ FunctionHeaderH : TypesV Name '(' ArgList ')' { } 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::arg_iterator ArgIt = Fn->arg_begin(); - for (std::vector >::iterator I =$4->begin(); - I != $4->end(); ++I, ++ArgIt) { + 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... InsertValue(ArgIt); } - delete $4; // We're now done with the argument list + delete $5; // We're now done with the argument list } }; @@ -1664,9 +1770,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 @@ -1784,8 +1887,9 @@ InstructionList : InstructionList Inst { // 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, $$); } | LABELSTR { $$ = CurBB = getBBVal(ValID::create($1), true); @@ -1793,8 +1897,9 @@ InstructionList : InstructionList Inst { // 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, $$); }; BBTerminatorInst : RET ResolvedVal { // Return with a result... @@ -1827,17 +1932,17 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... SwitchInst *S = new SwitchInst(getVal($2, $3), getBBVal($6), 0); $$ = S; } - | 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()); } @@ -1845,17 +1950,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 = getBBVal($9); - BasicBlock *Except = getBBVal($12); + 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 @@ -1863,7 +1968,7 @@ 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) @@ -1873,10 +1978,12 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result... if (I != E || (ArgI != ArgE && !Ty->isVarArg())) 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(); @@ -1936,15 +2043,22 @@ 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() && !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!"); - } + 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!"); @@ -2001,35 +2115,50 @@ 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; } | PHI_TOK PHIList { @@ -2045,17 +2174,17 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { $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()); } @@ -2063,17 +2192,17 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; if (isVarArg) ParamTypes.pop_back(); - if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) + if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy) ThrowException("LLVM functions cannot return aggregate types!"); - 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... // 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 " @@ -2086,7 +2215,7 @@ 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) @@ -2096,10 +2225,12 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef { if (I != E || (ArgI != ArgE && !Ty->isVarArg())) 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; @@ -2121,20 +2252,33 @@ OptVolatile : VOLATILE { }; -MemoryInst : MALLOC Types { - $$ = new MallocInst(*$2); + +MemoryInst : MALLOC Types OptCAlign { + if ($3 != 0 && !isPowerOf2_32($3)) + ThrowException("Alignment amount '" + utostr($3) + + "' is not a power of 2!"); + $$ = new MallocInst(*$2, 0, $3); delete $2; } - | MALLOC Types ',' UINT ValueRef { - $$ = new MallocInst(*$2, getVal($4, $5)); + | MALLOC Types ',' UINT ValueRef OptCAlign { + if ($6 != 0 && !isPowerOf2_32($6)) + ThrowException("Alignment amount '" + utostr($6) + + "' is not a power of 2!"); + $$ = new MallocInst(*$2, getVal($4, $5), $6); delete $2; } - | ALLOCA Types { - $$ = new AllocaInst(*$2); + | ALLOCA Types OptCAlign { + if ($3 != 0 && !isPowerOf2_32($3)) + ThrowException("Alignment amount '" + utostr($3) + + "' is not a power of 2!"); + $$ = new AllocaInst(*$2, 0, $3); delete $2; } - | ALLOCA Types ',' UINT ValueRef { - $$ = new AllocaInst(*$2, getVal($4, $5)); + | ALLOCA Types ',' UINT ValueRef OptCAlign { + if ($6 != 0 && !isPowerOf2_32($6)) + ThrowException("Alignment amount '" + utostr($6) + + "' is not a power of 2!"); + $$ = new AllocaInst(*$2, getVal($4, $5), $6); delete $2; } | FREE ResolvedVal {