diff options
author | Tanya Lattner <tonic@nondot.org> | 2006-11-08 17:44:16 +0000 |
---|---|---|
committer | Tanya Lattner <tonic@nondot.org> | 2006-11-08 17:44:16 +0000 |
commit | 532aeb4d55797ea8fe12a659decd078de10a27fb (patch) | |
tree | 6100e8a3a979a655b627e8e1c87f93c9c84bb04a | |
parent | fc9597dbbca6a63e1136304e7c5dc164bb4754e9 (diff) | |
download | llvm-532aeb4d55797ea8fe12a659decd078de10a27fb.zip llvm-532aeb4d55797ea8fe12a659decd078de10a27fb.tar.gz llvm-532aeb4d55797ea8fe12a659decd078de10a27fb.tar.bz2 |
Merging from mainline cvs
llvm-svn: 31556
-rw-r--r-- | llvm/lib/AsmParser/llvmAsmParser.y | 3099 |
1 files changed, 805 insertions, 2294 deletions
diff --git a/llvm/lib/AsmParser/llvmAsmParser.y b/llvm/lib/AsmParser/llvmAsmParser.y index 8eea9ab..33f46fc 100644 --- a/llvm/lib/AsmParser/llvmAsmParser.y +++ b/llvm/lib/AsmParser/llvmAsmParser.y @@ -1,233 +1,164 @@ -//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===// +//===-- 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. // -//===----------------------------------------------------------------------===// +//===------------------------------------------------------------------------=// + // -// This file implements the bison parser for LLVM assembly languages files. +// TODO: Parse comments and add them to an internal node... so that they may +// be saved in the bytecode format as well as everything else. Very important +// for a general IR format. // -//===----------------------------------------------------------------------===// %{ #include "ParserInternals.h" -#include "llvm/CallingConv.h" -#include "llvm/InlineAsm.h" -#include "llvm/Instructions.h" -#include "llvm/Module.h" +#include "llvm/Assembly/Parser.h" #include "llvm/SymbolTable.h" -#include "llvm/Assembly/AutoUpgrade.h" -#include "llvm/Support/GetElementPtrTypeIterator.h" -#include "llvm/ADT/STLExtras.h" -#include "llvm/Support/MathExtras.h" -#include <algorithm> -#include <iostream> +#include "llvm/Module.h" +#include "llvm/GlobalVariable.h" +#include "llvm/Method.h" +#include "llvm/BasicBlock.h" +#include "llvm/DerivedTypes.h" +#include "llvm/iTerminators.h" +#include "llvm/iMemory.h" +#include "llvm/Support/STLExtras.h" +#include "llvm/Support/DepthFirstIterator.h" #include <list> -#include <utility> - -// 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 +#include <utility> // Get definition of pair class +#include <algorithm> +#include <stdio.h> // This embarasment is due to our flex lexer... + +int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); -namespace llvm { - std::string CurFilename; -} -using namespace llvm; - static Module *ParserResult; +string CurFilename; // DEBUG_UPREFS - Define this symbol if you want to enable debugging output // relating to upreferences in the input stream. // //#define DEBUG_UPREFS 1 #ifdef DEBUG_UPREFS -#define UR_OUT(X) std::cerr << X +#define UR_OUT(X) cerr << X #else #define UR_OUT(X) #endif -#define YYERROR_VERBOSE 1 - -static bool ObsoleteVarArgs; -static bool NewVarArgs; -static BasicBlock *CurBB; -static GlobalVariable *CurGV; - - -// This contains info used when building the body of a function. It is -// destroyed when the function is completed. +// This contains info used when building the body of a method. It is destroyed +// when the method is completed. // -typedef std::vector<Value *> ValueList; // Numbered defs -static void -ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers, - std::map<const Type *,ValueList> *FutureLateResolvers = 0); +typedef vector<Value *> ValueList; // Numbered defs +static void ResolveDefinitions(vector<ValueList> &LateResolvers); +static void ResolveTypes (vector<PATypeHolder<Type> > &LateResolveTypes); static struct PerModuleInfo { Module *CurrentModule; - std::map<const Type *, ValueList> Values; // Module level numbered definitions - std::map<const Type *,ValueList> LateResolveValues; - std::vector<PATypeHolder> Types; - std::map<ValID, PATypeHolder> LateResolveTypes; - - /// PlaceHolderInfo - When temporary placeholder objects are created, remember - /// how they were referenced and on which line of the input they came from so - /// that we can resolve them later and print error messages as appropriate. - std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo; - - // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward - // references to global values. Global values may be referenced before they - // are defined, and if so, the temporary object that they represent is held - // here. This is used for forward references of GlobalValues. - // - typedef std::map<std::pair<const PointerType *, - ValID>, GlobalValue*> GlobalRefsType; - GlobalRefsType GlobalRefs; + vector<ValueList> Values; // Module level numbered definitions + vector<ValueList> LateResolveValues; + vector<PATypeHolder<Type> > Types, LateResolveTypes; void ModuleDone() { - // If we could not resolve some functions at function compilation time - // (calls to functions before they are defined), resolve them now... Types - // are resolved when the constant pool has been completely parsed. + // If we could not resolve some methods at method compilation time (calls to + // methods before they are defined), resolve them now... Types 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"; - } - GenerateError(UndefinedReferences); - return; - } - - // Look for intrinsic functions and CallInst that need to be upgraded - for (Module::iterator FI = CurrentModule->begin(), - FE = CurrentModule->end(); FI != FE; ) - UpgradeCallsToIntrinsic(FI++); - Values.clear(); // Clear out function local definitions + Values.clear(); // Clear out method local definitions Types.clear(); 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. - GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) { - // Check to see if there is a forward reference to this global variable... - // if there is, eliminate it and patch the reference to use the new def'n. - GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID)); - GlobalValue *Ret = 0; - if (I != GlobalRefs.end()) { - Ret = I->second; - GlobalRefs.erase(I); - } - return Ret; - } } CurModule; -static struct PerFunctionInfo { - Function *CurrentFunction; // Pointer to current function being created - - std::map<const Type*, ValueList> Values; // Keep track of #'d definitions - std::map<const Type*, ValueList> LateResolveValues; - bool isDeclare; // Is this function a forward declararation? - GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration. +static struct PerMethodInfo { + Method *CurrentMethod; // Pointer to current method being created - /// BBForwardRefs - When we see forward references to basic blocks, keep - /// track of them here. - std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs; - std::vector<BasicBlock*> NumberedBlocks; - unsigned NextBBNum; + vector<ValueList> Values; // Keep track of numbered definitions + vector<ValueList> LateResolveValues; + vector<PATypeHolder<Type> > Types, LateResolveTypes; + bool isDeclare; // Is this method a forward declararation? - inline PerFunctionInfo() { - CurrentFunction = 0; + inline PerMethodInfo() { + CurrentMethod = 0; isDeclare = false; - Linkage = GlobalValue::ExternalLinkage; } - inline void FunctionStart(Function *M) { - CurrentFunction = M; - NextBBNum = 0; - } - - void FunctionDone() { - NumberedBlocks.clear(); + inline ~PerMethodInfo() {} - // Any forward referenced blocks left? - if (!BBForwardRefs.empty()) { - GenerateError("Undefined reference to label " + - BBForwardRefs.begin()->first->getName()); - return; - } + inline void MethodStart(Method *M) { + CurrentMethod = M; + } - // Resolve all forward references now. - ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); + void MethodDone() { + // If we could not resolve some blocks at parsing time (forward branches) + // resolve the branches now... + ResolveDefinitions(LateResolveValues); - Values.clear(); // Clear out function local definitions - CurrentFunction = 0; + Values.clear(); // Clear out method local definitions + Types.clear(); + CurrentMethod = 0; isDeclare = false; - Linkage = GlobalValue::ExternalLinkage; } -} CurFun; // Info for the current function... - -static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } +} CurMeth; // Info for the current method... //===----------------------------------------------------------------------===// // Code to handle definitions of all the types //===----------------------------------------------------------------------===// -static int InsertValue(Value *V, - std::map<const Type*,ValueList> &ValueTab = CurFun.Values) { - if (V->hasName()) return -1; // Is this a numbered definition? +static void InsertValue(Value *D, vector<ValueList> &ValueTab = CurMeth.Values){ + if (!D->hasName()) { // Is this a numbered definition? + unsigned type = D->getType()->getUniqueID(); + if (ValueTab.size() <= type) + ValueTab.resize(type+1, ValueList()); + //printf("Values[%d][%d] = %d\n", type, ValueTab[type].size(), D); + ValueTab[type].push_back(D); + } +} - // Yes, insert the value into the value table... - ValueList &List = ValueTab[V->getType()]; - List.push_back(V); - return List.size()-1; +// TODO: FIXME when Type are not const +static void InsertType(const Type *Ty, vector<PATypeHolder<Type> > &Types) { + Types.push_back(Ty); } static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { switch (D.Type) { - case ValID::NumberVal: // Is it a numbered definition? + case 0: { // Is it a numbered definition? + unsigned Num = (unsigned)D.Num; + // Module constants occupy the lowest numbered slots... - if ((unsigned)D.Num < CurModule.Types.size()) - return CurModule.Types[(unsigned)D.Num]; - break; - case ValID::NameVal: // Is it a named definition? - if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { - D.destroy(); // Free old strdup'd memory... - return N; + if (Num < CurModule.Types.size()) + return CurModule.Types[Num]; + + Num -= CurModule.Types.size(); + + // Check that the number is within bounds... + if (Num <= CurMeth.Types.size()) + return CurMeth.Types[Num]; + } + case 1: { // Is it a named definition? + string Name(D.Name); + SymbolTable *SymTab = 0; + if (CurMeth.CurrentMethod) + SymTab = CurMeth.CurrentMethod->getSymbolTable(); + Value *N = SymTab ? SymTab->lookup(Type::TypeTy, Name) : 0; + + if (N == 0) { + // Symbol table doesn't automatically chain yet... because the method + // hasn't been added to the module... + // + SymTab = CurModule.CurrentModule->getSymbolTable(); + if (SymTab) + N = SymTab->lookup(Type::TypeTy, Name); + if (N == 0) break; } - break; + + D.destroy(); // Free old strdup'd memory... + return N->castTypeAsserting(); + } default: - GenerateError("Internal parser error: Invalid symbol type reference!"); - return 0; + ThrowException("Invalid symbol type reference!"); } // If we reached here, we referenced either a symbol that we don't know about @@ -236,251 +167,132 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { // if (DoNotImprovise) return 0; // Do we just want a null to be returned? + vector<PATypeHolder<Type> > *LateResolver = CurMeth.CurrentMethod ? + &CurMeth.LateResolveTypes : &CurModule.LateResolveTypes; - 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<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D); - if (I != CurModule.LateResolveTypes.end()) - return I->second; - - Type *Typ = OpaqueType::get(); - CurModule.LateResolveTypes.insert(std::make_pair(D, Typ)); + Type *Typ = new TypePlaceHolder(Type::TypeTy, D); + InsertType(Typ, *LateResolver); return Typ; - } - -static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) { - SymbolTable &SymTab = - inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() : - CurModule.CurrentModule->getSymbolTable(); - return SymTab.lookup(Ty, Name); } -// getValNonImprovising - Look up the value specified by the provided type and -// the provided ValID. If the value exists and has already been defined, return -// it. Otherwise return null. -// -static Value *getValNonImprovising(const Type *Ty, const ValID &D) { - if (isa<FunctionType>(Ty)) { - GenerateError("Functions are not values and " - "must be referenced as pointers"); - return 0; - } +static Value *getVal(const Type *Ty, const ValID &D, + bool DoNotImprovise = false) { + assert(Ty != Type::TypeTy && "Should use getTypeVal for types!"); switch (D.Type) { - case ValID::NumberVal: { // Is it a numbered definition? + case 0: { // Is it a numbered definition? + unsigned type = Ty->getUniqueID(); unsigned Num = (unsigned)D.Num; // Module constants occupy the lowest numbered slots... - std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty); - if (VI != CurModule.Values.end()) { - if (Num < VI->second.size()) - return VI->second[Num]; - Num -= VI->second.size(); + if (type < CurModule.Values.size()) { + if (Num < CurModule.Values[type].size()) + return CurModule.Values[type][Num]; + + Num -= CurModule.Values[type].size(); } // Make sure that our type is within bounds - VI = CurFun.Values.find(Ty); - if (VI == CurFun.Values.end()) return 0; + if (CurMeth.Values.size() <= type) + break; // Check that the number is within bounds... - if (VI->second.size() <= Num) return 0; - - return VI->second[Num]; - } - - case ValID::NameVal: { // Is it a named definition? - Value *N = lookupInSymbolTable(Ty, std::string(D.Name)); - if (N == 0) return 0; + if (CurMeth.Values[type].size() <= Num) + break; + + return CurMeth.Values[type][Num]; + } + case 1: { // Is it a named definition? + string Name(D.Name); + SymbolTable *SymTab = 0; + if (CurMeth.CurrentMethod) + SymTab = CurMeth.CurrentMethod->getSymbolTable(); + Value *N = SymTab ? SymTab->lookup(Ty, Name) : 0; + + if (N == 0) { + // Symbol table doesn't automatically chain yet... because the method + // hasn't been added to the module... + // + SymTab = CurModule.CurrentModule->getSymbolTable(); + if (SymTab) + N = SymTab->lookup(Ty, Name); + if (N == 0) break; + } D.destroy(); // Free old strdup'd memory... return N; } - // Check to make sure that "Ty" is an integral type, and that our - // value will fit into the specified type... - case ValID::ConstSIntVal: // Is it a constant pool reference?? - if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { - GenerateError("Signed integral constant '" + - itostr(D.ConstPool64) + "' is invalid for type '" + - Ty->getDescription() + "'!"); - return 0; - } - return ConstantInt::get(Ty, D.ConstPool64); - - case ValID::ConstUIntVal: // Is it an unsigned const pool reference? - if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) { - if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { - GenerateError("Integral constant '" + utostr(D.UConstPool64) + - "' is invalid or out of range!"); - return 0; - } else { // This is really a signed reference. Transmogrify. - return ConstantInt::get(Ty, D.ConstPool64); - } - } else { - return ConstantInt::get(Ty, D.UConstPool64); - } - - case ValID::ConstFPVal: // Is it a floating point const pool reference? - if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { - GenerateError("FP constant invalid for type!!"); - return 0; - } - return ConstantFP::get(Ty, D.ConstPoolFP); + case 2: // Is it a constant pool reference?? + case 3: // Is it an unsigned const pool reference? + case 4: // Is it a string const pool reference? + case 5:{ // Is it a floating point const pool reference? + ConstPoolVal *CPV = 0; - case ValID::ConstNullVal: // Is it a null value? - if (!isa<PointerType>(Ty)) { - GenerateError("Cannot create a a non pointer null!"); - return 0; - } - return ConstantPointerNull::get(cast<PointerType>(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) { - GenerateError("Constant expression type different from required type!"); - return 0; - } - return D.ConstantValue; - - case ValID::InlineAsmVal: { // Inline asm expression - const PointerType *PTy = dyn_cast<PointerType>(Ty); - const FunctionType *FTy = - PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; - if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) { - GenerateError("Invalid type for asm constraint string!"); - return 0; + // Check to make sure that "Ty" is an integral type, and that our + // value will fit into the specified type... + switch (D.Type) { + case 2: + if (Ty == Type::BoolTy) { // Special handling for boolean data + CPV = ConstPoolBool::get(D.ConstPool64 != 0); + } else { + if (!ConstPoolSInt::isValueValidForType(Ty, D.ConstPool64)) + ThrowException("Symbolic constant pool value '" + + itostr(D.ConstPool64) + "' is invalid for type '" + + Ty->getName() + "'!"); + CPV = ConstPoolSInt::get(Ty, D.ConstPool64); + } + break; + case 3: + if (!ConstPoolUInt::isValueValidForType(Ty, D.UConstPool64)) { + if (!ConstPoolSInt::isValueValidForType(Ty, D.ConstPool64)) { + ThrowException("Integral constant pool reference is invalid!"); + } else { // This is really a signed reference. Transmogrify. + CPV = ConstPoolSInt::get(Ty, D.ConstPool64); + } + } else { + CPV = ConstPoolUInt::get(Ty, D.UConstPool64); + } + break; + case 4: + cerr << "FIXME: TODO: String constants [sbyte] not implemented yet!\n"; + abort(); + break; + case 5: + if (!ConstPoolFP::isValueValidForType(Ty, D.ConstPoolFP)) + ThrowException("FP constant invalid for type!!"); + else + CPV = ConstPoolFP::get(Ty, D.ConstPoolFP); + break; } - InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints, - D.IAD->HasSideEffects); - D.destroy(); // Free InlineAsmDescriptor. - return IA; - } + assert(CPV && "How did we escape creating a constant??"); + return CPV; + } // End of case 2,3,4 default: assert(0 && "Unhandled case!"); - return 0; } // End of switch - assert(0 && "Unhandled case!"); - return 0; -} - -// getVal - This function is identical to getValNonImprovising, except that if a -// value is not already defined, it "improvises" by creating a placeholder var -// that looks and acts just like the requested variable. When the value is -// defined later, all uses of the placeholder variable are replaced with the -// real thing. -// -static Value *getVal(const Type *Ty, const ValID &ID) { - 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<OpaqueType>(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 // forward, so just create an entry to be resolved later and get to it... // - V = new Argument(Ty); - - // Remember where this forward reference came from. FIXME, shouldn't we try - // to recycle these things?? - CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, - llvmAsmlineno))); - - if (inFunctionScope()) - InsertValue(V, CurFun.LateResolveValues); - else - InsertValue(V, CurModule.LateResolveValues); - return V; -} - -/// getBBVal - This is used for two purposes: -/// * If isDefinition is true, a new basic block with the specified ID is being -/// defined. -/// * If isDefinition is true, this is a reference to a basic block, which may -/// or may not be a forward reference. -/// -static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { - assert(inFunctionScope() && "Can't get basic block at global scope!"); - - std::string Name; - BasicBlock *BB = 0; - switch (ID.Type) { - default: - GenerateError("Illegal label reference " + ID.getName()); - return 0; - case ValID::NumberVal: // Is it a numbered definition? - if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size()) - CurFun.NumberedBlocks.resize(ID.Num+1); - BB = CurFun.NumberedBlocks[ID.Num]; - break; - case ValID::NameVal: // Is it a named definition? - Name = ID.Name; - if (Value *N = CurFun.CurrentFunction-> - getSymbolTable().lookup(Type::LabelTy, Name)) - BB = cast<BasicBlock>(N); - break; - } - - // See if the block has already been defined. - if (BB) { - // If this is the definition of the block, make sure the existing value was - // just a forward reference. If it was a forward reference, there will be - // an entry for it in the PlaceHolderInfo map. - if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) { - // The existing value was a definition, not a forward reference. - GenerateError("Redefinition of label " + ID.getName()); - return 0; - } + if (DoNotImprovise) return 0; // Do we just want a null to be returned? - ID.destroy(); // Free strdup'd memory. - return BB; - } + Value *d = 0; + vector<ValueList> *LateResolver = (CurMeth.CurrentMethod) ? + &CurMeth.LateResolveValues : &CurModule.LateResolveValues; - // Otherwise this block has not been seen before. - BB = new BasicBlock("", CurFun.CurrentFunction); - if (ID.Type == ValID::NameVal) { - BB->setName(ID.Name); - } else { - CurFun.NumberedBlocks[ID.Num] = BB; + switch (Ty->getPrimitiveID()) { + case Type::LabelTyID: d = new BBPlaceHolder(Ty, D); break; + case Type::MethodTyID: d = new MethPlaceHolder(Ty, D); + LateResolver = &CurModule.LateResolveValues; break; + default: d = new ValuePlaceHolder(Ty, D); break; } - // If this is not a definition, keep track of it so we can use it as a forward - // reference. - if (!isDefinition) { - // Remember where this forward reference came from. - CurFun.BBForwardRefs[BB] = std::make_pair(ID, llvmAsmlineno); - } else { - // The forward declaration could have been inserted anywhere in the - // function: insert it into the correct place now. - CurFun.CurrentFunction->getBasicBlockList().remove(BB); - CurFun.CurrentFunction->getBasicBlockList().push_back(BB); - } - ID.destroy(); - return BB; + assert(d != 0 && "How did we not make something?"); + InsertValue(d, *LateResolver); + return d; } @@ -492,550 +304,219 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { // values not defined yet... for example, a forward branch, or the PHI node for // a loop body. // -// This keeps a table (CurFun.LateResolveValues) of all such forward references +// This keeps a table (CurMeth.LateResolveValues) of all such forward references // 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<const Type*,ValueList> &LateResolvers, - std::map<const Type*,ValueList> *FutureLateResolvers) { +static void ResolveDefinitions(vector<ValueList> &LateResolvers) { // Loop over LateResolveDefs fixing up stuff that couldn't be resolved - for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(), - E = LateResolvers.end(); LRI != E; ++LRI) { - ValueList &List = LRI->second; - while (!List.empty()) { - Value *V = List.back(); - List.pop_back(); - - std::map<Value*, std::pair<ValID, int> >::iterator PHI = - CurModule.PlaceHolderInfo.find(V); - assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!"); - - ValID &DID = PHI->second.first; - - Value *TheRealValue = getValNonImprovising(LRI->first, DID); - if (TriggerError) - return; - if (TheRealValue) { - V->replaceAllUsesWith(TheRealValue); - delete V; - CurModule.PlaceHolderInfo.erase(PHI); - } else if (FutureLateResolvers) { - // Functions have their unresolved items forwarded to the module late - // resolver table - InsertValue(V, *FutureLateResolvers); - } else { - if (DID.Type == ValID::NameVal) { - GenerateError("Reference to an invalid definition: '" +DID.getName()+ - "' of type '" + V->getType()->getDescription() + "'", - PHI->second.second); - return; - } else { - GenerateError("Reference to an invalid definition: #" + - itostr(DID.Num) + " of type '" + - V->getType()->getDescription() + "'", - PHI->second.second); - return; - } + for (unsigned ty = 0; ty < LateResolvers.size(); ty++) { + while (!LateResolvers[ty].empty()) { + Value *V = LateResolvers[ty].back(); + LateResolvers[ty].pop_back(); + ValID &DID = getValIDFromPlaceHolder(V); + + Value *TheRealValue = getVal(Type::getUniqueIDType(ty), DID, true); + + if (TheRealValue == 0) { + if (DID.Type == 1) + ThrowException("Reference to an invalid definition: '" +DID.getName()+ + "' of type '" + V->getType()->getDescription() + "'", + getLineNumFromPlaceHolder(V)); + else + ThrowException("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", + getLineNumFromPlaceHolder(V)); } + + assert(!V->isType() && "Types should be in LateResolveTypes!"); + + V->replaceAllUsesWith(TheRealValue); + delete V; } } LateResolvers.clear(); } -// ResolveTypeTo - A brand new type was just declared. This means that (if -// name is not null) things referencing Name can be resolved. Otherwise, things -// refering to the number can be resolved. Do this now. -// -static void ResolveTypeTo(char *Name, const Type *ToTy) { - ValID D; - if (Name) D = ValID::create(Name); - else D = ValID::create((int)CurModule.Types.size()); - std::map<ValID, PATypeHolder>::iterator I = - CurModule.LateResolveTypes.find(D); - if (I != CurModule.LateResolveTypes.end()) { - ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); - CurModule.LateResolveTypes.erase(I); - } -} - -// setValueName - Set the specified value to the name given. The name may be -// null potentially, in which case this is a noop. The string passed in is -// assumed to be a malloc'd string buffer, and is free'd by this function. +// ResolveTypes - This goes through the forward referenced type table and makes +// sure that all type references are complete. This code is executed after the +// constant pool of a method or module is completely parsed. // -static void setValueName(Value *V, char *NameStr) { - if (NameStr) { - std::string Name(NameStr); // Copy string - free(NameStr); // Free old string - - if (V->getType() == Type::VoidTy) { - GenerateError("Can't assign name '" + Name+"' to value with void type!"); - return; - } - - assert(inFunctionScope() && "Must be in function scope!"); - SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable(); - if (ST.lookup(V->getType(), Name)) { - GenerateError("Redefinition of value named '" + Name + "' in the '" + - V->getType()->getDescription() + "' type plane!"); - return; +static void ResolveTypes(vector<PATypeHolder<Type> > &LateResolveTypes) { + while (!LateResolveTypes.empty()) { + const Type *Ty = LateResolveTypes.back(); + ValID &DID = getValIDFromPlaceHolder(Ty); + + const Type *TheRealType = getTypeVal(DID, true); + if (TheRealType == 0) { + if (DID.Type == 1) + ThrowException("Reference to an invalid type: '" +DID.getName(), + getLineNumFromPlaceHolder(Ty)); + else + ThrowException("Reference to an invalid type: #" + itostr(DID.Num), + getLineNumFromPlaceHolder(Ty)); } - // Set the name. - V->setName(Name); - } -} - -/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, -/// this is a declaration, otherwise it is a definition. -static GlobalVariable * -ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, - bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { - if (isa<FunctionType>(Ty)) { - GenerateError("Cannot declare global vars of function type!"); - return 0; - } - - const PointerType *PTy = PointerType::get(Ty); - - std::string Name; - if (NameStr) { - Name = NameStr; // Copy string - free(NameStr); // Free old string - } - - // See if this global value was forward referenced. If so, recycle the - // object. - ValID ID; - if (!Name.empty()) { - ID = ValID::create((char*)Name.c_str()); - } else { - ID = ValID::create((int)CurModule.Values[PTy].size()); - } - - if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { - // Move the global to the end of the list, from whereever it was - // previously inserted. - GlobalVariable *GV = cast<GlobalVariable>(FWGV); - CurModule.CurrentModule->getGlobalList().remove(GV); - CurModule.CurrentModule->getGlobalList().push_back(GV); - GV->setInitializer(Initializer); - GV->setLinkage(Linkage); - GV->setConstant(isConstantGlobal); - InsertValue(GV, CurModule.Values); - return GV; - } - - // If this global has a name, check to see if there is already a definition - // of this global in the module. If so, merge as appropriate. Note that - // this is really just a hack around problems in the CFE. :( - if (!Name.empty()) { - // We are a simple redefinition of a value, check to see if it is defined - // the same as the old one. - if (GlobalVariable *EGV = - CurModule.CurrentModule->getGlobalVariable(Name, Ty)) { - // We are allowed to redefine a global variable in two circumstances: - // 1. If at least one of the globals is uninitialized or - // 2. If both initializers have the same value. - // - if (!EGV->hasInitializer() || !Initializer || - EGV->getInitializer() == Initializer) { - - // Make sure the existing global version gets the initializer! Make - // sure that it also gets marked const if the new version is. - if (Initializer && !EGV->hasInitializer()) - EGV->setInitializer(Initializer); - if (isConstantGlobal) - EGV->setConstant(true); - EGV->setLinkage(Linkage); - return EGV; - } + // FIXME: When types are not const + DerivedType *DTy = const_cast<DerivedType*>(Ty->castDerivedTypeAsserting()); + + // Refine the opaque type we had to the new type we are getting. + DTy->refineAbstractTypeTo(TheRealType); - GenerateError("Redefinition of global variable named '" + Name + - "' in the '" + Ty->getDescription() + "' type plane!"); - return 0; - } + // No need to delete type, refine does that for us. + LateResolveTypes.pop_back(); } - - // Otherwise there is no existing GV to use, create one now. - GlobalVariable *GV = - new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, - CurModule.CurrentModule); - InsertValue(GV, CurModule.Values); - return GV; } -// setTypeName - Set the specified type to the name given. The name may be +// setValueName - Set the specified value to the name given. The name may be // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is freed by this function. // -// This function returns true if the type has already been defined, but is -// allowed to be redefined in the specified context. If the name is a new name -// for the type plane, it is inserted and false is returned. -static bool setTypeName(const Type *T, char *NameStr) { - assert(!inFunctionScope() && "Can't give types function-local names!"); - if (NameStr == 0) return false; - - std::string Name(NameStr); // Copy string +static void setValueName(Value *V, char *NameStr) { + if (NameStr == 0) return; + string Name(NameStr); // Copy string free(NameStr); // Free old string - // We don't allow assigning names to 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); - - if (AlreadyExists) { // Inserting a name that is already defined??? - const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); - assert(Existing && "Conflict but no matching type?"); + SymbolTable *ST = CurMeth.CurrentMethod ? + CurMeth.CurrentMethod->getSymbolTableSure() : + CurModule.CurrentModule->getSymbolTableSure(); + Value *Existing = ST->lookup(V->getType(), Name); + if (Existing) { // Inserting a name that is already defined??? // There is only one case where this is allowed: when we are refining an // opaque type. In this case, Existing will be an opaque type. - if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) { - // We ARE replacing an opaque type! - const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T); - return true; - } + if (const Type *Ty = Existing->castType()) + if (Ty->isOpaqueType()) { + // We ARE replacing an opaque type! - // Otherwise, this is an attempt to redefine a type. That's okay if - // the redefinition is identical to the original. This will be so if - // Existing and T point to the same Type object. In this one case we - // allow the equivalent redefinition. - if (Existing == T) return true; // Yes, it's equal. + // TODO: FIXME when types are not const! + const_cast<DerivedType*>(Ty->castDerivedTypeAsserting())->refineAbstractTypeTo(V->castTypeAsserting()); + return; + } - // Any other kind of (non-equivalent) redefinition is an error. - GenerateError("Redefinition of type named '" + Name + "' in the '" + - T->getDescription() + "' type plane!"); + // Otherwise, we are a simple redefinition of a value, baaad + ThrowException("Redefinition of value name '" + Name + "' in the '" + + V->getType()->getDescription() + "' type plane!"); } - return false; + V->setName(Name, ST); } + //===----------------------------------------------------------------------===// // Code for handling upreferences in type names... // -// TypeContains - Returns true if Ty directly contains E in it. +// TypeContains - Returns true if Ty contains E in it. // static bool TypeContains(const Type *Ty, const Type *E) { - return std::find(Ty->subtype_begin(), Ty->subtype_end(), - E) != Ty->subtype_end(); + return find(df_begin(Ty), df_end(Ty), E) != df_end(Ty); } -namespace { - struct UpRefRecord { - // 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; - - // UpRefTy - This is the actual opaque type that the upreference is - // represented with. - OpaqueType *UpRefTy; - - UpRefRecord(unsigned NL, OpaqueType *URTy) - : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {} - }; -} -// UpRefs - A list of the outstanding upreferences that need to be resolved. -static std::vector<UpRefRecord> UpRefs; - -/// HandleUpRefs - Every time we finish a new layer of types, this function is -/// called. It loops through the UpRefs vector, which is a list of the -/// currently active types. For each type, if the up reference is contained in -/// the newly completed type, we decrement the level count. When the level -/// count reaches zero, the upreferenced type is the type that is passed in: -/// thus we can complete the cycle. -/// -static PATypeHolder HandleUpRefs(const Type *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() << - "' newly formed. Resolving upreferences.\n" << - UpRefs.size() << " upreferences active!\n"); - - // If we find any resolvable upreferences (i.e., those whose NestingLevel goes - // to zero), we resolve them all together before we resolve them to Ty. At - // the end of the loop, if there is anything to resolve to Ty, it will be in - // this variable. - OpaqueType *TypeToResolve = 0; - - for (unsigned i = 0; i != UpRefs.size(); ++i) { - UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " - << UpRefs[i].second->getDescription() << ") = " - << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); - 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 (!TypeToResolve) { - TypeToResolve = UpRefs[i].UpRefTy; - } else { - UR_OUT(" * Resolving upreference for " - << UpRefs[i].second->getDescription() << "\n"; - std::string OldName = UpRefs[i].UpRefTy->getDescription()); - UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); - UR_OUT(" * Type '" << OldName << "' refined upreference to: " - << (const void*)Ty << ", " << Ty->getDescription() << "\n"); - } - UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... - --i; // Do not skip the next element... +static vector<pair<unsigned, OpaqueType *> > UpRefs; + +static PATypeHolder<Type> HandleUpRefs(const Type *ty) { + PATypeHolder<Type> Ty(ty); + UR_OUT(UpRefs.size() << " upreferences active!\n"); + for (unsigned i = 0; i < UpRefs.size(); ) { + UR_OUT("TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].second->getDescription() << ") = " + << TypeContains(Ty, UpRefs[i].second) << endl); + if (TypeContains(Ty, UpRefs[i].second)) { + unsigned Level = --UpRefs[i].first; // Decrement level of upreference + UR_OUT("Uplevel Ref Level = " << Level << endl); + if (Level == 0) { // Upreference should be resolved! + UR_OUT("About to resolve upreference!\n"; + string OldName = UpRefs[i].second->getDescription()); + UpRefs[i].second->refineAbstractTypeTo(Ty); + UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... + UR_OUT("Type '" << OldName << "' refined upreference to: " + << (const void*)Ty << ", " << Ty->getDescription() << endl); + continue; } } - } - if (TypeToResolve) { - UR_OUT(" * Resolving upreference for " - << UpRefs[i].second->getDescription() << "\n"; - std::string OldName = TypeToResolve->getDescription()); - TypeToResolve->refineAbstractTypeTo(Ty); + ++i; // Otherwise, no resolve, move on... } - + // FIXME: TODO: this should return the updated type return Ty; } -/// This function is used to obtain the correct opcode for an instruction when -/// an obsolete opcode is encountered. The OI parameter (OpcodeInfo) has both -/// an opcode and an "obsolete" flag. These are generated by the lexer and -/// the "obsolete" member will be true when the lexer encounters the token for -/// an obsolete opcode. For example, "div" was replaced by [usf]div but we need -/// to maintain backwards compatibility for asm files that still have the "div" -/// instruction. This function handles converting div -> [usf]div appropriately. -/// @brief Convert obsolete opcodes to new values -static void -sanitizeOpCode(OpcodeInfo<Instruction::BinaryOps> &OI, const PATypeHolder& PATy) -{ - // If its not obsolete, don't do anything - if (!OI.obsolete) - return; - - // If its a packed type we want to use the element type - const Type* Ty = PATy; - if (const PackedType* PTy = dyn_cast<PackedType>(Ty)) - Ty = PTy->getElementType(); - - // Depending on the opcode .. - switch (OI.opcode) { - default: - GenerateError("Invalid obsolete opCode (check Lexer.l)"); - break; - case Instruction::UDiv: - // Handle cases where the opcode needs to change - if (Ty->isFloatingPoint()) - OI.opcode = Instruction::FDiv; - else if (Ty->isSigned()) - OI.opcode = Instruction::SDiv; - break; - case Instruction::URem: - if (Ty->isFloatingPoint()) - OI.opcode = Instruction::FRem; - else if (Ty->isSigned()) - OI.opcode = Instruction::SRem; - break; - } - // Its not obsolete any more, we fixed it. - OI.obsolete = false; +template <class TypeTy> +inline static void TypeDone(PATypeHolder<TypeTy> *Ty) { + if (UpRefs.size()) + ThrowException("Invalid upreference in type: " + (*Ty)->getDescription()); } - -// common code from the two 'RunVMAsmParser' functions -static Module* RunParser(Module * M) { - - llvmAsmlineno = 1; // Reset the current line number... - ObsoleteVarArgs = false; - NewVarArgs = false; - CurModule.CurrentModule = M; - - // Check to make sure the parser succeeded - if (yyparse()) { - if (ParserResult) - delete ParserResult; - return 0; - } - - // Check to make sure that parsing produced a result - if (!ParserResult) - return 0; - - // Reset ParserResult variable while saving its value for the result. - Module *Result = ParserResult; - ParserResult = 0; - - //Not all functions use vaarg, so make a second check for ObsoleteVarArgs - { - Function* F; - if ((F = Result->getNamedFunction("llvm.va_start")) - && F->getFunctionType()->getNumParams() == 0) - ObsoleteVarArgs = true; - if((F = Result->getNamedFunction("llvm.va_copy")) - && F->getFunctionType()->getNumParams() == 1) - ObsoleteVarArgs = true; - } - - if (ObsoleteVarArgs && NewVarArgs) { - GenerateError( - "This file is corrupt: it uses both new and old style varargs"); - return 0; - } - - if(ObsoleteVarArgs) { - if(Function* F = Result->getNamedFunction("llvm.va_start")) { - if (F->arg_size() != 0) { - GenerateError("Obsolete va_start takes 0 argument!"); - return 0; - } - - //foo = va_start() - // -> - //bar = alloca typeof(foo) - //va_start(bar) - //foo = load bar - - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getReturnType(); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_start", - RetTy, ArgTyPtr, (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast<CallInst>(F->use_back()); - AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI); - new CallInst(NF, bar, "", CI); - Value* foo = new LoadInst(bar, "vastart.fix.2", CI); - CI->replaceAllUsesWith(foo); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - - if(Function* F = Result->getNamedFunction("llvm.va_end")) { - if(F->arg_size() != 1) { - GenerateError("Obsolete va_end takes 1 argument!"); - return 0; - } - //vaend foo - // -> - //bar = alloca 1 of typeof(foo) - //vaend bar - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getParamType(0); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_end", - RetTy, ArgTyPtr, (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast<CallInst>(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); - } +// newTH - Allocate a new type holder for the specified type +template <class TypeTy> +inline static PATypeHolder<TypeTy> *newTH(const TypeTy *Ty) { + return new PATypeHolder<TypeTy>(Ty); +} +template <class TypeTy> +inline static PATypeHolder<TypeTy> *newTH(const PATypeHolder<TypeTy> &TH) { + return new PATypeHolder<TypeTy>(TH); +} - if(Function* F = Result->getNamedFunction("llvm.va_copy")) { - if(F->arg_size() != 1) { - GenerateError("Obsolete va_copy takes 1 argument!"); - return 0; - } - //foo = vacopy(bar) - // -> - //a = alloca 1 of typeof(foo) - //b = alloca 1 of typeof(foo) - //store bar -> b - //vacopy(a, b) - //foo = load a - - const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID); - const Type* ArgTy = F->getFunctionType()->getReturnType(); - const Type* ArgTyPtr = PointerType::get(ArgTy); - Function* NF = Result->getOrInsertFunction("llvm.va_copy", - RetTy, ArgTyPtr, ArgTyPtr, - (Type *)0); - - while (!F->use_empty()) { - CallInst* CI = cast<CallInst>(F->use_back()); - AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI); - AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI); - new StoreInst(CI->getOperand(1), b, CI); - new CallInst(NF, a, b, "", CI); - Value* foo = new LoadInst(a, "vacopy.fix.3", CI); - CI->replaceAllUsesWith(foo); - CI->getParent()->getInstList().erase(CI); - } - Result->getFunctionList().erase(F); - } - } - return Result; +// newTHC - Allocate a new type holder for the specified type that can be +// casted to a new Type type. +template <class TypeTy, class OldTy> +inline static PATypeHolder<TypeTy> *newTHC(const PATypeHolder<OldTy> &Old) { + return new PATypeHolder<TypeTy>((const TypeTy*)Old.get()); } + //===----------------------------------------------------------------------===// // RunVMAsmParser - Define an interface to this parser //===----------------------------------------------------------------------===// // -Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { - set_scan_file(F); - +Module *RunVMAsmParser(const string &Filename, FILE *F) { + llvmAsmin = F; CurFilename = Filename; - return RunParser(new Module(CurFilename)); -} + llvmAsmlineno = 1; // Reset the current line number... -Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { - set_scan_string(AsmString); + CurModule.CurrentModule = new Module(); // Allocate a new module to read + yyparse(); // Parse the file. + Module *Result = ParserResult; + llvmAsmin = stdin; // F is about to go away, don't use it anymore... + ParserResult = 0; - CurFilename = "from_memory"; - if (M == NULL) { - return RunParser(new Module (CurFilename)); - } else { - return RunParser(M); - } + return Result; } %} %union { - llvm::Module *ModuleVal; - llvm::Function *FunctionVal; - std::pair<llvm::PATypeHolder*, char*> *ArgVal; - llvm::BasicBlock *BasicBlockVal; - llvm::TerminatorInst *TermInstVal; - llvm::Instruction *InstVal; - llvm::Constant *ConstVal; - - const llvm::Type *PrimType; - llvm::PATypeHolder *TypeVal; - llvm::Value *ValueVal; - - std::vector<std::pair<llvm::PATypeHolder*,char*> > *ArgList; - std::vector<llvm::Value*> *ValueList; - std::list<llvm::PATypeHolder> *TypeList; - // Represent the RHS of PHI node - std::list<std::pair<llvm::Value*, - llvm::BasicBlock*> > *PHIList; - std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable; - std::vector<llvm::Constant*> *ConstVector; - - llvm::GlobalValue::LinkageTypes Linkage; + Module *ModuleVal; + Method *MethodVal; + MethodArgument *MethArgVal; + BasicBlock *BasicBlockVal; + TerminatorInst *TermInstVal; + Instruction *InstVal; + ConstPoolVal *ConstVal; + + const Type *PrimType; + PATypeHolder<Type> *TypeVal; + PATypeHolder<ArrayType> *ArrayTypeTy; + PATypeHolder<StructType> *StructTypeTy; + Value *ValueVal; + + list<MethodArgument*> *MethodArgList; + list<Value*> *ValueList; + list<PATypeHolder<Type> > *TypeList; + list<pair<Value*, BasicBlock*> > *PHIList; // Represent the RHS of PHI node + list<pair<ConstPoolVal*, BasicBlock*> > *JumpTable; + vector<ConstPoolVal*> *ConstVector; + int64_t SInt64Val; uint64_t UInt64Val; int SIntVal; @@ -1044,38 +525,31 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { bool BoolVal; char *StrVal; // This memory is strdup'd! - llvm::ValID ValIDVal; // strdup'd memory maybe! + ValID ValIDVal; // strdup'd memory maybe! - BinaryOpInfo BinaryOpVal; - TermOpInfo TermOpVal; - MemOpInfo MemOpVal; - OtherOpInfo OtherOpVal; - llvm::Module::Endianness Endianness; + Instruction::UnaryOps UnaryOpVal; + Instruction::BinaryOps BinaryOpVal; + Instruction::TermOps TermOpVal; + Instruction::MemoryOps MemOpVal; + Instruction::OtherOps OtherOpVal; } -%type <ModuleVal> Module FunctionList -%type <FunctionVal> Function FunctionProto FunctionHeader BasicBlockList +%type <ModuleVal> Module MethodList +%type <MethodVal> Method MethodProto MethodHeader BasicBlockList %type <BasicBlockVal> BasicBlock InstructionList %type <TermInstVal> BBTerminatorInst %type <InstVal> Inst InstVal MemoryInst -%type <ConstVal> ConstVal ConstExpr -%type <ConstVector> ConstVector -%type <ArgList> ArgList ArgListH -%type <ArgVal> ArgVal +%type <ConstVal> ConstVal ExtendedConstVal +%type <ConstVector> ConstVector UByteList +%type <MethodArgList> ArgList ArgListH +%type <MethArgVal> ArgVal %type <PHIList> PHIList %type <ValueList> ValueRefList ValueRefListE // For call param lists -%type <ValueList> IndexList // For GEP derived indices %type <TypeList> TypeListI ArgTypeListI %type <JumpTable> JumpTable %type <BoolVal> GlobalType // GLOBAL or CONSTANT? -%type <BoolVal> OptVolatile // 'volatile' or not -%type <BoolVal> OptTailCall // TAIL CALL or plain CALL. -%type <BoolVal> OptSideEffect // 'sideeffect' or not. -%type <Linkage> OptLinkage -%type <Endianness> BigOrLittle - -// ValueRef - Unresolved reference to a definition or BB -%type <ValIDVal> ValueRef ConstValueRef SymbolicValueRef + +%type <ValIDVal> ValueRef ConstValueRef // Reference to a definition or BB %type <ValueVal> ResolvedVal // <type> <valref> pair // Tokens and types for handling constant integer values // @@ -1094,679 +568,346 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { // Built in types... %type <TypeVal> Types TypesV UpRTypes UpRTypesV %type <PrimType> SIntType UIntType IntType FPType PrimType // Classifications +%token <TypeVal> OPAQUE %token <PrimType> VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG %token <PrimType> FLOAT DOUBLE TYPE LABEL +%type <ArrayTypeTy> ArrayType ArrayTypeI +%type <StructTypeTy> StructType StructTypeI + +%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT +%type <StrVal> OptVAR_ID OptAssign + + +%token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE GLOBAL CONSTANT UNINIT +%token TO DOTDOTDOT STRING -%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT -%type <StrVal> Name OptName OptAssign -%type <UIntVal> OptAlign OptCAlign -%type <StrVal> OptSection SectionString - -%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK -%token DECLARE GLOBAL CONSTANT SECTION VOLATILE -%token TO DOTDOTDOT NULL_TOK UNDEF CONST INTERNAL LINKONCE WEAK APPENDING -%token 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 <UIntVal> OptCallingConv - -// Basic Block Terminating Operators -%token <TermOpVal> RET BR SWITCH INVOKE UNWIND UNREACHABLE - -// Binary Operators -%type <BinaryOpVal> ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories -%token <BinaryOpVal> ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR -%token <BinaryOpVal> SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comparators +// Basic Block Terminating Operators +%token <TermOpVal> RET BR SWITCH + +// Unary Operators +%type <UnaryOpVal> UnaryOps // all the unary operators +%token <UnaryOpVal> NOT + +// Binary Operators +%type <BinaryOpVal> BinaryOps // all the binary operators +%token <BinaryOpVal> ADD SUB MUL DIV REM +%token <BinaryOpVal> SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comarators // Memory Instructions -%token <MemOpVal> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR +%token <MemoryOpVal> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR // Other Operators %type <OtherOpVal> ShiftOps -%token <OtherOpVal> PHI_TOK CAST SELECT SHL SHR VAARG -%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR -%token VAARG_old VANEXT_old //OBSOLETE - +%token <OtherOpVal> PHI CALL CAST SHL SHR %start Module %% // Handle constant integer size restriction and conversion... // -INTVAL : SINTVAL; + +INTVAL : SINTVAL INTVAL : UINTVAL { if ($1 > (uint32_t)INT32_MAX) // Outside of my range! - GEN_ERROR("Value too large for type!"); + ThrowException("Value too large for type!"); $$ = (int32_t)$1; - CHECK_FOR_ERROR -}; +} -EINT64VAL : ESINT64VAL; // These have same type and can't cause problems... +EINT64VAL : ESINT64VAL // These have same type and can't cause problems... EINT64VAL : EUINT64VAL { if ($1 > (uint64_t)INT64_MAX) // Outside of my range! - GEN_ERROR("Value too large for type!"); + ThrowException("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 | UDIV | SDIV | FDIV | UREM | SREM | FREM; -LogicalOps : AND | OR | XOR; -SetCondOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE; - -ShiftOps : SHL | SHR; +UnaryOps : NOT +BinaryOps : ADD | SUB | MUL | DIV | REM +BinaryOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE +ShiftOps : SHL | SHR // These are some types that allow classification if we only want a particular // thing... for example, only a signed, unsigned, or integral type. -SIntType : LONG | INT | SHORT | SBYTE; -UIntType : ULONG | UINT | USHORT | UBYTE; -IntType : SIntType | UIntType; -FPType : FLOAT | DOUBLE; +SIntType : LONG | INT | SHORT | SBYTE +UIntType : ULONG | UINT | USHORT | UBYTE +IntType : SIntType | UIntType +FPType : FLOAT | DOUBLE // OptAssign - Value producing statements have an optional assignment component -OptAssign : Name '=' { +OptAssign : VAR_ID '=' { $$ = $1; - CHECK_FOR_ERROR } - | /*empty*/ { - $$ = 0; - CHECK_FOR_ERROR - }; - -OptLinkage : INTERNAL { $$ = GlobalValue::InternalLinkage; } | - LINKONCE { $$ = GlobalValue::LinkOnceLinkage; } | - WEAK { $$ = GlobalValue::WeakLinkage; } | - APPENDING { $$ = GlobalValue::AppendingLinkage; } | - DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; } | - DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; } | - EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } | - /*empty*/ { $$ = GlobalValue::ExternalLinkage; }; - -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; }; + | /*empty*/ { + $$ = 0; + } -// 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 -// used in specific contexts (function returning void for example). To have +// used in specific contexts (method returning void for example). To have // access to it, a user must explicitly use TypesV. // // TypesV includes all of 'Types', but it also includes the void type. -TypesV : Types | VOID { $$ = new PATypeHolder($1); }; -UpRTypesV : UpRTypes | VOID { $$ = new PATypeHolder($1); }; +TypesV : Types | VOID { $$ = newTH($1); } +UpRTypesV : UpRTypes | VOID { $$ = newTH($1); } Types : UpRTypes { - if (!UpRefs.empty()) - GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription()); - $$ = $1; - CHECK_FOR_ERROR - }; + TypeDone($$ = $1); + } // Derived types are added later... // -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... - const Type* tmp = getTypeVal($1); - CHECK_FOR_ERROR - $$ = new PATypeHolder(tmp); -}; +PrimType : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT +PrimType : LONG | ULONG | FLOAT | DOUBLE | TYPE | LABEL +UpRTypes : OPAQUE | PrimType { $$ = newTH($1); } +UpRTypes : ValueRef { // Named types are also simple types... + $$ = newTH(getTypeVal($1)); +} + +// ArrayTypeI - Internal version of ArrayType that can have incomplete uprefs +// +ArrayTypeI : '[' UpRTypesV ']' { // Unsized array type? + $$ = newTHC<ArrayType>(HandleUpRefs(ArrayType::get(*$2))); + delete $2; + } + | '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type? + $$ = newTHC<ArrayType>(HandleUpRefs(ArrayType::get(*$4, (int)$2))); + delete $4; + } + +StructTypeI : '{' TypeListI '}' { // Structure type? + vector<const Type*> Elements; + mapto($2->begin(), $2->end(), back_inserter(Elements), + mem_fun_ref(&PATypeHandle<Type>::get)); + + $$ = newTHC<StructType>(HandleUpRefs(StructType::get(Elements))); + delete $2; + } + | '{' '}' { // Empty structure type? + $$ = newTH(StructType::get(vector<const Type*>())); + } + // Include derived types in the Types production. // UpRTypes : '\\' EUINT64VAL { // Type UpReference - if ($2 > (uint64_t)~0U) GEN_ERROR("Value out of range!"); + if ($2 > (uint64_t)INT64_MAX) ThrowException("Value out of range!"); OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder - UpRefs.push_back(UpRefRecord((unsigned)$2, OT)); // Add to vector... - $$ = new PATypeHolder(OT); + UpRefs.push_back(make_pair((unsigned)$2, OT)); // Add to vector... + $$ = newTH<Type>(OT); UR_OUT("New Upreference!\n"); - CHECK_FOR_ERROR } - | UpRTypesV '(' ArgTypeListI ')' { // Function derived type? - std::vector<const Type*> Params; - for (std::list<llvm::PATypeHolder>::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))); + | UpRTypesV '(' ArgTypeListI ')' { // Method derived type? + vector<const Type*> Params; + mapto($3->begin(), $3->end(), back_inserter(Params), + mem_fun_ref(&PATypeHandle<Type>::get)); + $$ = newTH(HandleUpRefs(MethodType::get(*$1, Params))); delete $3; // Delete the argument list - delete $1; // Delete the return type handle - CHECK_FOR_ERROR + delete $1; // Delete the old type handle } - | '[' 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) - 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<const Type*> Elements; - for (std::list<llvm::PATypeHolder>::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 + | ArrayTypeI { // [Un]sized array type? + $$ = newTHC<Type>(*$1); delete $1; } - | '{' '}' { // Empty structure type? - $$ = new PATypeHolder(StructType::get(std::vector<const Type*>())); - CHECK_FOR_ERROR + | StructTypeI { // Structure type? + $$ = newTHC<Type>(*$1); delete $1; } | 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 - }; + $$ = newTH(HandleUpRefs(PointerType::get(*$1))); + delete $1; // Delete the type handle + } + +// Define some helpful top level types that do not allow UpReferences to escape +// +ArrayType : ArrayTypeI { TypeDone($$ = $1); } +StructType : StructTypeI { TypeDone($$ = $1); } + -// TypeList - Used for struct declarations and as a basis for function type + +// TypeList - Used for struct declarations and as a basis for method type // declaration type lists // TypeListI : UpRTypes { - $$ = new std::list<PATypeHolder>(); + $$ = new list<PATypeHolder<Type> >(); $$->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... +// ArgTypeList - List of types for a method type declaration... ArgTypeListI : TypeListI | TypeListI ',' DOTDOTDOT { ($$=$1)->push_back(Type::VoidTy); - CHECK_FOR_ERROR } | DOTDOTDOT { - ($$ = new std::list<PATypeHolder>())->push_back(Type::VoidTy); - CHECK_FOR_ERROR + ($$ = new list<PATypeHolder<Type> >())->push_back(Type::VoidTy); } | /*empty*/ { - $$ = new std::list<PATypeHolder>(); - CHECK_FOR_ERROR - }; + $$ = new list<PATypeHolder<Type> >(); + } + // ConstVal - The various declarations that go into the constant pool. This -// production is used ONLY to represent constants that show up AFTER a 'const', -// 'constant' or 'global' token at global scope. Constants that can be inlined -// into other expressions (such as integers and constexprs) are handled by the -// ResolvedVal, ValueRef and ConstValueRef productions. +// includes all forward declarations of types, constants, and functions. +// +// This is broken into two sections: ExtendedConstVal and ConstVal // -ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr - const ArrayType *ATy = dyn_cast<ArrayType>($1->get()); - if (ATy == 0) - GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); +ExtendedConstVal: ArrayType '[' ConstVector ']' { // Nonempty unsized arr + const ArrayType *ATy = *$1; const Type *ETy = ATy->getElementType(); int NumElements = ATy->getNumElements(); // Verify that we have the correct size... if (NumElements != -1 && NumElements != (int)$3->size()) - GEN_ERROR("Type mismatch: constant sized array initialized with " + - utostr($3->size()) + " arguments, but has size of " + - itostr(NumElements) + "!"); + ThrowException("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()) - GEN_ERROR("Element #" + utostr(i) + " is not of type '" + - ETy->getDescription() +"' as required!\nIt is of type '"+ - (*$3)[i]->getType()->getDescription() + "'."); + ThrowException("Element #" + utostr(i) + " is not of type '" + + ETy->getName() + "' as required!\nIt is of type '" + + (*$3)[i]->getType()->getName() + "'."); } - $$ = ConstantArray::get(ATy, *$3); + $$ = ConstPoolArray::get(ATy, *$3); delete $1; delete $3; - CHECK_FOR_ERROR } - | Types '[' ']' { - const ArrayType *ATy = dyn_cast<ArrayType>($1->get()); - if (ATy == 0) - GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); - - int NumElements = ATy->getNumElements(); + | ArrayType '[' ']' { + int NumElements = (*$1)->getNumElements(); if (NumElements != -1 && NumElements != 0) - GEN_ERROR("Type mismatch: constant sized array initialized with 0" - " arguments, but has size of " + itostr(NumElements) +"!"); - $$ = ConstantArray::get(ATy, std::vector<Constant*>()); + ThrowException("Type mismatch: constant sized array initialized with 0" + " arguments, but has size of " + itostr(NumElements) +"!"); + $$ = ConstPoolArray::get((*$1), vector<ConstPoolVal*>()); delete $1; - CHECK_FOR_ERROR } - | Types 'c' STRINGCONSTANT { - const ArrayType *ATy = dyn_cast<ArrayType>($1->get()); - if (ATy == 0) - GEN_ERROR("Cannot make array constant with type: '" + - (*$1)->getDescription() + "'!"); - + | ArrayType 'c' STRINGCONSTANT { + const ArrayType *ATy = *$1; int NumElements = ATy->getNumElements(); const Type *ETy = ATy->getElementType(); char *EndStr = UnEscapeLexed($3, true); if (NumElements != -1 && NumElements != (EndStr-$3)) - GEN_ERROR("Can't build string constant of size " + - itostr((int)(EndStr-$3)) + - " when array has size " + itostr(NumElements) + "!"); - std::vector<Constant*> Vals; + ThrowException("Can't build string constant of size " + + itostr((int)(EndStr-$3)) + + " when array has size " + itostr(NumElements) + "!"); + vector<ConstPoolVal*> Vals; if (ETy == Type::SByteTy) { - for (signed char *C = (signed char *)$3; C != (signed char *)EndStr; ++C) - Vals.push_back(ConstantInt::get(ETy, *C)); + for (char *C = $3; C != EndStr; ++C) + Vals.push_back(ConstPoolSInt::get(ETy, *C)); } else if (ETy == Type::UByteTy) { - for (unsigned char *C = (unsigned char *)$3; - C != (unsigned char*)EndStr; ++C) - Vals.push_back(ConstantInt::get(ETy, *C)); + for (char *C = $3; C != EndStr; ++C) + Vals.push_back(ConstPoolUInt::get(ETy, *C)); } else { free($3); - GEN_ERROR("Cannot build string arrays of non byte sized elements!"); + ThrowException("Cannot build string arrays of non byte sized elements!"); } free($3); - $$ = ConstantArray::get(ATy, Vals); + $$ = ConstPoolArray::get(ATy, Vals); delete $1; - CHECK_FOR_ERROR } - | Types '<' ConstVector '>' { // Nonempty unsized arr - const PackedType *PTy = dyn_cast<PackedType>($1->get()); - if (PTy == 0) - 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()) - 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()) - 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); + | StructType '{' ConstVector '}' { + // FIXME: TODO: Check to see that the constants are compatible with the type + // initializer! + $$ = ConstPoolStruct::get(*$1, *$3); delete $1; delete $3; - CHECK_FOR_ERROR - } - | Types '{' ConstVector '}' { - const StructType *STy = dyn_cast<StructType>($1->get()); - if (STy == 0) - GEN_ERROR("Cannot make struct constant with type: '" + - (*$1)->getDescription() + "'!"); - - if ($3->size() != STy->getNumContainedTypes()) - GEN_ERROR("Illegal number of initializers for structure type!"); - - // Check to ensure that constants are compatible with the type initializer! - for (unsigned i = 0, e = $3->size(); i != e; ++i) - if ((*$3)[i]->getType() != STy->getElementType(i)) - GEN_ERROR("Expected type '" + - STy->getElementType(i)->getDescription() + - "' for element #" + utostr(i) + - " of structure initializer!"); - - $$ = ConstantStruct::get(STy, *$3); - delete $1; delete $3; - CHECK_FOR_ERROR } - | Types '{' '}' { - const StructType *STy = dyn_cast<StructType>($1->get()); - if (STy == 0) - GEN_ERROR("Cannot make struct constant with type: '" + - (*$1)->getDescription() + "'!"); - - if (STy->getNumContainedTypes() != 0) - GEN_ERROR("Illegal number of initializers for structure type!"); +/* + | Types '*' ConstVal { + assert(0); + $$ = 0; + } +*/ - $$ = ConstantStruct::get(STy, std::vector<Constant*>()); - delete $1; - CHECK_FOR_ERROR +ConstVal : ExtendedConstVal { + $$ = $1; + } + | SIntType EINT64VAL { // integral constants + if (!ConstPoolSInt::isValueValidForType($1, $2)) + ThrowException("Constant value doesn't fit in type!"); + $$ = ConstPoolSInt::get($1, $2); + } + | UIntType EUINT64VAL { // integral constants + if (!ConstPoolUInt::isValueValidForType($1, $2)) + ThrowException("Constant value doesn't fit in type!"); + $$ = ConstPoolUInt::get($1, $2); + } + | BOOL TRUE { // Boolean constants + $$ = ConstPoolBool::True; + } + | BOOL FALSE { // Boolean constants + $$ = ConstPoolBool::False; + } + | FPType FPVAL { // Float & Double constants + $$ = ConstPoolFP::get($1, $2); } - | Types NULL_TOK { - const PointerType *PTy = dyn_cast<PointerType>($1->get()); - if (PTy == 0) - GEN_ERROR("Cannot make null pointer constant with type: '" + - (*$1)->getDescription() + "'!"); - $$ = ConstantPointerNull::get(PTy); - delete $1; - CHECK_FOR_ERROR +// ConstVector - A list of comma seperated constants. +ConstVector : ConstVector ',' ConstVal { + ($$ = $1)->push_back($3); + } + | ConstVal { + $$ = new vector<ConstPoolVal*>(); + $$->push_back($1); } - | Types UNDEF { - $$ = UndefValue::get($1->get()); - delete $1; - CHECK_FOR_ERROR - } - | Types SymbolicValueRef { - const PointerType *Ty = dyn_cast<PointerType>($1->get()); - if (Ty == 0) - GEN_ERROR("Global const reference must be a pointer type!"); - - // ConstExprs can exist in the body of a function, thus creating - // GlobalValues whenever they refer to a variable. Because we are in - // the context of a function, getValNonImprovising will search the functions - // symbol table instead of the module symbol table for the global symbol, - // which throws things all off. To get around this, we just tell - // getValNonImprovising that we are at global scope here. - // - Function *SavedCurFn = CurFun.CurrentFunction; - CurFun.CurrentFunction = 0; - Value *V = getValNonImprovising(Ty, $2); - CHECK_FOR_ERROR - CurFun.CurrentFunction = SavedCurFn; +// GlobalType - Match either GLOBAL or CONSTANT for global declarations... +GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; } - // If this is an initializer for a constant pointer, which is referencing a - // (currently) undefined variable, create a stub now that shall be replaced - // in the future with the right type of variable. - // - if (V == 0) { - assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!"); - const PointerType *PT = cast<PointerType>(Ty); - // First check to see if the forward references value is already created! - PerModuleInfo::GlobalRefsType::iterator I = - CurModule.GlobalRefs.find(std::make_pair(PT, $2)); - - if (I != CurModule.GlobalRefs.end()) { - V = I->second; // Placeholder already exists, use it... - $2.destroy(); - } else { - std::string Name; - if ($2.Type == ValID::NameVal) Name = $2.Name; - - // Create the forward referenced global. - GlobalValue *GV; - if (const FunctionType *FTy = - dyn_cast<FunctionType>(PT->getElementType())) { - GV = new Function(FTy, GlobalValue::ExternalLinkage, Name, - CurModule.CurrentModule); - } else { - GV = new GlobalVariable(PT->getElementType(), false, - GlobalValue::ExternalLinkage, 0, - Name, CurModule.CurrentModule); - } +// ConstPool - Constants with optional names assigned to them. +ConstPool : ConstPool OptAssign ConstVal { + setValueName($3, $2); + InsertValue($3); + } + | ConstPool OptAssign TYPE TypesV { // Types can be defined in the const pool + // TODO: FIXME when Type are not const + setValueName(const_cast<Type*>($4->get()), $2); - // Keep track of the fact that we have a forward ref to recycle it - CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV)); - V = GV; - } + if (!$2) { + InsertType($4->get(), + CurMeth.CurrentMethod ? CurMeth.Types : CurModule.Types); } - - $$ = cast<GlobalValue>(V); - delete $1; // Free the type handle - CHECK_FOR_ERROR + delete $4; } - | Types ConstExpr { - if ($1->get() != $2->getType()) - GEN_ERROR("Mismatched types for constant expression!"); - $$ = $2; - delete $1; - CHECK_FOR_ERROR + | ConstPool MethodProto { // Method prototypes can be in const pool } - | Types ZEROINITIALIZER { - const Type *Ty = $1->get(); - if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty)) - GEN_ERROR("Cannot create a null initialized value of this type!"); - $$ = Constant::getNullValue(Ty); - delete $1; - CHECK_FOR_ERROR - }; + | ConstPool OptAssign GlobalType ResolvedVal { + const Type *Ty = $4->getType(); + // Global declarations appear in Constant Pool + ConstPoolVal *Initializer = $4->castConstant(); + if (Initializer == 0) + ThrowException("Global value initializer is not a constant!"); + + GlobalVariable *GV = new GlobalVariable(PointerType::get(Ty), $3, + Initializer); + setValueName(GV, $2); -ConstVal : 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 (!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::getTrue(); - CHECK_FOR_ERROR - } - | BOOL FALSETOK { // Boolean constants - $$ = ConstantBool::getFalse(); - CHECK_FOR_ERROR + CurModule.CurrentModule->getGlobalList().push_back(GV); + InsertValue(GV, CurModule.Values); } - | 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()) - GEN_ERROR("cast constant expression from a non-primitive type: '" + - $3->getType()->getDescription() + "'!"); - if (!$5->get()->isFirstClassType()) - GEN_ERROR("cast constant expression to a non-primitive type: '" + - $5->get()->getDescription() + "'!"); - $$ = ConstantExpr::getCast($3, $5->get()); - delete $5; - CHECK_FOR_ERROR - } - | GETELEMENTPTR '(' ConstVal IndexList ')' { - if (!isa<PointerType>($3->getType())) - GEN_ERROR("GetElementPtr requires a pointer operand!"); - - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct - // indices to uint struct indices for compatibility. - generic_gep_type_iterator<std::vector<Value*>::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<StructType>(*GTI)) // Only change struct indices - if (ConstantInt *CUI = dyn_cast<ConstantInt>((*$4)[i])) - if (CUI->getType() == Type::UByteTy) - (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy); - - const Type *IdxTy = - GetElementPtrInst::getIndexedType($3->getType(), *$4, true); - if (!IdxTy) - GEN_ERROR("Index list invalid for constant getelementptr!"); - - std::vector<Constant*> IdxVec; - for (unsigned i = 0, e = $4->size(); i != e; ++i) - if (Constant *C = dyn_cast<Constant>((*$4)[i])) - IdxVec.push_back(C); - else - 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) - GEN_ERROR("Select condition must be of boolean type!"); - if ($5->getType() != $7->getType()) - GEN_ERROR("Select operand types must match!"); - $$ = ConstantExpr::getSelect($3, $5, $7); - CHECK_FOR_ERROR - } - | ArithmeticOps '(' ConstVal ',' ConstVal ')' { - if ($3->getType() != $5->getType()) - GEN_ERROR("Binary operator types must match!"); - // First, make sure we're dealing with the right opcode by upgrading from - // obsolete versions. - sanitizeOpCode($1,$3->getType()); - CHECK_FOR_ERROR; - - // 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<PointerType>($3->getType())) { - $$ = ConstantExpr::get($1.opcode, $3, $5); - } else { - const Type *IntPtrTy = 0; - switch (CurModule.CurrentModule->getPointerSize()) { - case Module::Pointer32: IntPtrTy = Type::IntTy; break; - case Module::Pointer64: IntPtrTy = Type::LongTy; break; - default: GEN_ERROR("invalid pointer binary constant expr!"); - } - $$ = ConstantExpr::get($1.opcode, ConstantExpr::getCast($3, IntPtrTy), - ConstantExpr::getCast($5, IntPtrTy)); - $$ = ConstantExpr::getCast($$, $3->getType()); + | ConstPool OptAssign UNINIT GlobalType Types { + const Type *Ty = *$5; + // Global declarations appear in Constant Pool + if (Ty->isArrayType() && Ty->castArrayType()->isUnsized()) { + ThrowException("Type '" + Ty->getDescription() + + "' is not a sized type!"); } - CHECK_FOR_ERROR - } - | LogicalOps '(' ConstVal ',' ConstVal ')' { - if ($3->getType() != $5->getType()) - GEN_ERROR("Logical operator types must match!"); - if (!$3->getType()->isIntegral()) { - if (!isa<PackedType>($3->getType()) || - !cast<PackedType>($3->getType())->getElementType()->isIntegral()) - GEN_ERROR("Logical operator requires integral operands!"); - } - $$ = ConstantExpr::get($1.opcode, $3, $5); - CHECK_FOR_ERROR - } - | SetCondOps '(' ConstVal ',' ConstVal ')' { - if ($3->getType() != $5->getType()) - GEN_ERROR("setcc operand types must match!"); - $$ = ConstantExpr::get($1.opcode, $3, $5); - CHECK_FOR_ERROR - } - | ShiftOps '(' ConstVal ',' ConstVal ')' { - if ($5->getType() != Type::UByteTy) - GEN_ERROR("Shift count for shift constant must be unsigned byte!"); - if (!$3->getType()->isInteger()) - GEN_ERROR("Shift constant expression requires integer operand!"); - $$ = ConstantExpr::get($1.opcode, $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<Constant*>(); - $$->push_back($1); - CHECK_FOR_ERROR - }; + GlobalVariable *GV = new GlobalVariable(PointerType::get(Ty), $4); + setValueName(GV, $2); -// GlobalType - Match either GLOBAL or CONSTANT for global declarations... -GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; + CurModule.CurrentModule->getGlobalList().push_back(GV); + InsertValue(GV, CurModule.Values); + } + | /* empty: end of list */ { + } //===----------------------------------------------------------------------===// @@ -1776,1052 +917,422 @@ GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; }; // Module rule: Capture the result of parsing the whole file into a result // variable... // -Module : FunctionList { +Module : MethodList { $$ = ParserResult = $1; CurModule.ModuleDone(); - CHECK_FOR_ERROR; -}; +} -// FunctionList - A list of functions, preceeded by a constant pool. +// MethodList - A list of methods, preceeded by a constant pool. // -FunctionList : FunctionList Function { +MethodList : MethodList Method { $$ = $1; - CurFun.FunctionDone(); - CHECK_FOR_ERROR + if (!$2->getParent()) + $1->getMethodList().push_back($2); + CurMeth.MethodDone(); } - | FunctionList FunctionProto { - $$ = $1; - CHECK_FOR_ERROR - } - | FunctionList MODULE ASM_TOK AsmBlock { + | MethodList MethodProto { $$ = $1; - CHECK_FOR_ERROR - } - | FunctionList IMPLEMENTATION { - $$ = $1; - CHECK_FOR_ERROR } - | ConstPool { + | ConstPool IMPLEMENTATION { $$ = CurModule.CurrentModule; - // Emit an error if there are any unresolved types left. - if (!CurModule.LateResolveTypes.empty()) { - const ValID &DID = CurModule.LateResolveTypes.begin()->first; - if (DID.Type == ValID::NameVal) { - GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'"); - } else { - GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num)); - } - } - CHECK_FOR_ERROR - }; - -// ConstPool - Constants with optional names assigned to them. -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: - // - // %list = type { %list * } - // %list = type { %list * } ; repeated type decl - // - // If types are not resolved eagerly, then the two types will not be - // determined to be the same type! - // - 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. - 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 + // Resolve circular types before we parse the body of the module + ResolveTypes(CurModule.LateResolveTypes); } - | ConstPool OptAssign OptLinkage GlobalType ConstVal { - if ($5 == 0) - GEN_ERROR("Global value initializer is not a constant!"); - CurGV = ParseGlobalVariable($2, $3, $4, $5->getType(), $5); - CHECK_FOR_ERROR - } GlobalVarAttributes { - CurGV = 0; - } - | ConstPool OptAssign EXTERNAL GlobalType Types { - CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0); - 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) - CurModule.CurrentModule->setPointerSize(Module::Pointer32); - else if ($3 == 64) - CurModule.CurrentModule->setPointerSize(Module::Pointer64); - else - GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!"); - CHECK_FOR_ERROR - } - | TRIPLE '=' STRINGCONSTANT { - CurModule.CurrentModule->setTargetTriple($3); - free($3); - } - | DATALAYOUT '=' STRINGCONSTANT { - CurModule.CurrentModule->setDataLayout($3); - free($3); - }; -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 - } - ; //===----------------------------------------------------------------------===// -// Rules to match Function Headers +// Rules to match Method Headers //===----------------------------------------------------------------------===// -Name : VAR_ID | STRINGCONSTANT; -OptName : Name | /*empty*/ { $$ = 0; }; +OptVAR_ID : VAR_ID | /*empty*/ { $$ = 0; } -ArgVal : Types OptName { - if (*$1 == Type::VoidTy) - GEN_ERROR("void typed arguments are invalid!"); - $$ = new std::pair<PATypeHolder*, char*>($1, $2); - CHECK_FOR_ERROR -}; +ArgVal : Types OptVAR_ID { + $$ = new MethodArgument(*$1); delete $1; + setValueName($$, $2); +} -ArgListH : ArgListH ',' ArgVal { - $$ = $1; - $1->push_back(*$3); - delete $3; - CHECK_FOR_ERROR +ArgListH : ArgVal ',' ArgListH { + $$ = $3; + $3->push_front($1); } | ArgVal { - $$ = new std::vector<std::pair<PATypeHolder*,char*> >(); - $$->push_back(*$1); - delete $1; - CHECK_FOR_ERROR - }; + $$ = new list<MethodArgument*>(); + $$->push_front($1); + } + | DOTDOTDOT { + $$ = new list<MethodArgument*>(); + $$->push_back(new MethodArgument(Type::VoidTy)); + } ArgList : ArgListH { $$ = $1; - CHECK_FOR_ERROR - } - | ArgListH ',' DOTDOTDOT { - $$ = $1; - $$->push_back(std::pair<PATypeHolder*, - char*>(new PATypeHolder(Type::VoidTy), 0)); - CHECK_FOR_ERROR - } - | DOTDOTDOT { - $$ = new std::vector<std::pair<PATypeHolder*,char*> >(); - $$->push_back(std::make_pair(new PATypeHolder(Type::VoidTy), (char*)0)); - CHECK_FOR_ERROR } | /* empty */ { $$ = 0; - CHECK_FOR_ERROR - }; - -FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' - OptSection OptAlign { - UnEscapeLexed($3); - std::string FunctionName($3); - free($3); // Free strdup'd memory! - - if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy) - GEN_ERROR("LLVM functions cannot return aggregate types!"); - - std::vector<const Type*> ParamTypeList; - if ($5) { // If there are arguments... - for (std::vector<std::pair<PATypeHolder*,char*> >::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(*$2, ParamTypeList, isVarArg); - const PointerType *PFT = PointerType::get(FT); - delete $2; - - ValID ID; - if (!FunctionName.empty()) { - ID = ValID::create((char*)FunctionName.c_str()); - } else { - ID = ValID::create((int)CurModule.Values[PFT].size()); - } - - Function *Fn = 0; - // See if this function was forward referenced. If so, recycle the object. - if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { - // Move the function to the end of the list, from whereever it was - // previously inserted. - Fn = cast<Function>(FWRef); - CurModule.CurrentModule->getFunctionList().remove(Fn); - CurModule.CurrentModule->getFunctionList().push_back(Fn); - } else if (!FunctionName.empty() && // Merge with an earlier prototype? - (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) { - // If this is the case, either we need to be a forward decl, or it needs - // to be. - if (!CurFun.isDeclare && !Fn->isExternal()) - 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::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 ($5) { // Is null if empty... - if (isVarArg) { // Nuke the last entry - assert($5->back().first->get() == Type::VoidTy && $5->back().second == 0&& - "Not a varargs marker!"); - delete $5->back().first; - $5->pop_back(); // Delete the last entry - } - Function::arg_iterator ArgIt = Fn->arg_begin(); - for (std::vector<std::pair<PATypeHolder*,char*> >::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); + } + +MethodHeaderH : TypesV STRINGCONSTANT '(' ArgList ')' { + UnEscapeLexed($2); + vector<const Type*> ParamTypeList; + if ($4) + for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); ++I) + ParamTypeList.push_back((*I)->getType()); + + const MethodType *MT = MethodType::get(*$1, ParamTypeList); + delete $1; + + Method *M = 0; + if (SymbolTable *ST = CurModule.CurrentModule->getSymbolTable()) { + if (Value *V = ST->lookup(MT, $2)) { // Method already in symtab? + M = V->castMethodAsserting(); + + // Yes it is. If this is the case, either we need to be a forward decl, + // or it needs to be. + if (!CurMeth.isDeclare && !M->isExternal()) + ThrowException("Redefinition of method '" + string($2) + "'!"); } + } - delete $5; // We're now done with the argument list + if (M == 0) { // Not already defined? + M = new Method(MT, $2); + InsertValue(M, CurModule.Values); } - CHECK_FOR_ERROR -}; -BEGIN : BEGINTOK | '{'; // Allow BEGIN or '{' to start a function + free($2); // Free strdup'd memory! -FunctionHeader : OptLinkage FunctionHeaderH BEGIN { - $$ = CurFun.CurrentFunction; + CurMeth.MethodStart(M); - // Make sure that we keep track of the linkage type even if there was a - // previous "declare". - $$->setLinkage($1); -}; + // Add all of the arguments we parsed to the method... + if ($4 && !CurMeth.isDeclare) { // Is null if empty... + Method::ArgumentListType &ArgList = M->getArgumentList(); -END : ENDTOK | '}'; // Allow end of '}' to end a function + for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); ++I) { + InsertValue(*I); + ArgList.push_back(*I); + } + delete $4; // We're now done with the argument list + } +} + +MethodHeader : MethodHeaderH ConstPool BEGINTOK { + $$ = CurMeth.CurrentMethod; + + // Resolve circular types before we parse the body of the method. + ResolveTypes(CurMeth.LateResolveTypes); +} -Function : BasicBlockList END { +Method : BasicBlockList END { $$ = $1; - CHECK_FOR_ERROR -}; +} -FnDeclareLinkage: /*default*/ | - DLLIMPORT { CurFun.Linkage = GlobalValue::DLLImportLinkage; } | - EXTERN_WEAK { CurFun.Linkage = GlobalValue::DLLImportLinkage; }; - -FunctionProto : DECLARE { CurFun.isDeclare = true; } FnDeclareLinkage FunctionHeaderH { - $$ = CurFun.CurrentFunction; - CurFun.FunctionDone(); - CHECK_FOR_ERROR - }; +MethodProto : DECLARE { CurMeth.isDeclare = true; } MethodHeaderH { + $$ = CurMeth.CurrentMethod; + if (!$$->getParent()) + CurModule.CurrentModule->getMethodList().push_back($$); + CurMeth.MethodDone(); +} //===----------------------------------------------------------------------===// // 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::getTrue()); - CHECK_FOR_ERROR + | TRUE { + $$ = ValID::create((int64_t)1); } - | FALSETOK { - $$ = ValID::create(ConstantBool::getFalse()); - CHECK_FOR_ERROR - } - | NULL_TOK { - $$ = ValID::createNull(); - CHECK_FOR_ERROR - } - | UNDEF { - $$ = ValID::createUndef(); - CHECK_FOR_ERROR + | FALSE { + $$ = ValID::create((int64_t)0); } - | ZEROINITIALIZER { // A vector zero constant. - $$ = ValID::createZeroInit(); - CHECK_FOR_ERROR +/* + | STRINGCONSTANT { // Quoted strings work too... especially for methods + $$ = ValID::create_conststr($1); } - | '<' ConstVector '>' { // Nonempty unsized packed vector - const Type *ETy = (*$2)[0]->getType(); - int NumElements = $2->size(); - - PackedType* pt = PackedType::get(ETy, NumElements); - PATypeHolder* PTy = new PATypeHolder( - HandleUpRefs( - PackedType::get( - ETy, - NumElements) - ) - ); - - // Verify all elements are correct type! - for (unsigned i = 0; i < $2->size(); i++) { - if (ETy != (*$2)[i]->getType()) - 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 { +// ValueRef - A reference to a definition... +ValueRef : INTVAL { // Is it an integer reference...? $$ = 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 -// another value. -// -SymbolicValueRef : INTVAL { // Is it an integer reference...? - $$ = ValID::create($1); - CHECK_FOR_ERROR } - | Name { // Is it a named reference...? + | VAR_ID { // Is it a named reference...? $$ = ValID::create($1); - CHECK_FOR_ERROR - }; - -// ValueRef - A reference to a definition... either constant or symbolic -ValueRef : SymbolicValueRef | ConstValueRef; - + } + | ConstValueRef { + $$ = $1; + } // ResolvedVal - a <type> <value> pair. This is used only in cases where the // type immediately preceeds the value reference, and allows complex constant // pool references (for things like: 'ret [2 x int] [ int 12, int 42]') -ResolvedVal : Types ValueRef { +ResolvedVal : ExtendedConstVal { + $$ = $1; + } + | Types ValueRef { $$ = getVal(*$1, $2); delete $1; - CHECK_FOR_ERROR - }; + } + BasicBlockList : BasicBlockList BasicBlock { + $1->getBasicBlocks().push_back($2); $$ = $1; - CHECK_FOR_ERROR } - | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks - $$ = $1; - CHECK_FOR_ERROR - }; + | MethodHeader BasicBlock { // Do not allow methods with 0 basic blocks + $$ = $1; // in them... + $1->getBasicBlocks().push_back($2); + } // Basic blocks are terminated by branching instructions: // br, br/cc, switch, ret // -BasicBlock : InstructionList OptAssign BBTerminatorInst { - setValueName($3, $2); - CHECK_FOR_ERROR - InsertValue($3); - - $1->getInstList().push_back($3); +BasicBlock : InstructionList BBTerminatorInst { + $1->getInstList().push_back($2); InsertValue($1); $$ = $1; - CHECK_FOR_ERROR - }; + } + | LABELSTR InstructionList BBTerminatorInst { + $2->getInstList().push_back($3); + setValueName($2, $1); + + InsertValue($2); + $$ = $2; + } InstructionList : InstructionList Inst { $1->getInstList().push_back($2); $$ = $1; - CHECK_FOR_ERROR } | /* empty */ { - $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true); - CHECK_FOR_ERROR - - // Make sure to move the basic block to the correct location in the - // function, instead of leaving it inserted wherever it was first - // referenced. - Function::BasicBlockListType &BBL = - CurFun.CurrentFunction->getBasicBlockList(); - BBL.splice(BBL.end(), BBL, $$); - CHECK_FOR_ERROR - } - | LABELSTR { - $$ = CurBB = getBBVal(ValID::create($1), true); - CHECK_FOR_ERROR - - // Make sure to move the basic block to the correct location in the - // function, instead of leaving it inserted wherever it was first - // referenced. - Function::BasicBlockListType &BBL = - CurFun.CurrentFunction->getBasicBlockList(); - BBL.splice(BBL.end(), BBL, $$); - CHECK_FOR_ERROR - }; + $$ = new BasicBlock(); + } 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... - BasicBlock* tmpBB = getBBVal($3); - CHECK_FOR_ERROR - $$ = new BranchInst(tmpBB); + $$ = new BranchInst(getVal(Type::LabelTy, $3)->castBasicBlockAsserting()); } // Conditional Branch... | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { - 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); + $$ = new BranchInst(getVal(Type::LabelTy, $6)->castBasicBlockAsserting(), + getVal(Type::LabelTy, $9)->castBasicBlockAsserting(), + getVal(Type::BoolTy, $3)); } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' { - Value* tmpVal = getVal($2, $3); - CHECK_FOR_ERROR - BasicBlock* tmpBB = getBBVal($6); - CHECK_FOR_ERROR - SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size()); + SwitchInst *S = new SwitchInst(getVal($2, $3), + getVal(Type::LabelTy, $6)->castBasicBlockAsserting()); $$ = S; - std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(), - E = $8->end(); - for (; I != E; ++I) { - if (ConstantInt *CI = dyn_cast<ConstantInt>(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 '[' ']' { - 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 + list<pair<ConstPoolVal*, BasicBlock*> >::iterator I = $8->begin(), + end = $8->end(); + for (; I != end; ++I) + S->dest_push_back(I->first, I->second); } - | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')' - TO LABEL ValueRef UNWIND LABEL ValueRef { - const PointerType *PFTy; - const FunctionType *Ty; - - if (!(PFTy = dyn_cast<PointerType>($3->get())) || - !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { - // Pull out the types of all of the arguments... - std::vector<const Type*> ParamTypes; - if ($6) { - for (std::vector<Value*>::iterator I = $6->begin(), E = $6->end(); - I != E; ++I) - ParamTypes.push_back((*I)->getType()); - } - - bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; - if (isVarArg) ParamTypes.pop_back(); - - Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); - PFTy = PointerType::get(Ty); - } - - 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 (!$6) { // Has no arguments? - $$ = new InvokeInst(V, Normal, Except, std::vector<Value*>()); - } else { // Has arguments? - // Loop through FunctionType's arguments and ensure they are specified - // correctly! - // - FunctionType::param_iterator I = Ty->param_begin(); - FunctionType::param_iterator E = Ty->param_end(); - std::vector<Value*>::iterator ArgI = $6->begin(), ArgE = $6->end(); - - for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); - - if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - GEN_ERROR("Invalid number of parameters detected!"); - - $$ = new InvokeInst(V, Normal, Except, *$6); - } - cast<InvokeInst>($$)->setCallingConv($2); - - delete $3; - delete $6; - CHECK_FOR_ERROR - } - | UNWIND { - $$ = new UnwindInst(); - CHECK_FOR_ERROR - } - | UNREACHABLE { - $$ = new UnreachableInst(); - CHECK_FOR_ERROR - }; - - JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { $$ = $1; - Constant *V = cast<Constant>(getValNonImprovising($2, $3)); - CHECK_FOR_ERROR + ConstPoolVal *V = getVal($2, $3, true)->castConstantAsserting(); if (V == 0) - GEN_ERROR("May only switch on a constant pool value!"); + ThrowException("May only switch on a constant pool value!"); - BasicBlock* tmpBB = getBBVal($6); - CHECK_FOR_ERROR - $$->push_back(std::make_pair(V, tmpBB)); + $$->push_back(make_pair(V, getVal($5, $6)->castBasicBlockAsserting())); } | IntType ConstValueRef ',' LABEL ValueRef { - $$ = new std::vector<std::pair<Constant*, BasicBlock*> >(); - Constant *V = cast<Constant>(getValNonImprovising($1, $2)); - CHECK_FOR_ERROR + $$ = new list<pair<ConstPoolVal*, BasicBlock*> >(); + ConstPoolVal *V = getVal($1, $2, true)->castConstantAsserting(); if (V == 0) - GEN_ERROR("May only switch on a constant pool value!"); + ThrowException("May only switch on a constant pool value!"); - BasicBlock* tmpBB = getBBVal($5); - CHECK_FOR_ERROR - $$->push_back(std::make_pair(V, tmpBB)); - }; + $$->push_back(make_pair(V, getVal($4, $5)->castBasicBlockAsserting())); + } Inst : OptAssign InstVal { - // Is this definition named?? if so, assign the name... - setValueName($2, $1); - CHECK_FOR_ERROR + setValueName($2, $1); // Is this definition named?? if so, assign the name... + InsertValue($2); $$ = $2; - CHECK_FOR_ERROR -}; +} PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes - $$ = new std::list<std::pair<Value*, BasicBlock*> >(); - Value* tmpVal = getVal(*$1, $3); - CHECK_FOR_ERROR - BasicBlock* tmpBB = getBBVal($5); - CHECK_FOR_ERROR - $$->push_back(std::make_pair(tmpVal, tmpBB)); + $$ = new list<pair<Value*, BasicBlock*> >(); + $$->push_back(make_pair(getVal(*$1, $3), + getVal(Type::LabelTy, $5)->castBasicBlockAsserting())); delete $1; } | PHIList ',' '[' ValueRef ',' ValueRef ']' { $$ = $1; - 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)); - }; + $1->push_back(make_pair(getVal($1->front().first->getType(), $4), + getVal(Type::LabelTy, $6)->castBasicBlockAsserting())); + } ValueRefList : ResolvedVal { // Used for call statements, and memory insts... - $$ = new std::vector<Value*>(); + $$ = new list<Value*>(); $$->push_back($1); } | 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<PackedType>((*$2).get())) - GEN_ERROR( - "Arithmetic operator requires integer, FP, or packed operands!"); - if (isa<PackedType>((*$2).get()) && - ($1.opcode == Instruction::URem || - $1.opcode == Instruction::SRem || - $1.opcode == Instruction::FRem)) - GEN_ERROR("U/S/FRem not supported on packed types!"); - // Upgrade the opcode from obsolete versions before we do anything with it. - sanitizeOpCode($1,*$2); - CHECK_FOR_ERROR; - Value* val1 = getVal(*$2, $3); - CHECK_FOR_ERROR - Value* val2 = getVal(*$2, $5); - CHECK_FOR_ERROR - $$ = BinaryOperator::create($1.opcode, val1, val2); - if ($$ == 0) - GEN_ERROR("binary operator returned null!"); - delete $2; - } - | LogicalOps Types ValueRef ',' ValueRef { - if (!(*$2)->isIntegral()) { - if (!isa<PackedType>($2->get()) || - !cast<PackedType>($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.opcode, tmpVal1, tmpVal2); - if ($$ == 0) - GEN_ERROR("binary operator returned null!"); - delete $2; - } - | SetCondOps Types ValueRef ',' ValueRef { - if(isa<PackedType>((*$2).get())) { - GEN_ERROR( - "PackedTypes currently not supported in setcc instructions!"); - } - Value* tmpVal1 = getVal(*$2, $3); - CHECK_FOR_ERROR - Value* tmpVal2 = getVal(*$2, $5); - CHECK_FOR_ERROR - $$ = new SetCondInst($1.opcode, tmpVal1, tmpVal2); +ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; } + +InstVal : BinaryOps Types ValueRef ',' ValueRef { + $$ = BinaryOperator::create($1, getVal(*$2, $3), getVal(*$2, $5)); if ($$ == 0) - GEN_ERROR("binary operator returned null!"); + ThrowException("binary operator returned null!"); delete $2; } - | NOT ResolvedVal { - std::cerr << "WARNING: Use of eliminated 'not' instruction:" - << " Replacing with 'xor'.\n"; - - Value *Ones = ConstantIntegral::getAllOnesValue($2->getType()); - if (Ones == 0) - GEN_ERROR("Expected integral type for not instruction!"); - - $$ = BinaryOperator::create(Instruction::Xor, $2, Ones); + | UnaryOps ResolvedVal { + $$ = UnaryOperator::create($1, $2); if ($$ == 0) - GEN_ERROR("Could not create a xor instruction!"); - CHECK_FOR_ERROR + ThrowException("unary operator returned null!"); } | ShiftOps ResolvedVal ',' ResolvedVal { if ($4->getType() != Type::UByteTy) - GEN_ERROR("Shift amount must be ubyte!"); - if (!$2->getType()->isInteger()) - GEN_ERROR("Shift constant expression requires integer operand!"); - $$ = new ShiftInst($1.opcode, $2, $4); - CHECK_FOR_ERROR + ThrowException("Shift amount must be ubyte!"); + $$ = new ShiftInst($1, $2, $4); } | CAST ResolvedVal TO Types { - if (!$4->get()->isFirstClassType()) - GEN_ERROR("cast instruction to a non-primitive type: '" + - $4->get()->getDescription() + "'!"); $$ = new CastInst($2, *$4); delete $4; - CHECK_FOR_ERROR - } - | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal { - if ($2->getType() != Type::BoolTy) - GEN_ERROR("select condition must be boolean!"); - if ($4->getType() != $6->getType()) - GEN_ERROR("select value types should match!"); - $$ = new SelectInst($2, $4, $6); - CHECK_FOR_ERROR - } - | VAARG ResolvedVal ',' Types { - NewVarArgs = true; - $$ = new VAArgInst($2, *$4); - delete $4; - CHECK_FOR_ERROR - } - | VAARG_old ResolvedVal ',' Types { - ObsoleteVarArgs = true; - const Type* ArgTy = $2->getType(); - Function* NF = CurModule.CurrentModule-> - getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0); - - //b = vaarg a, t -> - //foo = alloca 1 of t - //bar = vacopy a - //store bar -> foo - //b = vaarg foo, t - AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix"); - CurBB->getInstList().push_back(foo); - CallInst* bar = new CallInst(NF, $2); - CurBB->getInstList().push_back(bar); - CurBB->getInstList().push_back(new StoreInst(bar, foo)); - $$ = new VAArgInst(foo, *$4); - delete $4; - CHECK_FOR_ERROR - } - | VANEXT_old ResolvedVal ',' Types { - ObsoleteVarArgs = true; - const Type* ArgTy = $2->getType(); - Function* NF = CurModule.CurrentModule-> - getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0); - - //b = vanext a, t -> - //foo = alloca 1 of t - //bar = vacopy a - //store bar -> foo - //tmp = vaarg foo, t - //b = load foo - AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix"); - CurBB->getInstList().push_back(foo); - CallInst* bar = new CallInst(NF, $2); - CurBB->getInstList().push_back(bar); - CurBB->getInstList().push_back(new StoreInst(bar, foo)); - Instruction* tmp = new VAArgInst(foo, *$4); - CurBB->getInstList().push_back(tmp); - $$ = new LoadInst(foo); - delete $4; - CHECK_FOR_ERROR - } - | EXTRACTELEMENT ResolvedVal ',' ResolvedVal { - if (!ExtractElementInst::isValidOperands($2, $4)) - GEN_ERROR("Invalid extractelement operands!"); - $$ = 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 { + } + | PHI PHIList { const Type *Ty = $2->front().first->getType(); - if (!Ty->isFirstClassType()) - GEN_ERROR("PHI node operands must be of first class type!"); $$ = new PHINode(Ty); - ((PHINode*)$$)->reserveOperandSpace($2->size()); while ($2->begin() != $2->end()) { if ($2->front().first->getType() != Ty) - GEN_ERROR("All elements of a PHI node must be of the same type!"); - cast<PHINode>($$)->addIncoming($2->front().first, $2->front().second); + ThrowException("All elements of a PHI node must be of the same type!"); + ((PHINode*)$$)->addIncoming($2->front().first, $2->front().second); $2->pop_front(); } delete $2; // Free the list... - CHECK_FOR_ERROR - } - | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { - const PointerType *PFTy; - const FunctionType *Ty; + } + | CALL TypesV ValueRef '(' ValueRefListE ')' { + const MethodType *Ty; - if (!(PFTy = dyn_cast<PointerType>($3->get())) || - !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { + if (!(Ty = (*$2)->dyncastMethodType())) { // Pull out the types of all of the arguments... - std::vector<const Type*> ParamTypes; - if ($6) { - for (std::vector<Value*>::iterator I = $6->begin(), E = $6->end(); - I != E; ++I) - ParamTypes.push_back((*I)->getType()); - } - - bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; - if (isVarArg) ParamTypes.pop_back(); - - if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy) - GEN_ERROR("LLVM functions cannot return aggregate types!"); - - Ty = FunctionType::get($3->get(), ParamTypes, isVarArg); - PFTy = PointerType::get(Ty); + vector<const Type*> ParamTypes; + for (list<Value*>::iterator I = $5->begin(), E = $5->end(); I != E; ++I) + ParamTypes.push_back((*I)->getType()); + Ty = MethodType::get(*$2, ParamTypes); } + delete $2; - Value *V = getVal(PFTy, $4); // Get the function we're calling... - CHECK_FOR_ERROR + Value *V = getVal(Ty, $3); // Get the method we're calling... // Create the call node... - if (!$6) { // Has no arguments? - // Make sure no arguments is a good thing! - if (Ty->getNumParams() != 0) - GEN_ERROR("No arguments passed to a function that " - "expects arguments!"); - - $$ = new CallInst(V, std::vector<Value*>()); + if (!$5) { // Has no arguments? + $$ = new CallInst(V->castMethodAsserting(), vector<Value*>()); } else { // Has arguments? - // Loop through FunctionType's arguments and ensure they are specified + // Loop through MethodType's arguments and ensure they are specified // correctly! // - FunctionType::param_iterator I = Ty->param_begin(); - FunctionType::param_iterator E = Ty->param_end(); - std::vector<Value*>::iterator ArgI = $6->begin(), ArgE = $6->end(); + MethodType::ParamTypes::const_iterator I = Ty->getParamTypes().begin(); + MethodType::ParamTypes::const_iterator E = Ty->getParamTypes().end(); + list<Value*>::iterator ArgI = $5->begin(), ArgE = $5->end(); for (; ArgI != ArgE && I != E; ++ArgI, ++I) - if ((*ArgI)->getType() != *I) - GEN_ERROR("Parameter " +(*ArgI)->getName()+ " is not of type '" + - (*I)->getDescription() + "'!"); + if ((*ArgI)->getType() != *I) + ThrowException("Parameter " +(*ArgI)->getName()+ " is not of type '" + + (*I)->getName() + "'!"); if (I != E || (ArgI != ArgE && !Ty->isVarArg())) - GEN_ERROR("Invalid number of parameters detected!"); + ThrowException("Invalid number of parameters detected!"); - $$ = new CallInst(V, *$6); + $$ = new CallInst(V->castMethodAsserting(), + vector<Value*>($5->begin(), $5->end())); } - cast<CallInst>($$)->setTailCall($1); - cast<CallInst>($$)->setCallingConv($2); - delete $3; - delete $6; - CHECK_FOR_ERROR + delete $5; } | MemoryInst { $$ = $1; - CHECK_FOR_ERROR - }; - - -// IndexList - List of indices for GEP based instructions... -IndexList : ',' ValueRefList { - $$ = $2; - CHECK_FOR_ERROR - } | /* empty */ { - $$ = new std::vector<Value*>(); - CHECK_FOR_ERROR - }; - -OptVolatile : VOLATILE { - $$ = true; - CHECK_FOR_ERROR } - | /* empty */ { - $$ = false; - CHECK_FOR_ERROR - }; - +// UByteList - List of ubyte values for load and store instructions +UByteList : ',' ConstVector { + $$ = $2; +} | /* empty */ { + $$ = new vector<ConstPoolVal*>(); +} -MemoryInst : MALLOC Types OptCAlign { - $$ = new MallocInst(*$2, 0, $3); +MemoryInst : MALLOC Types { + $$ = new MallocInst(PointerType::get(*$2)); delete $2; - CHECK_FOR_ERROR } - | MALLOC Types ',' UINT ValueRef OptCAlign { - Value* tmpVal = getVal($4, $5); - CHECK_FOR_ERROR - $$ = new MallocInst(*$2, tmpVal, $6); + | MALLOC Types ',' UINT ValueRef { + if (!(*$2)->isArrayType() || ((const ArrayType*)$2->get())->isSized()) + ThrowException("Trying to allocate " + (*$2)->getName() + + " as unsized array!"); + const Type *Ty = PointerType::get(*$2); + $$ = new MallocInst(Ty, getVal($4, $5)); delete $2; } - | ALLOCA Types OptCAlign { - $$ = new AllocaInst(*$2, 0, $3); + | ALLOCA Types { + $$ = new AllocaInst(PointerType::get(*$2)); delete $2; - CHECK_FOR_ERROR } - | ALLOCA Types ',' UINT ValueRef OptCAlign { - Value* tmpVal = getVal($4, $5); - CHECK_FOR_ERROR - $$ = new AllocaInst(*$2, tmpVal, $6); + | ALLOCA Types ',' UINT ValueRef { + if (!(*$2)->isArrayType() || ((const ArrayType*)$2->get())->isSized()) + ThrowException("Trying to allocate " + (*$2)->getName() + + " as unsized array!"); + const Type *Ty = PointerType::get(*$2); + Value *ArrSize = getVal($4, $5); + $$ = new AllocaInst(Ty, ArrSize); delete $2; } | FREE ResolvedVal { - if (!isa<PointerType>($2->getType())) - GEN_ERROR("Trying to free nonpointer type " + - $2->getType()->getDescription() + "!"); + if (!$2->getType()->isPointerType()) + ThrowException("Trying to free nonpointer type " + + $2->getType()->getName() + "!"); $$ = new FreeInst($2); - CHECK_FOR_ERROR - } - - | OptVolatile LOAD Types ValueRef { - if (!isa<PointerType>($3->get())) - GEN_ERROR("Can't load from nonpointer type: " + - (*$3)->getDescription()); - if (!cast<PointerType>($3->get())->getElementType()->isFirstClassType()) - GEN_ERROR("Can't load from pointer of non-first-class type: " + - (*$3)->getDescription()); - Value* tmpVal = getVal(*$3, $4); - CHECK_FOR_ERROR - $$ = new LoadInst(tmpVal, "", $1); - delete $3; - } - | OptVolatile STORE ResolvedVal ',' Types ValueRef { - const PointerType *PT = dyn_cast<PointerType>($5->get()); - if (!PT) - GEN_ERROR("Can't store to a nonpointer type: " + - (*$5)->getDescription()); - const Type *ElTy = PT->getElementType(); - if (ElTy != $3->getType()) - GEN_ERROR("Can't store '" + $3->getType()->getDescription() + - "' into space of type '" + ElTy->getDescription() + "'!"); - - Value* tmpVal = getVal(*$5, $6); - CHECK_FOR_ERROR - $$ = new StoreInst($3, tmpVal, $1); - delete $5; } - | GETELEMENTPTR Types ValueRef IndexList { - if (!isa<PointerType>($2->get())) - GEN_ERROR("getelementptr insn requires pointer operand!"); - - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte struct - // indices to uint struct indices for compatibility. - generic_gep_type_iterator<std::vector<Value*>::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<StructType>(*GTI)) // Only change struct indices - if (ConstantInt *CUI = dyn_cast<ConstantInt>((*$4)[i])) - if (CUI->getType() == Type::UByteTy) - (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy); - if (!GetElementPtrInst::getIndexedType(*$2, *$4, true)) - GEN_ERROR("Invalid getelementptr indices for type '" + - (*$2)->getDescription()+ "'!"); - Value* tmpVal = getVal(*$2, $3); - CHECK_FOR_ERROR - $$ = new GetElementPtrInst(tmpVal, *$4); - delete $2; - delete $4; - }; + | LOAD Types ValueRef UByteList { + if (!(*$2)->isPointerType()) + ThrowException("Can't load from nonpointer type: " + (*$2)->getName()); + if (LoadInst::getIndexedType(*$2, *$4) == 0) + ThrowException("Invalid indices for load instruction!"); + $$ = new LoadInst(getVal(*$2, $3), *$4); + delete $4; // Free the vector... + delete $2; + } + | STORE ResolvedVal ',' Types ValueRef UByteList { + if (!(*$4)->isPointerType()) + ThrowException("Can't store to a nonpointer type: " + (*$4)->getName()); + const Type *ElTy = StoreInst::getIndexedType(*$4, *$6); + if (ElTy == 0) + ThrowException("Can't store into that field list!"); + if (ElTy != $2->getType()) + ThrowException("Can't store '" + $2->getType()->getName() + + "' into space of type '" + ElTy->getName() + "'!"); + $$ = new StoreInst($2, getVal(*$4, $5), *$6); + delete $4; delete $6; + } + | GETELEMENTPTR Types ValueRef UByteList { + if (!(*$2)->isPointerType()) + ThrowException("getelementptr insn requires pointer operand!"); + if (!GetElementPtrInst::getIndexedType(*$2, *$4, true)) + ThrowException("Can't get element ptr '" + (*$2)->getName() + "'!"); + $$ = new GetElementPtrInst(getVal(*$2, $3), *$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("<stdin>") : CurFilename) - + ":" + utostr((unsigned) llvmAsmlineno) + ": "; - std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading "; - if (yychar == YYEMPTY || yychar == 0) - errMsg += "end-of-file."; - else - errMsg += "token: '" + std::string(llvmAsmtext, llvmAsmleng) + "'"; - GenerateError(errMsg); + ThrowException(string("Parse error: ") + ErrorMsg); return 0; } |