X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-upgrade%2FUpgradeParser.y.cvs;h=211934f368a0978a3d9c2bc770413af58da904fd;hb=4424757d3e38eaa646cd5c8dab19b8b24ee49416;hp=0544d400e6ce4ce24ca6c75f7b6967c5fdf45931;hpb=f8383def5c31acfab4fd55c9fb395d417fd65c45;p=oota-llvm.git diff --git a/tools/llvm-upgrade/UpgradeParser.y.cvs b/tools/llvm-upgrade/UpgradeParser.y.cvs index 0544d400e6c..211934f368a 100644 --- a/tools/llvm-upgrade/UpgradeParser.y.cvs +++ b/tools/llvm-upgrade/UpgradeParser.y.cvs @@ -1,958 +1,2062 @@ -//===-- UpgradeParser.y - Upgrade parser for llvm assmbly -------*- C++ -*-===// +//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===// // // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and is distributed under the -// University of Illinois Open Source License. See LICENSE.TXT for details. +// 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 1.9 assembly language. +// This file implements the bison parser for LLVM assembly languages files. // //===----------------------------------------------------------------------===// %{ #include "UpgradeInternals.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/ParameterAttributes.h" +#include "llvm/ValueSymbolTable.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" #include +#include #include +#include #include -#include + +// 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 +#else +#define UR_OUT(X) +#endif #define YYERROR_VERBOSE 1 #define YYINCLUDED_STDLIB_H #define YYDEBUG 1 -int yylex(); // declaration" of xxx warnings. +int yylex(); int yyparse(); -extern int yydebug; +int yyerror(const char*); +static void warning(const std::string& WarningMsg); + +namespace llvm { + +std::istream* LexInput; static std::string CurFilename; -static std::ostream *O = 0; -std::istream* LexInput = 0; -unsigned SizeOfPointer = 32; -static uint64_t unique = 1; // This bool controls whether attributes are ever added to function declarations // definitions and calls. static bool AddAttributes = false; -// This bool is used to communicate between the InstVal and Inst rules about -// whether or not a cast should be deleted. When the flag is set, InstVal has -// determined that the cast is a candidate. However, it can only be deleted if -// the value being casted is the same value name as the instruction. The Inst -// rule makes that comparison if the flag is set and comments out the -// instruction if they match. -static bool deleteUselessCastFlag = false; -static std::string* deleteUselessCastName = 0; - -typedef std::vector TypeVector; -static TypeVector EnumeratedTypes; -typedef std::map TypeMap; -static TypeMap NamedTypes; -typedef std::map TypePlaneMap; -typedef std::map GlobalsTypeMap; -static GlobalsTypeMap Globals; - -static void warning(const std::string& msg); - -void destroy(ValueList* VL) { - while (!VL->empty()) { - ValueInfo& VI = VL->back(); - VI.destroy(); - VL->pop_back(); - } - delete VL; +static Module *ParserResult; +static bool ObsoleteVarArgs; +static bool NewVarArgs; +static BasicBlock *CurBB; +static GlobalVariable *CurGV; +static unsigned lastCallingConv; + +// This contains info used when building the body of a function. It is +// destroyed when the function is completed. +// +typedef std::vector ValueList; // Numbered defs + +typedef std::pair RenameMapKey; +typedef std::map RenameMapType; + +static void +ResolveDefinitions(std::map &LateResolvers, + std::map *FutureLateResolvers = 0); + +static struct PerModuleInfo { + Module *CurrentModule; + std::map Values; // Module level numbered definitions + std::map LateResolveValues; + std::vector Types; + std::vector TypeSigns; + std::map NamedTypeSigns; + std::map NamedValueSigns; + std::map LateResolveTypes; + static Module::Endianness Endian; + static Module::PointerSize PointerSize; + RenameMapType RenameMap; + + /// PlaceHolderInfo - When temporary placeholder objects are created, remember + /// how they were referenced and on which line of the input they came from so + /// that we can resolve them later and print error messages as appropriate. + std::map > PlaceHolderInfo; + + // GlobalRefs - This maintains a mapping between 's and forward + // references to global values. Global values may be referenced before they + // are defined, and if so, the temporary object that they represent is held + // here. This is used for forward references of GlobalValues. + // + typedef std::map, GlobalValue*> + GlobalRefsType; + GlobalRefsType GlobalRefs; + + 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. + // + ResolveDefinitions(LateResolveValues); + + // 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"; + } + error(UndefinedReferences); + return; + } + + if (CurrentModule->getDataLayout().empty()) { + std::string dataLayout; + if (Endian != Module::AnyEndianness) + dataLayout.append(Endian == Module::BigEndian ? "E" : "e"); + if (PointerSize != Module::AnyPointerSize) { + if (!dataLayout.empty()) + dataLayout += "-"; + dataLayout.append(PointerSize == Module::Pointer64 ? + "p:64:64" : "p:32:32"); + } + CurrentModule->setDataLayout(dataLayout); + } + + Values.clear(); // Clear out function local definitions + Types.clear(); + TypeSigns.clear(); + NamedTypeSigns.clear(); + NamedValueSigns.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; + } + void setEndianness(Module::Endianness E) { Endian = E; } + void setPointerSize(Module::PointerSize sz) { PointerSize = sz; } +} CurModule; + +Module::Endianness PerModuleInfo::Endian = Module::AnyEndianness; +Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize; + +static struct PerFunctionInfo { + Function *CurrentFunction; // Pointer to current function being created + + std::map Values; // Keep track of #'d definitions + std::map LateResolveValues; + bool isDeclare; // Is this function a forward declararation? + GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration. + + /// BBForwardRefs - When we see forward references to basic blocks, keep + /// track of them here. + std::map > BBForwardRefs; + std::vector NumberedBlocks; + RenameMapType RenameMap; + unsigned NextBBNum; + + inline PerFunctionInfo() { + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + } + + inline void FunctionStart(Function *M) { + CurrentFunction = M; + NextBBNum = 0; + } + + void FunctionDone() { + NumberedBlocks.clear(); + + // Any forward referenced blocks left? + if (!BBForwardRefs.empty()) { + error("Undefined reference to label " + + BBForwardRefs.begin()->first->getName()); + return; + } + + // Resolve all forward references now. + ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); + + Values.clear(); // Clear out function local definitions + RenameMap.clear(); + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + } +} CurFun; // Info for the current function... + +static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } + +/// This function is just a utility to make a Key value for the rename map. +/// The Key is a combination of the name, type, Signedness of the original +/// value (global/function). This just constructs the key and ensures that +/// named Signedness values are resolved to the actual Signedness. +/// @brief Make a key for the RenameMaps +static RenameMapKey makeRenameMapKey(const std::string &Name, const Type* Ty, + const Signedness &Sign) { + TypeInfo TI; + TI.T = Ty; + if (Sign.isNamed()) + // Don't allow Named Signedness nodes because they won't match. The actual + // Signedness must be looked up in the NamedTypeSigns map. + TI.S.copy(CurModule.NamedTypeSigns[Sign.getName()]); + else + TI.S.copy(Sign); + return std::make_pair(Name, TI); } -void UpgradeAssembly(const std::string &infile, std::istream& in, - std::ostream &out, bool debug, bool addAttrs) -{ - Upgradelineno = 1; - CurFilename = infile; - LexInput = ∈ - yydebug = debug; - AddAttributes = addAttrs; - O = &out; - if (yyparse()) { - std::cerr << "Parse failed.\n"; - out << "llvm-upgrade parse failed.\n"; - exit(1); +//===----------------------------------------------------------------------===// +// Code to handle definitions of all the types +//===----------------------------------------------------------------------===// + +static int InsertValue(Value *V, + std::map &ValueTab = CurFun.Values) { + if (V->hasName()) return -1; // Is this a numbered definition? + + // Yes, insert the value into the value table... + ValueList &List = ValueTab[V->getType()]; + List.push_back(V); + return List.size()-1; +} + +static const Type *getType(const ValID &D, bool DoNotImprovise = false) { + switch (D.Type) { + case ValID::NumberVal: // Is it a numbered definition? + // Module constants occupy the lowest numbered slots... + if ((unsigned)D.Num < CurModule.Types.size()) { + return CurModule.Types[(unsigned)D.Num]; + } + break; + case ValID::NameVal: // Is it a named definition? + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { + return N; + } + break; + default: + error("Internal parser error: Invalid symbol type reference"); + 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... + // + if (DoNotImprovise) return 0; // Do we just want a null to be returned? + + if (inFunctionScope()) { + if (D.Type == ValID::NameVal) { + error("Reference to an undefined type: '" + D.getName() + "'"); + return 0; + } else { + error("Reference to an undefined type: #" + itostr(D.Num)); + return 0; + } } + + std::map::iterator I =CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) + return I->second; + + Type *Typ = OpaqueType::get(); + CurModule.LateResolveTypes.insert(std::make_pair(D, Typ)); + return Typ; } -TypeInfo::TypeRegMap TypeInfo::registry; +/// This is like the getType method except that instead of looking up the type +/// for a given ID, it looks up that type's sign. +/// @brief Get the signedness of a referenced type +static Signedness getTypeSign(const ValID &D) { + switch (D.Type) { + case ValID::NumberVal: // Is it a numbered definition? + // Module constants occupy the lowest numbered slots... + if ((unsigned)D.Num < CurModule.TypeSigns.size()) { + return CurModule.TypeSigns[(unsigned)D.Num]; + } + break; + case ValID::NameVal: { // Is it a named definition? + std::map::const_iterator I = + CurModule.NamedTypeSigns.find(D.Name); + if (I != CurModule.NamedTypeSigns.end()) + return I->second; + // Perhaps its a named forward .. just cache the name + Signedness S; + S.makeNamed(D.Name); + return S; + } + default: + break; + } + // If we don't find it, its signless + Signedness S; + S.makeSignless(); + return S; +} -const TypeInfo* TypeInfo::get(const std::string &newType, Types oldType) { - TypeInfo* Ty = new TypeInfo(); - Ty->newTy = newType; - Ty->oldTy = oldType; - return add_new_type(Ty); +/// This function is analagous to getElementType in LLVM. It provides the same +/// function except that it looks up the Signedness instead of the type. This is +/// used when processing GEP instructions that need to extract the type of an +/// indexed struct/array/ptr member. +/// @brief Look up an element's sign. +static Signedness getElementSign(const ValueInfo& VI, + const std::vector &Indices) { + const Type *Ptr = VI.V->getType(); + assert(isa(Ptr) && "Need pointer type"); + + unsigned CurIdx = 0; + Signedness S(VI.S); + while (const CompositeType *CT = dyn_cast(Ptr)) { + if (CurIdx == Indices.size()) + break; + + Value *Index = Indices[CurIdx++]; + assert(!isa(CT) || CurIdx == 1 && "Invalid type"); + Ptr = CT->getTypeAtIndex(Index); + if (const Type* Ty = Ptr->getForwardedType()) + Ptr = Ty; + assert(S.isComposite() && "Bad Signedness type"); + if (isa(CT)) { + S = S.get(cast(Index)->getZExtValue()); + } else { + S = S.get(0UL); + } + if (S.isNamed()) + S = CurModule.NamedTypeSigns[S.getName()]; + } + Signedness Result; + Result.makeComposite(S); + return Result; } -const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, - const TypeInfo* eTy, const TypeInfo* rTy) { - TypeInfo* Ty= new TypeInfo(); - Ty->newTy = newType; - Ty->oldTy = oldType; - Ty->elemTy = const_cast(eTy); - Ty->resultTy = const_cast(rTy); - return add_new_type(Ty); +/// This function just translates a ConstantInfo into a ValueInfo and calls +/// getElementSign(ValueInfo,...). Its just a convenience. +/// @brief ConstantInfo version of getElementSign. +static Signedness getElementSign(const ConstInfo& CI, + const std::vector &Indices) { + ValueInfo VI; + VI.V = CI.C; + VI.S.copy(CI.S); + std::vector Idx; + for (unsigned i = 0; i < Indices.size(); ++i) + Idx.push_back(Indices[i]); + Signedness result = getElementSign(VI, Idx); + VI.destroy(); + return result; } -const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, - const TypeInfo *eTy, uint64_t elems) { - TypeInfo* Ty = new TypeInfo(); - Ty->newTy = newType; - Ty->oldTy = oldType; - Ty->elemTy = const_cast(eTy); - Ty->nelems = elems; - return add_new_type(Ty); +/// This function determines if two function types differ only in their use of +/// the sret parameter attribute in the first argument. If they are identical +/// in all other respects, it returns true. Otherwise, it returns false. +static bool FuncTysDifferOnlyBySRet(const FunctionType *F1, + const FunctionType *F2) { + if (F1->getReturnType() != F2->getReturnType() || + F1->getNumParams() != F2->getNumParams()) + return false; + const ParamAttrsList *PAL1 = F1->getParamAttrs(); + const ParamAttrsList *PAL2 = F2->getParamAttrs(); + if (PAL1 && !PAL2 || PAL2 && !PAL1) + return false; + if (PAL1 && PAL2 && ((PAL1->size() != PAL2->size()) || + (PAL1->getParamAttrs(0) != PAL2->getParamAttrs(0)))) + return false; + unsigned SRetMask = ~unsigned(ParamAttr::StructRet); + for (unsigned i = 0; i < F1->getNumParams(); ++i) { + if (F1->getParamType(i) != F2->getParamType(i) || (PAL1 && PAL2 && + (unsigned(PAL1->getParamAttrs(i+1)) & SRetMask != + unsigned(PAL2->getParamAttrs(i+1)) & SRetMask))) + return false; + } + return true; } -const TypeInfo* TypeInfo::get(const std::string& newType, Types oldType, - TypeList* TL) { - TypeInfo* Ty = new TypeInfo(); - Ty->newTy = newType; - Ty->oldTy = oldType; - Ty->elements = TL; - return add_new_type(Ty); +/// This function determines if the type of V and Ty differ only by the SRet +/// parameter attribute. This is a more generalized case of +/// FuncTysDIfferOnlyBySRet since it doesn't require FunctionType arguments. +static bool TypesDifferOnlyBySRet(Value *V, const Type* Ty) { + if (V->getType() == Ty) + return true; + const PointerType *PF1 = dyn_cast(Ty); + const PointerType *PF2 = dyn_cast(V->getType()); + if (PF1 && PF2) { + const FunctionType* FT1 = dyn_cast(PF1->getElementType()); + const FunctionType* FT2 = dyn_cast(PF2->getElementType()); + if (FT1 && FT2) + return FuncTysDifferOnlyBySRet(FT1, FT2); + } + return false; } -const TypeInfo* TypeInfo::get(const std::string& newType, const TypeInfo* resTy, - TypeList* TL) { - TypeInfo* Ty = new TypeInfo(); - Ty->newTy = newType; - Ty->oldTy = FunctionTy; - Ty->resultTy = const_cast(resTy); - Ty->elements = TL; - return add_new_type(Ty); +// The upgrade of csretcc to sret param attribute may have caused a function +// to not be found because the param attribute changed the type of the called +// function. This helper function, used in getExistingValue, detects that +// situation and bitcasts the function to the correct type. +static Value* handleSRetFuncTypeMerge(Value *V, const Type* Ty) { + // Handle degenerate cases + if (!V) + return 0; + if (V->getType() == Ty) + return V; + + const PointerType *PF1 = dyn_cast(Ty); + const PointerType *PF2 = dyn_cast(V->getType()); + if (PF1 && PF2) { + const FunctionType *FT1 = dyn_cast(PF1->getElementType()); + const FunctionType *FT2 = dyn_cast(PF2->getElementType()); + if (FT1 && FT2 && FuncTysDifferOnlyBySRet(FT1, FT2)) { + const ParamAttrsList *PAL2 = FT2->getParamAttrs(); + if (PAL2 && PAL2->paramHasAttr(1, ParamAttr::StructRet)) + return V; + else if (Constant *C = dyn_cast(V)) + return ConstantExpr::getBitCast(C, PF1); + else + return new BitCastInst(V, PF1, "upgrd.cast", CurBB); + } + + } + return 0; } -const TypeInfo* TypeInfo::resolve() const { - if (isUnresolved()) { - if (getNewTy()[0] == '%' && isdigit(newTy[1])) { - unsigned ref = atoi(&((newTy.c_str())[1])); // skip the % - if (ref < EnumeratedTypes.size()) { - return EnumeratedTypes[ref]; - } else { - std::string msg("Can't resolve numbered type: "); - msg += getNewTy(); - yyerror(msg.c_str()); - } - } else { - TypeMap::iterator I = NamedTypes.find(newTy); - if (I != NamedTypes.end()) { - return I->second; +// getExistingValue - 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 *getExistingValue(const Type *Ty, const ValID &D) { + if (isa(Ty)) { + error("Functions are not values and must be referenced as pointers"); + } + + switch (D.Type) { + case ValID::NumberVal: { // Is it a numbered definition? + unsigned Num = (unsigned)D.Num; + + // Module constants occupy the lowest numbered slots... + std::map::iterator VI = CurModule.Values.find(Ty); + if (VI != CurModule.Values.end()) { + if (Num < VI->second.size()) + return VI->second[Num]; + Num -= VI->second.size(); + } + + // Make sure that our type is within bounds + VI = CurFun.Values.find(Ty); + if (VI == CurFun.Values.end()) return 0; + + // Check that the number is within bounds... + if (VI->second.size() <= Num) return 0; + + return VI->second[Num]; + } + + case ValID::NameVal: { // Is it a named definition? + // Get the name out of the ID + RenameMapKey Key = makeRenameMapKey(D.Name, Ty, D.S); + Value *V = 0; + if (inFunctionScope()) { + // See if the name was renamed + RenameMapType::const_iterator I = CurFun.RenameMap.find(Key); + std::string LookupName; + if (I != CurFun.RenameMap.end()) + LookupName = I->second; + else + LookupName = D.Name; + ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); + V = SymTab.lookup(LookupName); + if (V && V->getType() != Ty) + V = handleSRetFuncTypeMerge(V, Ty); + assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type"); + } + if (!V) { + RenameMapType::const_iterator I = CurModule.RenameMap.find(Key); + std::string LookupName; + if (I != CurModule.RenameMap.end()) + LookupName = I->second; + else + LookupName = D.Name; + V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName); + if (V && V->getType() != Ty) + V = handleSRetFuncTypeMerge(V, Ty); + assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type"); + } + if (!V) + return 0; + + D.destroy(); // Free old strdup'd memory... + return V; + } + + // 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)) { + error("Signed integral constant '" + itostr(D.ConstPool64) + + "' is invalid for type '" + Ty->getDescription() + "'"); + } + 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)) + error("Integral constant '" + utostr(D.UConstPool64) + + "' is invalid or out of range"); + 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)) + error("FP constant invalid for type"); + // Lexer has no type info, so builds all FP constants as double. + // Fix this here. + if (Ty==Type::FloatTy) + D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + return ConstantFP::get(Ty, *D.ConstPoolFP); + + case ValID::ConstNullVal: // Is it a null value? + if (!isa(Ty)) + error("Cannot create a a non pointer null"); + return ConstantPointerNull::get(cast(Ty)); + + case ValID::ConstUndefVal: // Is it an undef value? + return UndefValue::get(Ty); + + case ValID::ConstZeroVal: // Is it a zero value? + return Constant::getNullValue(Ty); + + case ValID::ConstantVal: // Fully resolved constant? + if (D.ConstantValue->getType() != Ty) + error("Constant expression type different from required type"); + return D.ConstantValue; + + case ValID::InlineAsmVal: { // Inline asm expression + const PointerType *PTy = dyn_cast(Ty); + const FunctionType *FTy = + PTy ? dyn_cast(PTy->getElementType()) : 0; + if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) + error("Invalid type for asm constraint string"); + InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints, + D.IAD->HasSideEffects); + D.destroy(); // Free InlineAsmDescriptor. + return IA; + } + default: + assert(0 && "Unhandled case"); + return 0; + } // End of switch + + assert(0 && "Unhandled case"); + return 0; +} + +// getVal - This function is identical to getExistingValue, 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) + error("Cannot use a basic block here"); + + // See if the value has already been defined. + Value *V = getExistingValue(Ty, ID); + if (V) return V; + + if (!Ty->isFirstClassType() && !isa(Ty)) + error("Invalid use of a composite type"); + + // If we reached here, we referenced either a symbol that we don't know about + // or an id number that hasn't been read yet. We may be referencing something + // forward, so just create an entry to be resolved later and get to it... + 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, Upgradelineno))); + + if (inFunctionScope()) + InsertValue(V, CurFun.LateResolveValues); + else + InsertValue(V, CurModule.LateResolveValues); + return V; +} + +/// @brief This just makes any name given to it unique, up to MAX_UINT times. +static std::string makeNameUnique(const std::string& Name) { + static unsigned UniqueNameCounter = 1; + std::string Result(Name); + Result += ".upgrd." + llvm::utostr(UniqueNameCounter++); + return Result; +} + +/// 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: + error("Illegal label reference " + ID.getName()); + break; + 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->getValueSymbolTable().lookup(Name)) { + if (N->getType() != Type::LabelTy) { + // Register names didn't use to conflict with basic block names + // because of type planes. Now they all have to be unique. So, we just + // rename the register and treat this name as if no basic block + // had been found. + RenameMapKey Key = makeRenameMapKey(ID.Name, N->getType(), ID.S); + N->setName(makeNameUnique(N->getName())); + CurModule.RenameMap[Key] = N->getName(); + BB = 0; } else { - std::string msg("Cannot resolve type: "); - msg += getNewTy(); - yyerror(msg.c_str()); + BB = cast(N); } } + break; + } + + // See if the block has already been defined. + if (BB) { + // If this is the definition of the block, make sure the existing value was + // just a forward reference. If it was a forward reference, there will be + // an entry for it in the PlaceHolderInfo map. + if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) + // The existing value was a definition, not a forward reference. + error("Redefinition of label " + ID.getName()); + + ID.destroy(); // Free strdup'd memory. + return BB; + } + + // Otherwise this block has not been seen before. + BB = new BasicBlock("", CurFun.CurrentFunction); + if (ID.Type == ValID::NameVal) { + BB->setName(ID.Name); + } else { + CurFun.NumberedBlocks[ID.Num] = BB; } - // otherwise its already resolved. - return this; + + // 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, Upgradelineno); + } 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; } -bool TypeInfo::operator<(const TypeInfo& that) const { - if (this == &that) - return false; - if (oldTy != that.oldTy) - return oldTy < that.oldTy; - switch (oldTy) { - case UpRefTy: { - unsigned thisUp = this->getUpRefNum(); - unsigned thatUp = that.getUpRefNum(); - return thisUp < thatUp; - } - case PackedTy: - case ArrayTy: - if (this->nelems != that.nelems) - return nelems < that.nelems; - case PointerTy: { - const TypeInfo* thisTy = this->elemTy; - const TypeInfo* thatTy = that.elemTy; - return *thisTy < *thatTy; - } - case FunctionTy: { - const TypeInfo* thisTy = this->resultTy; - const TypeInfo* thatTy = that.resultTy; - if (!thisTy->sameOldTyAs(thatTy)) - return *thisTy < *thatTy; - /* FALL THROUGH */ - } - case StructTy: - case PackedStructTy: { - if (elements->size() != that.elements->size()) - return elements->size() < that.elements->size(); - for (unsigned i = 0; i < elements->size(); i++) { - const TypeInfo* thisTy = (*this->elements)[i]; - const TypeInfo* thatTy = (*that.elements)[i]; - if (!thisTy->sameOldTyAs(thatTy)) - return *thisTy < *thatTy; + +//===----------------------------------------------------------------------===// +// Code to handle forward references in instructions +//===----------------------------------------------------------------------===// +// +// This code handles the late binding needed with statements that reference +// 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 +// 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 +// defs now... +// +static void +ResolveDefinitions(std::map &LateResolvers, + std::map *FutureLateResolvers) { + + // Loop over LateResolveDefs fixing up stuff that couldn't be resolved + for (std::map::iterator LRI = LateResolvers.begin(), + E = LateResolvers.end(); LRI != E; ++LRI) { + const Type* Ty = LRI->first; + ValueList &List = LRI->second; + while (!List.empty()) { + Value *V = List.back(); + List.pop_back(); + + std::map >::iterator PHI = + CurModule.PlaceHolderInfo.find(V); + assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error"); + + ValID &DID = PHI->second.first; + + Value *TheRealValue = getExistingValue(Ty, DID); + if (TheRealValue) { + V->replaceAllUsesWith(TheRealValue); + delete V; + CurModule.PlaceHolderInfo.erase(PHI); + } else if (FutureLateResolvers) { + // Functions have their unresolved items forwarded to the module late + // resolver table + InsertValue(V, *FutureLateResolvers); + } else { + if (DID.Type == ValID::NameVal) { + error("Reference to an invalid definition: '" + DID.getName() + + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } else { + error("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", PHI->second.second); + return; + } } - break; } - case UnresolvedTy: - return this->newTy < that.newTy; - default: - break; } - return false; + + LateResolvers.clear(); +} + +/// This function is used for type resolution and upref handling. When a type +/// becomes concrete, this function is called to adjust the signedness for the +/// concrete type. +static void ResolveTypeSign(const Type* oldTy, const Signedness &Sign) { + std::string TyName = CurModule.CurrentModule->getTypeName(oldTy); + if (!TyName.empty()) + CurModule.NamedTypeSigns[TyName] = Sign; +} + +/// 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, const Signedness& Sign){ + ValID D; + if (Name) + D = ValID::create(Name); + else + D = ValID::create((int)CurModule.Types.size()); + D.S.copy(Sign); + + if (Name) + CurModule.NamedTypeSigns[Name] = Sign; + + std::map::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + const Type *OldTy = I->second.get(); + ((DerivedType*)OldTy)->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); + } } -bool TypeInfo::sameOldTyAs(const TypeInfo* that) const { - if (that == 0) +/// This is the implementation portion of TypeHasInteger. It traverses the +/// type given, avoiding recursive types, and returns true as soon as it finds +/// an integer type. If no integer type is found, it returns false. +static bool TypeHasIntegerI(const Type *Ty, std::vector Stack) { + // Handle some easy cases + if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID)) return false; - if ( this == that ) + if (Ty->isInteger()) return true; - if (oldTy != that->oldTy) - return false; - switch (oldTy) { - case PackedTy: - case ArrayTy: - if (nelems != that->nelems) - return false; - /* FALL THROUGH */ - case PointerTy: { - const TypeInfo* thisTy = this->elemTy; - const TypeInfo* thatTy = that->elemTy; - return thisTy->sameOldTyAs(thatTy); - } - case FunctionTy: { - const TypeInfo* thisTy = this->resultTy; - const TypeInfo* thatTy = that->resultTy; - if (!thisTy->sameOldTyAs(thatTy)) - return false; - /* FALL THROUGH */ - } - case StructTy: - case PackedStructTy: { - if (elements->size() != that->elements->size()) - return false; - for (unsigned i = 0; i < elements->size(); i++) { - const TypeInfo* thisTy = (*this->elements)[i]; - const TypeInfo* thatTy = (*that->elements)[i]; - if (!thisTy->sameOldTyAs(thatTy)) - return false; - } + if (const SequentialType *STy = dyn_cast(Ty)) + return STy->getElementType()->isInteger(); + + // Avoid type structure recursion + for (std::vector::iterator I = Stack.begin(), E = Stack.end(); + I != E; ++I) + if (Ty == *I) + return false; + + // Push us on the type stack + Stack.push_back(Ty); + + if (const FunctionType *FTy = dyn_cast(Ty)) { + if (TypeHasIntegerI(FTy->getReturnType(), Stack)) return true; + FunctionType::param_iterator I = FTy->param_begin(); + FunctionType::param_iterator E = FTy->param_end(); + for (; I != E; ++I) + if (TypeHasIntegerI(*I, Stack)) + return true; + return false; + } else if (const StructType *STy = dyn_cast(Ty)) { + StructType::element_iterator I = STy->element_begin(); + StructType::element_iterator E = STy->element_end(); + for (; I != E; ++I) { + if (TypeHasIntegerI(*I, Stack)) + return true; } - case UnresolvedTy: - return this->newTy == that->newTy; - default: - return true; // for all others oldTy == that->oldTy is sufficient + return false; } - return true; + // There shouldn't be anything else, but its definitely not integer + assert(0 && "What type is this?"); + return false; } -bool TypeInfo::isUnresolvedDeep() const { - switch (oldTy) { - case UnresolvedTy: - return true; - case PackedTy: - case ArrayTy: - case PointerTy: - return elemTy->isUnresolvedDeep(); - case PackedStructTy: - case StructTy: - for (unsigned i = 0; i < elements->size(); i++) - if ((*elements)[i]->isUnresolvedDeep()) - return true; - return false; - default: - return false; +/// This is the interface to TypeHasIntegerI. It just provides the type stack, +/// to avoid recursion, and then calls TypeHasIntegerI. +static inline bool TypeHasInteger(const Type *Ty) { + std::vector TyStack; + return TypeHasIntegerI(Ty, TyStack); +} + +// setValueName - Set the specified value to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is free'd by this function. +// +static void setValueName(const ValueInfo &V, char *NameStr) { + if (NameStr) { + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string + + if (V.V->getType() == Type::VoidTy) { + error("Can't assign name '" + Name + "' to value with void type"); + return; + } + + assert(inFunctionScope() && "Must be in function scope"); + + // Search the function's symbol table for an existing value of this name + ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); + Value* Existing = ST.lookup(Name); + if (Existing) { + // An existing value of the same name was found. This might have happened + // because of the integer type planes collapsing in LLVM 2.0. + if (Existing->getType() == V.V->getType() && + !TypeHasInteger(Existing->getType())) { + // If the type does not contain any integers in them then this can't be + // a type plane collapsing issue. It truly is a redefinition and we + // should error out as the assembly is invalid. + error("Redefinition of value named '" + Name + "' of type '" + + V.V->getType()->getDescription() + "'"); + return; + } + // In LLVM 2.0 we don't allow names to be re-used for any values in a + // function, regardless of Type. Previously re-use of names was okay as + // long as they were distinct types. With type planes collapsing because + // of the signedness change and because of PR411, this can no longer be + // supported. We must search the entire symbol table for a conflicting + // name and make the name unique. No warning is needed as this can't + // cause a problem. + std::string NewName = makeNameUnique(Name); + // We're changing the name but it will probably be used by other + // instructions as operands later on. Consequently we have to retain + // a mapping of the renaming that we're doing. + RenameMapKey Key = makeRenameMapKey(Name, V.V->getType(), V.S); + CurFun.RenameMap[Key] = NewName; + Name = NewName; + } + + // Set the name. + V.V->setName(Name); } } -unsigned TypeInfo::getBitWidth() const { - switch (oldTy) { - default: - case LabelTy: - case VoidTy : return 0; - case BoolTy : return 1; - case SByteTy: case UByteTy : return 8; - case ShortTy: case UShortTy : return 16; - case IntTy: case UIntTy: case FloatTy: return 32; - case LongTy: case ULongTy: case DoubleTy : return 64; - case PointerTy: return SizeOfPointer; // global var - case PackedTy: - case ArrayTy: - return nelems * elemTy->getBitWidth(); - case StructTy: - case PackedStructTy: { - uint64_t size = 0; - for (unsigned i = 0; i < elements->size(); i++) { - size += (*elements)[i]->getBitWidth(); +/// 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, + const Signedness &Sign) { + if (isa(Ty)) + error("Cannot declare global vars of function type"); + + const PointerType *PTy = PointerType::get(Ty); + + std::string Name; + if (NameStr) { + Name = NameStr; // Copy string + free(NameStr); // Free old string + } + + // See if this global value was forward referenced. If so, recycle the + // object. + ValID ID; + if (!Name.empty()) { + ID = ValID::create((char*)Name.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PTy].size()); + } + ID.S.makeComposite(Sign); + + if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { + // Move the global to the end of the list, from whereever it was + // previously inserted. + GlobalVariable *GV = cast(FWGV); + CurModule.CurrentModule->getGlobalList().remove(GV); + CurModule.CurrentModule->getGlobalList().push_back(GV); + GV->setInitializer(Initializer); + GV->setLinkage(Linkage); + GV->setConstant(isConstantGlobal); + InsertValue(GV, CurModule.Values); + return GV; + } + + // If this global has a name, check to see if there is already a definition + // of this global in the module and emit warnings if there are conflicts. + if (!Name.empty()) { + // The global has a name. See if there's an existing one of the same name. + if (CurModule.CurrentModule->getNamedGlobal(Name) || + CurModule.CurrentModule->getFunction(Name)) { + // We found an existing global of the same name. This isn't allowed + // in LLVM 2.0. Consequently, we must alter the name of the global so it + // can at least compile. This can happen because of type planes + // There is alread a global of the same name which means there is a + // conflict. Let's see what we can do about it. + std::string NewName(makeNameUnique(Name)); + if (Linkage != GlobalValue::InternalLinkage) { + // The linkage of this gval is external so we can't reliably rename + // it because it could potentially create a linking problem. + // However, we can't leave the name conflict in the output either or + // it won't assemble with LLVM 2.0. So, all we can do is rename + // this one to something unique and emit a warning about the problem. + warning("Renaming global variable '" + Name + "' to '" + NewName + + "' may cause linkage errors"); } - return size; + + // Put the renaming in the global rename map + RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S); + CurModule.RenameMap[Key] = NewName; + + // Rename it + Name = NewName; } } + + // 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); + // Remember the sign of this global. + CurModule.NamedValueSigns[Name] = ID.S; + return GV; } -const TypeInfo* TypeInfo::getIndexedType(const ValueInfo& VI) const { - if (isStruct()) { - if (VI.isConstant() && VI.type->isInteger()) { - size_t pos = VI.val->find(' ') + 1; - if (pos < VI.val->size()) { - uint64_t idx = atoi(VI.val->substr(pos).c_str()); - return (*elements)[idx]; - } else { - yyerror("Invalid value for constant integer"); - return 0; - } - } else { - yyerror("Structure requires constant index"); - return 0; +// setTypeName - Set the specified type to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is freed by this function. +// +// This function returns true if the 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 PATypeInfo& TI, char *NameStr) { + assert(!inFunctionScope() && "Can't give types function-local names"); + if (NameStr == 0) return false; + + std::string Name(NameStr); // Copy string + free(NameStr); // Free old string + + const Type* Ty = TI.PAT->get(); + + // We don't allow assigning names to void type + if (Ty == Type::VoidTy) { + error("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, Ty); + + // Save the sign information for later use + CurModule.NamedTypeSigns[Name] = TI.S; + + if (AlreadyExists) { // Inserting a name that is already defined??? + const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); + assert(Existing && "Conflict but no matching type?"); + + // There is only one case where this is allowed: when we are refining an + // opaque type. In this case, Existing will be an opaque type. + if (const OpaqueType *OpTy = dyn_cast(Existing)) { + // We ARE replacing an opaque type! + const_cast(OpTy)->refineAbstractTypeTo(Ty); + return true; } + + // 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 == Ty) return true; // Yes, it's equal. + + // Any other kind of (non-equivalent) redefinition is an error. + error("Redefinition of type named '" + Name + "' in the '" + + Ty->getDescription() + "' type plane"); } - if (isArray() || isPacked() || isPointer()) - return elemTy; - yyerror("Invalid type for getIndexedType"); - return 0; + + return false; } -void TypeInfo::getSignedness(unsigned &sNum, unsigned &uNum, - UpRefStack& stack) const { - switch (oldTy) { - default: - case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: - case FloatTy : case DoubleTy: case UpRefTy: - return; - case SByteTy: case ShortTy: case LongTy: case IntTy: - sNum++; - return; - case UByteTy: case UShortTy: case UIntTy: case ULongTy: - uNum++; - return; - case PointerTy: - case PackedTy: - case ArrayTy: - stack.push_back(this); - elemTy->getSignedness(sNum, uNum, stack); - return; - case StructTy: - case PackedStructTy: { - stack.push_back(this); - for (unsigned i = 0; i < elements->size(); i++) { - (*elements)[i]->getSignedness(sNum, uNum, stack); +//===----------------------------------------------------------------------===// +// Code for handling upreferences in type names... +// + +// TypeContains - Returns true if Ty directly contains E in it. +// +static bool TypeContains(const Type *Ty, const Type *E) { + return std::find(Ty->subtype_begin(), Ty->subtype_end(), + E) != Ty->subtype_end(); +} + +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 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, const Signedness& Sign) { + // 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; + + unsigned i = 0; + for (; i != UpRefs.size(); ++i) { + UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].UpRefTy->getDescription() << ") = " + << (TypeContains(Ty, UpRefs[i].UpRefTy) ? "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].UpRefTy->getDescription() << "\n"; + std::string OldName = UpRefs[i].UpRefTy->getDescription()); + ResolveTypeSign(UpRefs[i].UpRefTy, Sign); + 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... } - return; - } - case UnresolvedTy: { - const TypeInfo* Ty = this->resolve(); - // Let's not recurse. - UpRefStack::const_iterator I = stack.begin(), E = stack.end(); - for ( ; I != E && *I != Ty; ++I) - ; - if (I == E) - Ty->getSignedness(sNum, uNum, stack); - return; } } -} -std::string AddSuffix(const std::string& Name, const std::string& Suffix) { - if (Name[Name.size()-1] == '"') { - std::string Result = Name; - Result.insert(Result.size()-1, Suffix); - return Result; + if (TypeToResolve) { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].UpRefTy->getDescription() << "\n"; + std::string OldName = TypeToResolve->getDescription()); + ResolveTypeSign(TypeToResolve, Sign); + TypeToResolve->refineAbstractTypeTo(Ty); } - return Name + Suffix; + + return Ty; } -std::string TypeInfo::makeUniqueName(const std::string& BaseName) const { - if (BaseName == "\"alloca point\"") - return BaseName; - switch (oldTy) { - default: - break; - case OpaqueTy: case LabelTy: case VoidTy: case BoolTy: case UpRefTy: - case FloatTy : case DoubleTy: case UnresolvedTy: - return BaseName; - case SByteTy: case ShortTy: case LongTy: case IntTy: - return AddSuffix(BaseName, ".s"); - case UByteTy: case UShortTy: case UIntTy: case ULongTy: - return AddSuffix(BaseName, ".u"); - } - - unsigned uNum = 0, sNum = 0; - std::string Suffix; - switch (oldTy) { - case PointerTy: - case PackedTy: - case ArrayTy: { - TypeInfo::UpRefStack stack; - elemTy->resolve()->getSignedness(sNum, uNum, stack); - break; +bool Signedness::operator<(const Signedness &that) const { + if (isNamed()) { + if (that.isNamed()) + return *(this->name) < *(that.name); + else + return CurModule.NamedTypeSigns[*name] < that; + } else if (that.isNamed()) { + return *this < CurModule.NamedTypeSigns[*that.name]; + } + + if (isComposite() && that.isComposite()) { + if (sv->size() == that.sv->size()) { + SignVector::const_iterator thisI = sv->begin(), thisE = sv->end(); + SignVector::const_iterator thatI = that.sv->begin(), + thatE = that.sv->end(); + for (; thisI != thisE; ++thisI, ++thatI) { + if (*thisI < *thatI) + return true; + else if (!(*thisI == *thatI)) + return false; + } + return false; } - case StructTy: - case PackedStructTy: { - for (unsigned i = 0; i < elements->size(); i++) { - TypeInfo::UpRefStack stack; - (*elements)[i]->resolve()->getSignedness(sNum, uNum, stack); + return sv->size() < that.sv->size(); + } + return kind < that.kind; +} + +bool Signedness::operator==(const Signedness &that) const { + if (isNamed()) + if (that.isNamed()) + return *(this->name) == *(that.name); + else + return CurModule.NamedTypeSigns[*(this->name)] == that; + else if (that.isNamed()) + return *this == CurModule.NamedTypeSigns[*(that.name)]; + if (isComposite() && that.isComposite()) { + if (sv->size() == that.sv->size()) { + SignVector::const_iterator thisI = sv->begin(), thisE = sv->end(); + SignVector::const_iterator thatI = that.sv->begin(), + thatE = that.sv->end(); + for (; thisI != thisE; ++thisI, ++thatI) { + if (!(*thisI == *thatI)) + return false; } - break; + return true; } - default: - assert(0 && "Invalid Type"); - break; + return false; } + return kind == that.kind; +} - if (sNum == 0 && uNum == 0) - return BaseName; - - switch (oldTy) { - default: Suffix += ".nada"; break; - case PointerTy: Suffix += ".pntr"; break; - case PackedTy: Suffix += ".pckd"; break; - case ArrayTy: Suffix += ".arry"; break; - case StructTy: Suffix += ".strc"; break; - case PackedStructTy: Suffix += ".pstr"; break; +void Signedness::copy(const Signedness &that) { + if (that.isNamed()) { + kind = Named; + name = new std::string(*that.name); + } else if (that.isComposite()) { + kind = Composite; + sv = new SignVector(); + *sv = *that.sv; + } else { + kind = that.kind; + sv = 0; } +} - Suffix += ".s" + llvm::utostr(sNum); - Suffix += ".u" + llvm::utostr(uNum); - return AddSuffix(BaseName, Suffix); +void Signedness::destroy() { + if (isNamed()) { + delete name; + } else if (isComposite()) { + delete sv; + } } -TypeInfo& TypeInfo::operator=(const TypeInfo& that) { - oldTy = that.oldTy; - nelems = that.nelems; - newTy = that.newTy; - elemTy = that.elemTy; - resultTy = that.resultTy; - if (that.elements) { - elements = new TypeList(that.elements->size()); - *elements = *that.elements; - } else { - elements = 0; +#ifndef NDEBUG +void Signedness::dump() const { + if (isComposite()) { + if (sv->size() == 1) { + (*sv)[0].dump(); + std::cerr << "*"; + } else { + std::cerr << "{ " ; + for (unsigned i = 0; i < sv->size(); ++i) { + if (i != 0) + std::cerr << ", "; + (*sv)[i].dump(); + } + std::cerr << "} " ; + } + } else if (isNamed()) { + std::cerr << *name; + } else if (isSigned()) { + std::cerr << "S"; + } else if (isUnsigned()) { + std::cerr << "U"; + } else + std::cerr << "."; +} +#endif + +static inline Instruction::TermOps +getTermOp(TermOps op) { + switch (op) { + default : assert(0 && "Invalid OldTermOp"); + case RetOp : return Instruction::Ret; + case BrOp : return Instruction::Br; + case SwitchOp : return Instruction::Switch; + case InvokeOp : return Instruction::Invoke; + case UnwindOp : return Instruction::Unwind; + case UnreachableOp: return Instruction::Unreachable; } - return *this; } -const TypeInfo* TypeInfo::add_new_type(TypeInfo* newTy) { - TypeRegMap::iterator I = registry.find(newTy); - if (I != registry.end()) { - delete newTy; - return *I; +static inline Instruction::BinaryOps +getBinaryOp(BinaryOps op, const Type *Ty, const Signedness& Sign) { + switch (op) { + default : assert(0 && "Invalid OldBinaryOps"); + case SetEQ : + case SetNE : + case SetLE : + case SetGE : + case SetLT : + case SetGT : assert(0 && "Should use getCompareOp"); + case AddOp : return Instruction::Add; + case SubOp : return Instruction::Sub; + case MulOp : return Instruction::Mul; + case DivOp : { + // This is an obsolete instruction so we must upgrade it based on the + // types of its operands. + bool isFP = Ty->isFloatingPoint(); + if (const VectorType* PTy = dyn_cast(Ty)) + // If its a vector type we want to use the element type + isFP = PTy->getElementType()->isFloatingPoint(); + if (isFP) + return Instruction::FDiv; + else if (Sign.isSigned()) + return Instruction::SDiv; + return Instruction::UDiv; + } + case UDivOp : return Instruction::UDiv; + case SDivOp : return Instruction::SDiv; + case FDivOp : return Instruction::FDiv; + case RemOp : { + // This is an obsolete instruction so we must upgrade it based on the + // types of its operands. + bool isFP = Ty->isFloatingPoint(); + if (const VectorType* PTy = dyn_cast(Ty)) + // If its a vector type we want to use the element type + isFP = PTy->getElementType()->isFloatingPoint(); + // Select correct opcode + if (isFP) + return Instruction::FRem; + else if (Sign.isSigned()) + return Instruction::SRem; + return Instruction::URem; + } + case URemOp : return Instruction::URem; + case SRemOp : return Instruction::SRem; + case FRemOp : return Instruction::FRem; + case LShrOp : return Instruction::LShr; + case AShrOp : return Instruction::AShr; + case ShlOp : return Instruction::Shl; + case ShrOp : + if (Sign.isSigned()) + return Instruction::AShr; + return Instruction::LShr; + case AndOp : return Instruction::And; + case OrOp : return Instruction::Or; + case XorOp : return Instruction::Xor; } - registry.insert(newTy); - return newTy; } -static const char* getCastOpcode( - std::string& Source, const TypeInfo* SrcTy, const TypeInfo* DstTy) -{ - unsigned SrcBits = SrcTy->getBitWidth(); - unsigned DstBits = DstTy->getBitWidth(); - const char* opcode = "bitcast"; - // Run through the possibilities ... - if (DstTy->isIntegral()) { // Casting to integral - if (SrcTy->isIntegral()) { // Casting from integral - if (DstBits < SrcBits) - opcode = "trunc"; - else if (DstBits > SrcBits) { // its an extension - if (SrcTy->isSigned()) - opcode ="sext"; // signed -> SEXT +static inline Instruction::OtherOps +getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty, + const Signedness &Sign) { + bool isSigned = Sign.isSigned(); + bool isFP = Ty->isFloatingPoint(); + switch (op) { + default : assert(0 && "Invalid OldSetCC"); + case SetEQ : + if (isFP) { + predicate = FCmpInst::FCMP_OEQ; + return Instruction::FCmp; + } else { + predicate = ICmpInst::ICMP_EQ; + return Instruction::ICmp; + } + case SetNE : + if (isFP) { + predicate = FCmpInst::FCMP_UNE; + return Instruction::FCmp; + } else { + predicate = ICmpInst::ICMP_NE; + return Instruction::ICmp; + } + case SetLE : + if (isFP) { + predicate = FCmpInst::FCMP_OLE; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SLE; else - opcode = "zext"; // unsigned -> ZEXT + predicate = ICmpInst::ICMP_ULE; + return Instruction::ICmp; + } + case SetGE : + if (isFP) { + predicate = FCmpInst::FCMP_OGE; + return Instruction::FCmp; } else { - opcode = "bitcast"; // Same size, No-op cast + if (isSigned) + predicate = ICmpInst::ICMP_SGE; + else + predicate = ICmpInst::ICMP_UGE; + return Instruction::ICmp; } - } else if (SrcTy->isFloatingPoint()) { // Casting from floating pt - if (DstTy->isSigned()) - opcode = "fptosi"; // FP -> sint - else - opcode = "fptoui"; // FP -> uint - } else if (SrcTy->isPacked()) { - assert(DstBits == SrcTy->getBitWidth() && - "Casting packed to integer of different width"); - opcode = "bitcast"; // same size, no-op cast - } else { - assert(SrcTy->isPointer() && - "Casting from a value that is not first-class type"); - opcode = "ptrtoint"; // ptr -> int - } - } else if (DstTy->isFloatingPoint()) { // Casting to floating pt - if (SrcTy->isIntegral()) { // Casting from integral - if (SrcTy->isSigned()) - opcode = "sitofp"; // sint -> FP - else - opcode = "uitofp"; // uint -> FP - } else if (SrcTy->isFloatingPoint()) { // Casting from floating pt - if (DstBits < SrcBits) { - opcode = "fptrunc"; // FP -> smaller FP - } else if (DstBits > SrcBits) { - opcode = "fpext"; // FP -> larger FP - } else { - opcode ="bitcast"; // same size, no-op cast + case SetLT : + if (isFP) { + predicate = FCmpInst::FCMP_OLT; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SLT; + else + predicate = ICmpInst::ICMP_ULT; + return Instruction::ICmp; + } + case SetGT : + if (isFP) { + predicate = FCmpInst::FCMP_OGT; + return Instruction::FCmp; + } else { + if (isSigned) + predicate = ICmpInst::ICMP_SGT; + else + predicate = ICmpInst::ICMP_UGT; + return Instruction::ICmp; } - } else if (SrcTy->isPacked()) { - assert(DstBits == SrcTy->getBitWidth() && - "Casting packed to floating point of different width"); - opcode = "bitcast"; // same size, no-op cast - } else { - assert(0 && "Casting pointer or non-first class to float"); - } - } else if (DstTy->isPacked()) { - if (SrcTy->isPacked()) { - assert(DstTy->getBitWidth() == SrcTy->getBitWidth() && - "Casting packed to packed of different widths"); - opcode = "bitcast"; // packed -> packed - } else if (DstTy->getBitWidth() == SrcBits) { - opcode = "bitcast"; // float/int -> packed - } else { - assert(!"Illegal cast to packed (wrong type or size)"); - } - } else if (DstTy->isPointer()) { - if (SrcTy->isPointer()) { - opcode = "bitcast"; // ptr -> ptr - } else if (SrcTy->isIntegral()) { - opcode = "inttoptr"; // int -> ptr - } else { - assert(!"Casting invalid type to pointer"); - } - } else { - assert(!"Casting to type that is not first-class"); } - return opcode; } -static std::string getCastUpgrade(const std::string& Src, const TypeInfo* SrcTy, - const TypeInfo* DstTy, bool isConst) -{ - std::string Result; - std::string Source = Src; - if (SrcTy->isFloatingPoint() && DstTy->isPointer()) { - // fp -> ptr cast is no longer supported but we must upgrade this - // by doing a double cast: fp -> int -> ptr - if (isConst) - Source = "i64 fptoui(" + Source + " to i64)"; - else { - *O << " %cast_upgrade" << unique << " = fptoui " << Source - << " to i64\n"; - Source = "i64 %cast_upgrade" + llvm::utostr(unique); - } - // Update the SrcTy for the getCastOpcode call below - SrcTy = TypeInfo::get("i64", ULongTy); - } else if (DstTy->isBool()) { - // cast type %x to bool was previously defined as setne type %x, null - // The cast semantic is now to truncate, not compare so we must retain - // the original intent by replacing the cast with a setne - const char* comparator = SrcTy->isPointer() ? ", null" : - (SrcTy->isFloatingPoint() ? ", 0.0" : - (SrcTy->isBool() ? ", false" : ", 0")); - const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne "; - if (isConst) { - Result = "(" + Source + comparator + ")"; - Result = compareOp + Result; - } else - Result = compareOp + Source + comparator; - return Result; // skip cast processing below - } - SrcTy = SrcTy->resolve(); - DstTy = DstTy->resolve(); - std::string Opcode(getCastOpcode(Source, SrcTy, DstTy)); - if (isConst) - Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")"; - else - Result += Opcode + " " + Source + " to " + DstTy->getNewTy(); - return Result; +static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) { + switch (op) { + default : assert(0 && "Invalid OldMemoryOps"); + case MallocOp : return Instruction::Malloc; + case FreeOp : return Instruction::Free; + case AllocaOp : return Instruction::Alloca; + case LoadOp : return Instruction::Load; + case StoreOp : return Instruction::Store; + case GetElementPtrOp : return Instruction::GetElementPtr; + } } -const char* getDivRemOpcode(const std::string& opcode, const TypeInfo* TI) { - const char* op = opcode.c_str(); - const TypeInfo* Ty = TI->resolve(); - if (Ty->isPacked()) - Ty = Ty->getElementType(); - if (opcode == "div") - if (Ty->isFloatingPoint()) - op = "fdiv"; - else if (Ty->isUnsigned()) - op = "udiv"; - else if (Ty->isSigned()) - op = "sdiv"; - else - yyerror("Invalid type for div instruction"); - else if (opcode == "rem") - if (Ty->isFloatingPoint()) - op = "frem"; - else if (Ty->isUnsigned()) - op = "urem"; - else if (Ty->isSigned()) - op = "srem"; - else - yyerror("Invalid type for rem instruction"); - return op; +static inline Instruction::OtherOps +getOtherOp(OtherOps op, const Signedness &Sign) { + switch (op) { + default : assert(0 && "Invalid OldOtherOps"); + case PHIOp : return Instruction::PHI; + case CallOp : return Instruction::Call; + case SelectOp : return Instruction::Select; + case UserOp1 : return Instruction::UserOp1; + case UserOp2 : return Instruction::UserOp2; + case VAArg : return Instruction::VAArg; + case ExtractElementOp : return Instruction::ExtractElement; + case InsertElementOp : return Instruction::InsertElement; + case ShuffleVectorOp : return Instruction::ShuffleVector; + case ICmpOp : return Instruction::ICmp; + case FCmpOp : return Instruction::FCmp; + }; } -std::string -getCompareOp(const std::string& setcc, const TypeInfo* TI) { - assert(setcc.length() == 5); - char cc1 = setcc[3]; - char cc2 = setcc[4]; - assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g'); - assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't'); - std::string result("xcmp xxx"); - result[6] = cc1; - result[7] = cc2; - if (TI->isFloatingPoint()) { - result[0] = 'f'; - result[5] = 'o'; - if (cc1 == 'n') - result[5] = 'u'; // NE maps to unordered - else - result[5] = 'o'; // everything else maps to ordered - } else if (TI->isIntegral() || TI->isPointer()) { - result[0] = 'i'; - if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e')) - result.erase(5,1); - else if (TI->isSigned()) - result[5] = 's'; - else if (TI->isUnsigned() || TI->isPointer() || TI->isBool()) - result[5] = 'u'; - else - yyerror("Invalid integral type for setcc"); - } - return result; +static inline Value* +getCast(CastOps op, Value *Src, const Signedness &SrcSign, const Type *DstTy, + const Signedness &DstSign, bool ForceInstruction = false) { + Instruction::CastOps Opcode; + const Type* SrcTy = Src->getType(); + if (op == CastOp) { + if (SrcTy->isFloatingPoint() && isa(DstTy)) { + // fp -> ptr cast is no longer supported but we must upgrade this + // by doing a double cast: fp -> int -> ptr + SrcTy = Type::Int64Ty; + Opcode = Instruction::IntToPtr; + if (isa(Src)) { + Src = ConstantExpr::getCast(Instruction::FPToUI, + cast(Src), SrcTy); + } else { + std::string NewName(makeNameUnique(Src->getName())); + Src = new FPToUIInst(Src, SrcTy, NewName, CurBB); + } + } else if (isa(DstTy) && + cast(DstTy)->getBitWidth() == 1) { + // cast type %x to bool was previously defined as setne type %x, null + // The cast semantic is now to truncate, not compare so we must retain + // the original intent by replacing the cast with a setne + Constant* Null = Constant::getNullValue(SrcTy); + Instruction::OtherOps Opcode = Instruction::ICmp; + unsigned short predicate = ICmpInst::ICMP_NE; + if (SrcTy->isFloatingPoint()) { + Opcode = Instruction::FCmp; + predicate = FCmpInst::FCMP_ONE; + } else if (!SrcTy->isInteger() && !isa(SrcTy)) { + error("Invalid cast to bool"); + } + if (isa(Src) && !ForceInstruction) + return ConstantExpr::getCompare(predicate, cast(Src), Null); + else + return CmpInst::create(Opcode, predicate, Src, Null); + } + // Determine the opcode to use by calling CastInst::getCastOpcode + Opcode = + CastInst::getCastOpcode(Src, SrcSign.isSigned(), DstTy, + DstSign.isSigned()); + + } else switch (op) { + default: assert(0 && "Invalid cast token"); + case TruncOp: Opcode = Instruction::Trunc; break; + case ZExtOp: Opcode = Instruction::ZExt; break; + case SExtOp: Opcode = Instruction::SExt; break; + case FPTruncOp: Opcode = Instruction::FPTrunc; break; + case FPExtOp: Opcode = Instruction::FPExt; break; + case FPToUIOp: Opcode = Instruction::FPToUI; break; + case FPToSIOp: Opcode = Instruction::FPToSI; break; + case UIToFPOp: Opcode = Instruction::UIToFP; break; + case SIToFPOp: Opcode = Instruction::SIToFP; break; + case PtrToIntOp: Opcode = Instruction::PtrToInt; break; + case IntToPtrOp: Opcode = Instruction::IntToPtr; break; + case BitCastOp: Opcode = Instruction::BitCast; break; + } + + if (isa(Src) && !ForceInstruction) + return ConstantExpr::getCast(Opcode, cast(Src), DstTy); + return CastInst::create(Opcode, Src, DstTy); } -static const TypeInfo* getFunctionReturnType(const TypeInfo* PFTy) { - PFTy = PFTy->resolve(); - if (PFTy->isPointer()) { - const TypeInfo* ElemTy = PFTy->getElementType(); - ElemTy = ElemTy->resolve(); - if (ElemTy->isFunction()) - return ElemTy->getResultType(); - } else if (PFTy->isFunction()) { - return PFTy->getResultType(); - } - return PFTy; -} +static Instruction * +upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, + std::vector& Args) { + + std::string Name = ID.Type == ValID::NameVal ? ID.Name : ""; + if (Name.length() <= 5 || Name[0] != 'l' || Name[1] != 'l' || + Name[2] != 'v' || Name[3] != 'm' || Name[4] != '.') + return 0; + + switch (Name[5]) { + case 'i': + if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") { + if (Args.size() != 2) + error("Invalid prototype for " + Name); + return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]); + } + break; -static const TypeInfo* ResolveUpReference(const TypeInfo* Ty, - TypeInfo::UpRefStack* stack) { - assert(Ty->isUpReference() && "Can't resolve a non-upreference"); - unsigned upref = Ty->getUpRefNum(); - assert(upref < stack->size() && "Invalid up reference"); - return (*stack)[upref - stack->size() - 1]; + case 'v' : { + const Type* PtrTy = PointerType::get(Type::Int8Ty); + std::vector Params; + if (Name == "llvm.va_start" || Name == "llvm.va_end") { + if (Args.size() != 1) + error("Invalid prototype for " + Name + " prototype"); + Params.push_back(PtrTy); + const FunctionType *FTy = + FunctionType::get(Type::VoidTy, Params, false); + const PointerType *PFTy = PointerType::get(FTy); + Value* Func = getVal(PFTy, ID); + Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB); + return new CallInst(Func, Args.begin(), Args.end()); + } else if (Name == "llvm.va_copy") { + if (Args.size() != 2) + error("Invalid prototype for " + Name + " prototype"); + Params.push_back(PtrTy); + Params.push_back(PtrTy); + const FunctionType *FTy = + FunctionType::get(Type::VoidTy, Params, false); + const PointerType *PFTy = PointerType::get(FTy); + Value* Func = getVal(PFTy, ID); + std::string InstName0(makeNameUnique("va0")); + std::string InstName1(makeNameUnique("va1")); + Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB); + Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB); + return new CallInst(Func, Args.begin(), Args.end()); + } + } + } + return 0; } -static const TypeInfo* getGEPIndexedType(const TypeInfo* PTy, ValueList* idxs) { - const TypeInfo* Result = PTy = PTy->resolve(); - assert(PTy->isPointer() && "GEP Operand is not a pointer?"); - TypeInfo::UpRefStack stack; - for (unsigned i = 0; i < idxs->size(); ++i) { - if (Result->isComposite()) { - Result = Result->getIndexedType((*idxs)[i]); - Result = Result->resolve(); - stack.push_back(Result); - } else - yyerror("Invalid type for index"); - } - // Resolve upreferences so we can return a more natural type - if (Result->isPointer()) { - if (Result->getElementType()->isUpReference()) { - stack.push_back(Result); - Result = ResolveUpReference(Result->getElementType(), &stack); +const Type* upgradeGEPCEIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Constant *Index = cast((*Indices)[i].V); + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); + } + + if (isa(Ty)) { + // Make sure that unsigned SequentialType indices are zext'd to + // 64-bits if they were smaller than that because LLVM 2.0 will sext + // all indices for SequentialType elements. We must retain the same + // semantic (zext) for unsigned types. + if (const IntegerType *Ity = dyn_cast(Index->getType())) { + if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { + Index = ConstantExpr::getCast(Instruction::ZExt, Index,Type::Int64Ty); + } + } } - } else if (Result->isUpReference()) { - Result = ResolveUpReference(Result->getElementType(), &stack); + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(), + Result.end(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); } - return Result->getPointerType(); + return Ty; } +const Type* upgradeGEPInstIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Value *Index = (*Indices)[i].V; + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); + } + -// This function handles appending .u or .s to integer value names that -// were previously unsigned or signed, respectively. This avoids name -// collisions since the unsigned and signed type planes have collapsed -// into a single signless type plane. -static std::string getUniqueName(const std::string *Name, const TypeInfo* Ty, - bool isGlobal = false, bool isDef = false) { + if (isa(Ty)) { // Only change struct indices + if (!isa(Index)) { + error("Invalid non-constant structure index"); + return 0; + } + } else { + // Make sure that unsigned SequentialType indices are zext'd to + // 64-bits if they were smaller than that because LLVM 2.0 will sext + // all indices for SequentialType elements. We must retain the same + // semantic (zext) for unsigned types. + if (const IntegerType *Ity = dyn_cast(Index->getType())) { + if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { + if (isa(Index)) + Index = ConstantExpr::getCast(Instruction::ZExt, + cast(Index), Type::Int64Ty); + else + Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty, + makeNameUnique("gep"), CurBB); + } + } + } + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(), + Result.end(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); + } + return Ty; +} - // If its not a symbolic name, don't modify it, probably a constant val. - if ((*Name)[0] != '%' && (*Name)[0] != '"') - return *Name; +unsigned upgradeCallingConv(unsigned CC) { + switch (CC) { + case OldCallingConv::C : return CallingConv::C; + case OldCallingConv::CSRet : return CallingConv::C; + case OldCallingConv::Fast : return CallingConv::Fast; + case OldCallingConv::Cold : return CallingConv::Cold; + case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall; + case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall; + default: + return CC; + } +} - // If its a numeric reference, just leave it alone. - if (isdigit((*Name)[1])) - return *Name; +Module* UpgradeAssembly(const std::string &infile, std::istream& in, + bool debug, bool addAttrs) +{ + Upgradelineno = 1; + CurFilename = infile; + LexInput = ∈ + yydebug = debug; + AddAttributes = addAttrs; + ObsoleteVarArgs = false; + NewVarArgs = false; - // Resolve the type - Ty = Ty->resolve(); + CurModule.CurrentModule = new Module(CurFilename); - // If its a global name, get its uniquified name, if any - GlobalsTypeMap::iterator GI = Globals.find(*Name); - if (GI != Globals.end()) { - TypePlaneMap::iterator TPI = GI->second.begin(); - TypePlaneMap::iterator TPE = GI->second.end(); - for ( ; TPI != TPE ; ++TPI) { - if (TPI->first->sameNewTyAs(Ty)) - return TPI->second; - } + // Check to make sure the parser succeeded + if (yyparse()) { + if (ParserResult) + delete ParserResult; + std::cerr << "llvm-upgrade: parse failed.\n"; + return 0; } - if (isGlobal) { - // We didn't find a global name, but if its supposed to be global then all - // we can do is return the name. This is probably a forward reference of a - // global value that hasn't been defined yet. Since we have no definition - // we don't know its linkage class. Just assume its an external and the name - // shouldn't change. - return *Name; + // Check to make sure that parsing produced a result + if (!ParserResult) { + std::cerr << "llvm-upgrade: no parse result.\n"; + return 0; } - // Default the result to the current name - std::string Result = Ty->makeUniqueName(*Name); + // Reset ParserResult variable while saving its value for the result. + Module *Result = ParserResult; + ParserResult = 0; - return Result; -} + //Not all functions use vaarg, so make a second check for ObsoleteVarArgs + { + Function* F; + if ((F = Result->getFunction("llvm.va_start")) + && F->getFunctionType()->getNumParams() == 0) + ObsoleteVarArgs = true; + if((F = Result->getFunction("llvm.va_copy")) + && F->getFunctionType()->getNumParams() == 1) + ObsoleteVarArgs = true; + } -static unsigned UniqueNameCounter = 0; - -std::string getGlobalName(const std::string* Name, const std::string Linkage, - const TypeInfo* Ty, bool isConstant) { - // Default to given name - std::string Result = *Name; - // Look up the name in the Globals Map - GlobalsTypeMap::iterator GI = Globals.find(*Name); - // Did we see this global name before? - if (GI != Globals.end()) { - if (Ty->isUnresolvedDeep()) { - // The Gval's type is unresolved. Consequently, we can't disambiguate it - // by type. We'll just change its name and emit a warning. - warning("Cannot disambiguate global value '" + *Name + - "' because type '" + Ty->getNewTy() + "'is unresolved.\n"); - Result = *Name + ".unique"; - UniqueNameCounter++; - Result += llvm::utostr(UniqueNameCounter); - return Result; - } else { - TypePlaneMap::iterator TPI = GI->second.find(Ty); - if (TPI != GI->second.end()) { - // We found an existing name of the same old type. This isn't allowed - // in LLVM 2.0. Consequently, we must alter the name of the global so it - // can at least compile. References to the global will yield the first - // definition, which is okay. We also must warn about this. - Result = *Name + ".unique"; - UniqueNameCounter++; - Result += llvm::utostr(UniqueNameCounter); - warning(std::string("Global variable '") + *Name + "' was renamed to '"+ - Result + "'"); - } else { - // There isn't an existing definition for this name according to the - // old types. Now search the TypePlanMap for types with the same new - // name. - TypePlaneMap::iterator TPI = GI->second.begin(); - TypePlaneMap::iterator TPE = GI->second.end(); - for ( ; TPI != TPE; ++TPI) { - if (TPI->first->sameNewTyAs(Ty)) { - // The new types are the same but the old types are different so - // this is a global name collision resulting from type planes - // collapsing. - if (Linkage == "external" || Linkage == "dllimport" || - Linkage == "extern_weak" || Linkage == "") { - // The linkage of this gval is external so we can't reliably - // rename it because it could potentially create a linking - // problem. However, we can't leave the name conflict in the - // output either or it won't assemble with LLVM 2.0. So, all we - // can do is rename this one to something unique and emit a - // warning about the problem. - Result = *Name + ".unique"; - UniqueNameCounter++; - Result += llvm::utostr(UniqueNameCounter); - warning("Renaming global value '" + *Name + "' to '" + Result + - "' may cause linkage errors."); - return Result; - } else { - // Its linkage is internal and its type is known so we can - // disambiguate the name collision successfully based on the type. - Result = getUniqueName(Name, Ty); - TPI->second = Result; - return Result; - } - } - } - // We didn't find an entry in the type plane with the same new type and - // the old types differ so this is a new type plane for this global - // variable. We just fall through to the logic below which inserts - // the global. + if (ObsoleteVarArgs && NewVarArgs) { + error("This file is corrupt: it uses both new and old style varargs"); + return 0; + } + + if(ObsoleteVarArgs) { + if(Function* F = Result->getFunction("llvm.va_start")) { + if (F->arg_size() != 0) { + error("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 = cast(Result->getOrInsertFunction( + "llvm.va_start", RetTy, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI); + new CallInst(NF, bar, "", CI); + Value* foo = new LoadInst(bar, "vastart.fix.2", CI); + CI->replaceAllUsesWith(foo); + CI->getParent()->getInstList().erase(CI); } + Result->getFunctionList().erase(F); } - } + + if(Function* F = Result->getFunction("llvm.va_end")) { + if(F->arg_size() != 1) { + error("Obsolete va_end takes 1 argument"); + return 0; + } - // Its a new global name, if it is external we can't change it - if (isConstant || Linkage == "external" || Linkage == "dllimport" || - Linkage == "extern_weak" || Linkage == "") { - Globals[Result][Ty] = Result; - return Result; + //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 = cast(Result->getOrInsertFunction( + "llvm.va_end", RetTy, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI); + new StoreInst(CI->getOperand(1), bar, CI); + new CallInst(NF, bar, "", CI); + CI->getParent()->getInstList().erase(CI); + } + Result->getFunctionList().erase(F); + } + + if(Function* F = Result->getFunction("llvm.va_copy")) { + if(F->arg_size() != 1) { + error("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 = cast(Result->getOrInsertFunction( + "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0)); + + while (!F->use_empty()) { + CallInst* CI = cast(F->use_back()); + Value *Args[2] = { + new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI), + new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI) + }; + new StoreInst(CI->getOperand(1), Args[1], CI); + new CallInst(NF, Args, Args + 2, "", CI); + Value* foo = new LoadInst(Args[0], "vacopy.fix.3", CI); + CI->replaceAllUsesWith(foo); + CI->getParent()->getInstList().erase(CI); + } + Result->getFunctionList().erase(F); + } } - // Its a new global name, and it is internal, change the name to make it - // unique for its type. - // Result = getUniqueName(Name, Ty); - Globals[*Name][Ty] = Result; return Result; } -%} -// %file-prefix="UpgradeParser" +} // end llvm namespace + +using namespace llvm; + +%} %union { - std::string* String; - const TypeInfo* Type; - ValueInfo Value; - ConstInfo Const; - ValueList* ValList; - TypeList* TypeVec; + llvm::Module *ModuleVal; + llvm::Function *FunctionVal; + std::pair *ArgVal; + llvm::BasicBlock *BasicBlockVal; + llvm::TermInstInfo TermInstVal; + llvm::InstrInfo InstVal; + llvm::ConstInfo ConstVal; + llvm::ValueInfo ValueVal; + llvm::PATypeInfo TypeVal; + llvm::TypeInfo PrimType; + llvm::PHIListInfo PHIList; + std::list *TypeList; + std::vector *ValueList; + std::vector *ConstVector; + + + std::vector > *ArgList; + // Represent the RHS of PHI node + std::vector > *JumpTable; + + llvm::GlobalValue::LinkageTypes Linkage; + int64_t SInt64Val; + uint64_t UInt64Val; + int SIntVal; + unsigned UIntVal; + llvm::APFloat *FPVal; + bool BoolVal; + + char *StrVal; // This memory is strdup'd! + llvm::ValID ValIDVal; // strdup'd memory maybe! + + llvm::BinaryOps BinaryOpVal; + llvm::TermOps TermOpVal; + llvm::MemoryOps MemOpVal; + llvm::OtherOps OtherOpVal; + llvm::CastOps CastOpVal; + llvm::ICmpInst::Predicate IPred; + llvm::FCmpInst::Predicate FPred; + llvm::Module::Endianness Endianness; } -%token VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG -%token FLOAT DOUBLE LABEL -%token OPAQUE ESINT64VAL EUINT64VAL SINTVAL UINTVAL FPVAL -%token NULL_TOK UNDEF ZEROINITIALIZER TRUETOK FALSETOK -%token TYPE VAR_ID LABELSTR STRINGCONSTANT -%token IMPLEMENTATION BEGINTOK ENDTOK -%token DECLARE GLOBAL CONSTANT SECTION VOLATILE -%token TO DOTDOTDOT CONST INTERNAL LINKONCE WEAK -%token DLLIMPORT DLLEXPORT EXTERN_WEAK APPENDING -%token NOT EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG -%token ALIGN UNINITIALIZED -%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 -%token RET BR SWITCH INVOKE EXCEPT UNWIND UNREACHABLE -%token ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM AND OR XOR -%token SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comparators -%token ICMP FCMP EQ NE SLT SGT SLE SGE OEQ ONE OLT OGT OLE OGE -%token ORD UNO UEQ UNE ULT UGT ULE UGE -%token MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR -%token PHI_TOK SELECT SHL SHR ASHR LSHR VAARG -%token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR -%token CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI UITOFP SITOFP -%token PTRTOINT INTTOPTR BITCAST - -%type OptAssign OptLinkage OptCallingConv OptAlign OptCAlign -%type SectionString OptSection GlobalVarAttributes GlobalVarAttribute -%type ConstExpr DefinitionList -%type ConstPool TargetDefinition LibrariesDefinition LibList OptName -%type ArgVal ArgListH ArgList FunctionHeaderH BEGIN FunctionHeader END -%type Function FunctionProto BasicBlock -%type InstructionList BBTerminatorInst JumpTable Inst -%type OptTailCall OptVolatile Unwind -%type SymbolicValueRef OptSideEffect GlobalType -%type FnDeclareLinkage BasicBlockList BigOrLittle AsmBlock -%type Name ConstValueRef ConstVector External -%type ShiftOps SetCondOps LogicalOps ArithmeticOps CastOps -%type IPredicates FPredicates - -%type ValueRefList ValueRefListE IndexList -%type TypeListI ArgTypeListI - -%type IntType SIntType UIntType FPType TypesV Types -%type PrimType UpRTypesV UpRTypes - -%type IntVal EInt64Val -%type ConstVal - -%type ValueRef ResolvedVal InstVal PHIList MemoryInst +%type Module FunctionList +%type Function FunctionProto FunctionHeader BasicBlockList +%type BasicBlock InstructionList +%type BBTerminatorInst +%type Inst InstVal MemoryInst +%type ConstVal ConstExpr +%type ConstVector +%type ArgList ArgListH +%type ArgVal +%type PHIList +%type ValueRefList ValueRefListE // For call param lists +%type IndexList // For GEP derived indices +%type TypeListI ArgTypeListI +%type JumpTable +%type GlobalType // GLOBAL or CONSTANT? +%type OptVolatile // 'volatile' or not +%type OptTailCall // TAIL CALL or plain CALL. +%type OptSideEffect // 'sideeffect' or not. +%type OptLinkage FnDeclareLinkage +%type BigOrLittle + +// ValueRef - Unresolved reference to a definition or BB +%type ValueRef ConstValueRef SymbolicValueRef +%type ResolvedVal // pair + +// Tokens and types for handling constant integer values +// +// ESINT64VAL - A negative number within long long range +%token ESINT64VAL + +// EUINT64VAL - A positive number within uns. long long range +%token EUINT64VAL +%type EINT64VAL + +%token SINTVAL // Signed 32 bit ints... +%token UINTVAL // Unsigned 32 bit ints... +%type INTVAL +%token FPVAL // Float or Double constant + +// Built in types... +%type Types TypesV UpRTypes UpRTypesV +%type SIntType UIntType IntType FPType PrimType // Classifications +%token VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG +%token FLOAT DOUBLE TYPE LABEL + +%token VAR_ID LABELSTR STRINGCONSTANT +%type Name OptName OptAssign +%type OptAlign OptCAlign +%type 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 OptCallingConv + +// Basic Block Terminating Operators +%token RET BR SWITCH INVOKE UNREACHABLE +%token UNWIND EXCEPT + +// Binary Operators +%type ArithmeticOps LogicalOps SetCondOps // Binops Subcatagories +%type ShiftOps +%token ADD SUB MUL DIV UDIV SDIV FDIV REM UREM SREM FREM +%token AND OR XOR SHL SHR ASHR LSHR +%token SETLE SETGE SETLT SETGT SETEQ SETNE // Binary Comparators +%token ICMP FCMP + +// Memory Instructions +%token MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR + +// Other Operators +%token PHI_TOK SELECT VAARG +%token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR +%token VAARG_old VANEXT_old //OBSOLETE + +// Support for ICmp/FCmp Predicates, which is 1.9++ but not 2.0 +%type IPredicates +%type FPredicates +%token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE +%token OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE + +%token CAST TRUNC ZEXT SEXT FPTRUNC FPEXT FPTOUI FPTOSI +%token UITOFP SITOFP PTRTOINT INTTOPTR BITCAST +%type CastOps %start Module %% // Handle constant integer size restriction and conversion... -IntVal : SINTVAL | UINTVAL ; -EInt64Val : ESINT64VAL | EUINT64VAL; +// +INTVAL + : SINTVAL + | UINTVAL { + if ($1 > (uint32_t)INT32_MAX) // Outside of my range! + error("Value too large for type"); + $$ = (int32_t)$1; + } + ; + +EINT64VAL + : ESINT64VAL // These have same type and can't cause problems... + | EUINT64VAL { + if ($1 > (uint64_t)INT64_MAX) // Outside of my range! + error("Value too large for type"); + $$ = (int64_t)$1; + }; // Operations that are notably excluded from this list include: // RET, BR, & SWITCH because they end basic blocks and are treated specially. -ArithmeticOps: ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV - | REM | UREM | SREM | FREM; -LogicalOps : AND | OR | XOR; -SetCondOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE; -IPredicates : EQ | NE | SLT | SGT | SLE | SGE | ULT | UGT | ULE | UGE; -FPredicates : OEQ | ONE | OLT | OGT | OLE | OGE | ORD | UNO | UEQ | UNE - | ULT | UGT | ULE | UGE | TRUETOK | FALSETOK; -ShiftOps : SHL | SHR | ASHR | LSHR; -CastOps : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI | - UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST - ; +// +ArithmeticOps + : ADD | SUB | MUL | DIV | UDIV | SDIV | FDIV | REM | UREM | SREM | FREM + ; + +LogicalOps + : AND | OR | XOR + ; + +SetCondOps + : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE + ; + +IPredicates + : EQ { $$ = ICmpInst::ICMP_EQ; } | NE { $$ = ICmpInst::ICMP_NE; } + | SLT { $$ = ICmpInst::ICMP_SLT; } | SGT { $$ = ICmpInst::ICMP_SGT; } + | SLE { $$ = ICmpInst::ICMP_SLE; } | SGE { $$ = ICmpInst::ICMP_SGE; } + | ULT { $$ = ICmpInst::ICMP_ULT; } | UGT { $$ = ICmpInst::ICMP_UGT; } + | ULE { $$ = ICmpInst::ICMP_ULE; } | UGE { $$ = ICmpInst::ICMP_UGE; } + ; + +FPredicates + : OEQ { $$ = FCmpInst::FCMP_OEQ; } | ONE { $$ = FCmpInst::FCMP_ONE; } + | OLT { $$ = FCmpInst::FCMP_OLT; } | OGT { $$ = FCmpInst::FCMP_OGT; } + | OLE { $$ = FCmpInst::FCMP_OLE; } | OGE { $$ = FCmpInst::FCMP_OGE; } + | ORD { $$ = FCmpInst::FCMP_ORD; } | UNO { $$ = FCmpInst::FCMP_UNO; } + | UEQ { $$ = FCmpInst::FCMP_UEQ; } | UNE { $$ = FCmpInst::FCMP_UNE; } + | ULT { $$ = FCmpInst::FCMP_ULT; } | UGT { $$ = FCmpInst::FCMP_UGT; } + | ULE { $$ = FCmpInst::FCMP_ULE; } | UGE { $$ = FCmpInst::FCMP_UGE; } + | TRUETOK { $$ = FCmpInst::FCMP_TRUE; } + | FALSETOK { $$ = FCmpInst::FCMP_FALSE; } + ; +ShiftOps + : SHL | SHR | ASHR | LSHR + ; + +CastOps + : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | FPTOUI | FPTOSI + | UITOFP | SITOFP | PTRTOINT | INTTOPTR | BITCAST | CAST + ; // 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 + : Name '=' { $$ = $1; } | /*empty*/ { - $$ = new std::string(""); + $$ = 0; }; OptLinkage - : INTERNAL | LINKONCE | WEAK | APPENDING | DLLIMPORT | DLLEXPORT - | EXTERN_WEAK - | /*empty*/ { $$ = new std::string(""); } ; + : 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 - : CCC_TOK | CSRETCC_TOK | FASTCC_TOK | COLDCC_TOK | X86_STDCALLCC_TOK - | X86_FASTCALLCC_TOK - | CC_TOK EUINT64VAL { - *$1 += *$2; - delete $2; - $$ = $1; - } - | /*empty*/ { $$ = new std::string(""); } ; + : /*empty*/ { $$ = lastCallingConv = OldCallingConv::C; } + | CCC_TOK { $$ = lastCallingConv = OldCallingConv::C; } + | CSRETCC_TOK { $$ = lastCallingConv = OldCallingConv::CSRet; } + | FASTCC_TOK { $$ = lastCallingConv = OldCallingConv::Fast; } + | COLDCC_TOK { $$ = lastCallingConv = OldCallingConv::Cold; } + | X86_STDCALLCC_TOK { $$ = lastCallingConv = OldCallingConv::X86_StdCall; } + | X86_FASTCALLCC_TOK { $$ = lastCallingConv = OldCallingConv::X86_FastCall; } + | CC_TOK EUINT64VAL { + if ((unsigned)$2 != $2) + error("Calling conv too large"); + $$ = lastCallingConv = $2; + } + ; // OptAlign/OptCAlign - An optional alignment, and an optional alignment with // a comma before it. OptAlign - : /*empty*/ { $$ = new std::string(); } - | ALIGN EUINT64VAL { *$1 += " " + *$2; delete $2; $$ = $1; }; + : /*empty*/ { $$ = 0; } + | ALIGN EUINT64VAL { + $$ = $2; + if ($$ != 0 && !isPowerOf2_32($$)) + error("Alignment must be a power of two"); + } + ; OptCAlign - : /*empty*/ { $$ = new std::string(); } - | ',' ALIGN EUINT64VAL { - $2->insert(0, ", "); - *$2 += " " + *$3; - delete $3; - $$ = $2; - }; + : /*empty*/ { $$ = 0; } + | ',' ALIGN EUINT64VAL { + $$ = $3; + if ($$ != 0 && !isPowerOf2_32($$)) + error("Alignment must be a power of two"); + } + ; SectionString - : SECTION STRINGCONSTANT { - *$1 += " " + *$2; - delete $2; - $$ = $1; - }; + : SECTION STRINGCONSTANT { + for (unsigned i = 0, e = strlen($2); i != e; ++i) + if ($2[i] == '"' || $2[i] == '\\') + error("Invalid character in section name"); + $$ = $2; + } + ; -OptSection : /*empty*/ { $$ = new std::string(); } - | SectionString; +OptSection + : /*empty*/ { $$ = 0; } + | SectionString { $$ = $1; } + ; +// GlobalVarAttributes - Used to pass the attributes string on a global. CurGV +// is set to be the global we are processing. +// GlobalVarAttributes - : /* empty */ { $$ = new std::string(); } - | ',' GlobalVarAttribute GlobalVarAttributes { - $2->insert(0, ", "); - if (!$3->empty()) - *$2 += " " + *$3; - delete $3; - $$ = $2; - }; + : /* empty */ {} + | ',' GlobalVarAttribute GlobalVarAttributes {} + ; -GlobalVarAttribute - : SectionString - | ALIGN EUINT64VAL { - *$1 += " " + *$2; - delete $2; - $$ = $1; - }; +GlobalVarAttribute + : SectionString { + CurGV->setSection($1); + free($1); + } + | ALIGN EUINT64VAL { + if ($2 != 0 && !isPowerOf2_32($2)) + error("Alignment must be a power of two"); + CurGV->setAlignment($2); + + } + ; //===----------------------------------------------------------------------===// // Types includes all predefined types... except void, because it can only be @@ -961,112 +2065,180 @@ GlobalVarAttribute // // TypesV includes all of 'Types', but it also includes the void type. -TypesV : Types | VOID ; -UpRTypesV : UpRTypes | VOID ; -Types : UpRTypes ; +TypesV + : Types + | VOID { + $$.PAT = new PATypeHolder($1.T); + $$.S.makeSignless(); + } + ; + +UpRTypesV + : UpRTypes + | VOID { + $$.PAT = new PATypeHolder($1.T); + $$.S.makeSignless(); + } + ; + +Types + : UpRTypes { + if (!UpRefs.empty()) + error("Invalid upreference in type: " + (*$1.PAT)->getDescription()); + $$ = $1; + } + ; + +PrimType + : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT + | LONG | ULONG | FLOAT | DOUBLE | LABEL + ; // Derived types are added later... -// -PrimType : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT ; -PrimType : LONG | ULONG | FLOAT | DOUBLE | LABEL; UpRTypes - : OPAQUE { - $$ = TypeInfo::get(*$1, OpaqueTy); - } - | SymbolicValueRef { - $$ = TypeInfo::get(*$1, UnresolvedTy); + : PrimType { + $$.PAT = new PATypeHolder($1.T); + $$.S.copy($1.S); + } + | OPAQUE { + $$.PAT = new PATypeHolder(OpaqueType::get()); + $$.S.makeSignless(); } - | PrimType { - $$ = $1; + | SymbolicValueRef { // Named types are also simple types... + $$.S.copy(getTypeSign($1)); + const Type* tmp = getType($1); + $$.PAT = new PATypeHolder(tmp); } | '\\' EUINT64VAL { // Type UpReference - $2->insert(0, "\\"); - $$ = TypeInfo::get(*$2, UpRefTy); + if ($2 > (uint64_t)~0U) + error("Value out of range"); + OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder + UpRefs.push_back(UpRefRecord((unsigned)$2, OT)); // Add to vector... + $$.PAT = new PATypeHolder(OT); + $$.S.makeSignless(); + UR_OUT("New Upreference!\n"); } | UpRTypesV '(' ArgTypeListI ')' { // Function derived type? - std::string newTy( $1->getNewTy() + "("); - for (unsigned i = 0; i < $3->size(); ++i) { - if (i != 0) - newTy += ", "; - if ((*$3)[i]->isVoid()) - newTy += "..."; - else - newTy += (*$3)[i]->getNewTy(); + $$.S.makeComposite($1.S); + std::vector Params; + for (std::list::iterator I = $3->begin(), + E = $3->end(); I != E; ++I) { + Params.push_back(I->PAT->get()); + $$.S.add(I->S); + } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + ParamAttrsList *PAL = 0; + if (lastCallingConv == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); } - newTy += ")"; - $$ = TypeInfo::get(newTy, $1, $3); + + const FunctionType *FTy = + FunctionType::get($1.PAT->get(), Params, isVarArg, PAL); + + $$.PAT = new PATypeHolder( HandleUpRefs(FTy, $$.S) ); + delete $1.PAT; // Delete the return type handle + delete $3; // Delete the argument list } | '[' EUINT64VAL 'x' UpRTypes ']' { // Sized array type? - uint64_t elems = atoi($2->c_str()); - $2->insert(0,"[ "); - *$2 += " x " + $4->getNewTy() + " ]"; - $$ = TypeInfo::get(*$2, ArrayTy, $4, elems); - } - | '<' EUINT64VAL 'x' UpRTypes '>' { // Packed array type? - uint64_t elems = atoi($2->c_str()); - $2->insert(0,"< "); - *$2 += " x " + $4->getNewTy() + " >"; - $$ = TypeInfo::get(*$2, PackedTy, $4, elems); + $$.S.makeComposite($4.S); + $$.PAT = new PATypeHolder(HandleUpRefs(ArrayType::get($4.PAT->get(), + (unsigned)$2), $$.S)); + delete $4.PAT; + } + | '<' EUINT64VAL 'x' UpRTypes '>' { // Vector type? + const llvm::Type* ElemTy = $4.PAT->get(); + if ((unsigned)$2 != $2) + error("Unsigned result not equal to signed result"); + if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint())) + error("Elements of a VectorType must be integer or floating point"); + if (!isPowerOf2_32($2)) + error("VectorType length should be a power of 2"); + $$.S.makeComposite($4.S); + $$.PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy, + (unsigned)$2), $$.S)); + delete $4.PAT; } | '{' TypeListI '}' { // Structure type? - std::string newTy("{"); - for (unsigned i = 0; i < $2->size(); ++i) { - if (i != 0) - newTy += ", "; - newTy += (*$2)[i]->getNewTy(); + std::vector Elements; + $$.S.makeComposite(); + for (std::list::iterator I = $2->begin(), + E = $2->end(); I != E; ++I) { + Elements.push_back(I->PAT->get()); + $$.S.add(I->S); } - newTy += "}"; - $$ = TypeInfo::get(newTy, StructTy, $2); + $$.PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), $$.S)); + delete $2; } | '{' '}' { // Empty structure type? - $$ = TypeInfo::get("{}", StructTy, new TypeList()); + $$.PAT = new PATypeHolder(StructType::get(std::vector())); + $$.S.makeComposite(); } | '<' '{' TypeListI '}' '>' { // Packed Structure type? - std::string newTy("<{"); - for (unsigned i = 0; i < $3->size(); ++i) { - if (i != 0) - newTy += ", "; - newTy += (*$3)[i]->getNewTy(); + $$.S.makeComposite(); + std::vector Elements; + for (std::list::iterator I = $3->begin(), + E = $3->end(); I != E; ++I) { + Elements.push_back(I->PAT->get()); + $$.S.add(I->S); + delete I->PAT; } - newTy += "}>"; - $$ = TypeInfo::get(newTy, PackedStructTy, $3); + $$.PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true), + $$.S)); + delete $3; } | '<' '{' '}' '>' { // Empty packed structure type? - $$ = TypeInfo::get("<{}>", PackedStructTy, new TypeList()); + $$.PAT = new PATypeHolder(StructType::get(std::vector(),true)); + $$.S.makeComposite(); } | UpRTypes '*' { // Pointer type? - $$ = $1->getPointerType(); - }; + if ($1.PAT->get() == Type::LabelTy) + error("Cannot form a pointer to a basic block"); + $$.S.makeComposite($1.S); + $$.PAT = new PATypeHolder(HandleUpRefs(PointerType::get($1.PAT->get()), + $$.S)); + delete $1.PAT; + } + ; // TypeList - Used for struct declarations and as a basis for function type // declaration type lists // TypeListI : UpRTypes { - $$ = new TypeList(); - $$->push_back($1); + $$ = new std::list(); + $$->push_back($1); } | TypeListI ',' UpRTypes { - $$ = $1; - $$->push_back($3); - }; + ($$=$1)->push_back($3); + } + ; // ArgTypeList - List of types for a function type declaration... ArgTypeListI - : TypeListI + : TypeListI | TypeListI ',' DOTDOTDOT { - $$ = $1; - $$->push_back(TypeInfo::get("void",VoidTy)); - delete $3; + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + ($$=$1)->push_back(VoidTI); } | DOTDOTDOT { - $$ = new TypeList(); - $$->push_back(TypeInfo::get("void",VoidTy)); - delete $1; + $$ = new std::list(); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + $$->push_back(VoidTI); } | /*empty*/ { - $$ = new TypeList(); - }; + $$ = new std::list(); + } + ; // ConstVal - The various declarations that go into the constant pool. This // production is used ONLY to represent constants that show up AFTER a 'const', @@ -1074,200 +2246,436 @@ ArgTypeListI // into other expressions (such as integers and constexprs) are handled by the // ResolvedVal, ValueRef and ConstValueRef productions. // -ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " [ " + *$3 + " ]"; +ConstVal + : Types '[' ConstVector ']' { // Nonempty unsized arr + const ArrayType *ATy = dyn_cast($1.PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + const Type *ETy = ATy->getElementType(); + int NumElements = ATy->getNumElements(); + + // Verify that we have the correct size... + if (NumElements != -1 && NumElements != (int)$3->size()) + error("Type mismatch: constant sized array initialized with " + + utostr($3->size()) + " arguments, but has size of " + + itostr(NumElements) + ""); + + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < $3->size(); i++) { + Constant *C = (*$3)[i].C; + const Type* ValTy = C->getType(); + if (ETy != ValTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + ValTy->getDescription() + "'"); + Elems.push_back(C); + } + $$.C = ConstantArray::get(ATy, Elems); + $$.S.copy($1.S); + delete $1.PAT; delete $3; } | Types '[' ']' { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += "[ ]"; + const ArrayType *ATy = dyn_cast($1.PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + int NumElements = ATy->getNumElements(); + if (NumElements != -1 && NumElements != 0) + error("Type mismatch: constant sized array initialized with 0" + " arguments, but has size of " + itostr(NumElements) +""); + $$.C = ConstantArray::get(ATy, std::vector()); + $$.S.copy($1.S); + delete $1.PAT; } | Types 'c' STRINGCONSTANT { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " c" + *$3; - delete $3; + const ArrayType *ATy = dyn_cast($1.PAT->get()); + if (ATy == 0) + error("Cannot make array constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + int NumElements = ATy->getNumElements(); + const Type *ETy = dyn_cast(ATy->getElementType()); + if (!ETy || cast(ETy)->getBitWidth() != 8) + error("String arrays require type i8, not '" + ETy->getDescription() + + "'"); + char *EndStr = UnEscapeLexed($3, true); + if (NumElements != -1 && NumElements != (EndStr-$3)) + error("Can't build string constant of size " + + itostr((int)(EndStr-$3)) + " when array has size " + + itostr(NumElements) + ""); + std::vector Vals; + for (char *C = (char *)$3; C != (char *)EndStr; ++C) + Vals.push_back(ConstantInt::get(ETy, *C)); + free($3); + $$.C = ConstantArray::get(ATy, Vals); + $$.S.copy($1.S); + delete $1.PAT; } | Types '<' ConstVector '>' { // Nonempty unsized arr - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " < " + *$3 + " >"; + const VectorType *PTy = dyn_cast($1.PAT->get()); + if (PTy == 0) + error("Cannot make packed constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + const Type *ETy = PTy->getElementType(); + int NumElements = PTy->getNumElements(); + // Verify that we have the correct size... + if (NumElements != -1 && NumElements != (int)$3->size()) + error("Type mismatch: constant sized packed initialized with " + + utostr($3->size()) + " arguments, but has size of " + + itostr(NumElements) + ""); + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < $3->size(); i++) { + Constant *C = (*$3)[i].C; + const Type* ValTy = C->getType(); + if (ETy != ValTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + ValTy->getDescription() + "'"); + Elems.push_back(C); + } + $$.C = ConstantVector::get(PTy, Elems); + $$.S.copy($1.S); + delete $1.PAT; delete $3; } | Types '{' ConstVector '}' { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " { " + *$3 + " }"; + const StructType *STy = dyn_cast($1.PAT->get()); + if (STy == 0) + error("Cannot make struct constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + if ($3->size() != STy->getNumContainedTypes()) + error("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + std::vector Fields; + for (unsigned i = 0, e = $3->size(); i != e; ++i) { + Constant *C = (*$3)[i].C; + if (C->getType() != STy->getElementType(i)) + error("Expected type '" + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + " of structure initializer"); + Fields.push_back(C); + } + $$.C = ConstantStruct::get(STy, Fields); + $$.S.copy($1.S); + delete $1.PAT; delete $3; } | Types '{' '}' { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " {}"; + const StructType *STy = dyn_cast($1.PAT->get()); + if (STy == 0) + error("Cannot make struct constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + if (STy->getNumContainedTypes() != 0) + error("Illegal number of initializers for structure type"); + $$.C = ConstantStruct::get(STy, std::vector()); + $$.S.copy($1.S); + delete $1.PAT; + } + | Types '<' '{' ConstVector '}' '>' { + const StructType *STy = dyn_cast($1.PAT->get()); + if (STy == 0) + error("Cannot make packed struct constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + if ($4->size() != STy->getNumContainedTypes()) + error("Illegal number of initializers for packed structure type"); + + // Check to ensure that constants are compatible with the type initializer! + std::vector Fields; + for (unsigned i = 0, e = $4->size(); i != e; ++i) { + Constant *C = (*$4)[i].C; + if (C->getType() != STy->getElementType(i)) + error("Expected type '" + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + " of packed struct initializer"); + Fields.push_back(C); + } + $$.C = ConstantStruct::get(STy, Fields); + $$.S.copy($1.S); + delete $1.PAT; + delete $4; + } + | Types '<' '{' '}' '>' { + const StructType *STy = dyn_cast($1.PAT->get()); + if (STy == 0) + error("Cannot make packed struct constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + if (STy->getNumContainedTypes() != 0) + error("Illegal number of initializers for packed structure type"); + $$.C = ConstantStruct::get(STy, std::vector()); + $$.S.copy($1.S); + delete $1.PAT; } | Types NULL_TOK { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + const PointerType *PTy = dyn_cast($1.PAT->get()); + if (PTy == 0) + error("Cannot make null pointer constant with type: '" + + $1.PAT->get()->getDescription() + "'"); + $$.C = ConstantPointerNull::get(PTy); + $$.S.copy($1.S); + delete $1.PAT; } | Types UNDEF { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + $$.C = UndefValue::get($1.PAT->get()); + $$.S.copy($1.S); + delete $1.PAT; } | Types SymbolicValueRef { - std::string Name = getUniqueName($2, $1->resolve(), true); - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + Name; - delete $2; + const PointerType *Ty = dyn_cast($1.PAT->get()); + if (Ty == 0) + error("Global const reference must be a pointer type, not" + + $1.PAT->get()->getDescription()); + + // 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, getExistingValue 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 + // getExistingValue that we are at global scope here. + // + Function *SavedCurFn = CurFun.CurrentFunction; + CurFun.CurrentFunction = 0; + $2.S.copy($1.S); + Value *V = getExistingValue(Ty, $2); + CurFun.CurrentFunction = SavedCurFn; + + // 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(Ty) && "Globals may only be used as pointers"); + const PointerType *PT = cast(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(PT->getElementType())) { + GV = new Function(FTy, GlobalValue::ExternalLinkage, Name, + CurModule.CurrentModule); + } else { + GV = new GlobalVariable(PT->getElementType(), false, + GlobalValue::ExternalLinkage, 0, + Name, CurModule.CurrentModule); + } + + // Keep track of the fact that we have a forward ref to recycle it + CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV)); + V = GV; + } + } + $$.C = cast(V); + $$.S.copy($1.S); + delete $1.PAT; // Free the type handle } | Types ConstExpr { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + if ($1.PAT->get() != $2.C->getType()) + error("Mismatched types for constant expression"); + $$ = $2; + $$.S.copy($1.S); + delete $1.PAT; } | Types ZEROINITIALIZER { - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; - } - | SIntType EInt64Val { // integral constants - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; - } - | UIntType EInt64Val { // integral constants - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + const Type *Ty = $1.PAT->get(); + if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) + error("Cannot create a null initialized value of this type"); + $$.C = Constant::getNullValue(Ty); + $$.S.copy($1.S); + delete $1.PAT; + } + | SIntType EINT64VAL { // integral constants + const Type *Ty = $1.T; + if (!ConstantInt::isValueValidForType(Ty, $2)) + error("Constant value doesn't fit in type"); + $$.C = ConstantInt::get(Ty, $2); + $$.S.makeSigned(); + } + | UIntType EUINT64VAL { // integral constants + const Type *Ty = $1.T; + if (!ConstantInt::isValueValidForType(Ty, $2)) + error("Constant value doesn't fit in type"); + $$.C = ConstantInt::get(Ty, $2); + $$.S.makeUnsigned(); } | BOOL TRUETOK { // Boolean constants - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + $$.C = ConstantInt::get(Type::Int1Ty, true); + $$.S.makeUnsigned(); } | BOOL FALSETOK { // Boolean constants - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; - delete $2; + $$.C = ConstantInt::get(Type::Int1Ty, false); + $$.S.makeUnsigned(); } | FPType FPVAL { // Float & Double constants - $$.type = $1; - $$.cnst = new std::string($1->getNewTy()); - *$$.cnst += " " + *$2; + if (!ConstantFP::isValueValidForType($1.T, *$2)) + error("Floating point constant invalid for type"); + // Lexer has no type info, so builds all FP constants as double. + // Fix this here. + if ($1.T==Type::FloatTy) + $2->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + $$.C = ConstantFP::get($1.T, *$2); delete $2; - }; - + $$.S.makeSignless(); + } + ; -ConstExpr: CastOps '(' ConstVal TO Types ')' { - std::string source = *$3.cnst; - const TypeInfo* SrcTy = $3.type->resolve(); - const TypeInfo* DstTy = $5->resolve(); - if (*$1 == "cast") { - // Call getCastUpgrade to upgrade the old cast - $$ = new std::string(getCastUpgrade(source, SrcTy, DstTy, true)); - } else { - // Nothing to upgrade, just create the cast constant expr - $$ = new std::string(*$1); - *$$ += "( " + source + " to " + $5->getNewTy() + ")"; - } - delete $1; $3.destroy(); delete $4; +ConstExpr + : CastOps '(' ConstVal TO Types ')' { + const Type* SrcTy = $3.C->getType(); + const Type* DstTy = $5.PAT->get(); + Signedness SrcSign($3.S); + Signedness DstSign($5.S); + if (!SrcTy->isFirstClassType()) + error("cast constant expression from a non-primitive type: '" + + SrcTy->getDescription() + "'"); + if (!DstTy->isFirstClassType()) + error("cast constant expression to a non-primitive type: '" + + DstTy->getDescription() + "'"); + $$.C = cast(getCast($1, $3.C, SrcSign, DstTy, DstSign)); + $$.S.copy(DstSign); + delete $5.PAT; } | GETELEMENTPTR '(' ConstVal IndexList ')' { - *$1 += "(" + *$3.cnst; - for (unsigned i = 0; i < $4->size(); ++i) { - ValueInfo& VI = (*$4)[i]; - *$1 += ", " + *VI.val; - VI.destroy(); - } - *$1 += ")"; - $$ = $1; - $3.destroy(); + const Type *Ty = $3.C->getType(); + if (!isa(Ty)) + error("GetElementPtr requires a pointer operand"); + + std::vector CIndices; + upgradeGEPCEIndices($3.C->getType(), $4, CIndices); + delete $4; + $$.C = ConstantExpr::getGetElementPtr($3.C, &CIndices[0], CIndices.size()); + $$.S.copy(getElementSign($3, CIndices)); } | SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' { - *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")"; - $3.destroy(); $5.destroy(); $7.destroy(); - $$ = $1; + if (!$3.C->getType()->isInteger() || + cast($3.C->getType())->getBitWidth() != 1) + error("Select condition must be bool type"); + if ($5.C->getType() != $7.C->getType()) + error("Select operand types must match"); + $$.C = ConstantExpr::getSelect($3.C, $5.C, $7.C); + $$.S.copy($5.S); } | ArithmeticOps '(' ConstVal ',' ConstVal ')' { - const char* op = getDivRemOpcode(*$1, $3.type); - $$ = new std::string(op); - *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")"; - delete $1; $3.destroy(); $5.destroy(); + const Type *Ty = $3.C->getType(); + if (Ty != $5.C->getType()) + error("Binary operator types must match"); + // First, make sure we're dealing with the right opcode by upgrading from + // obsolete versions. + Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S); + + // 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(Ty)) { + $$.C = ConstantExpr::get(Opcode, $3.C, $5.C); + } else { + const Type *IntPtrTy = 0; + switch (CurModule.CurrentModule->getPointerSize()) { + case Module::Pointer32: IntPtrTy = Type::Int32Ty; break; + case Module::Pointer64: IntPtrTy = Type::Int64Ty; break; + default: error("invalid pointer binary constant expr"); + } + $$.C = ConstantExpr::get(Opcode, + ConstantExpr::getCast(Instruction::PtrToInt, $3.C, IntPtrTy), + ConstantExpr::getCast(Instruction::PtrToInt, $5.C, IntPtrTy)); + $$.C = ConstantExpr::getCast(Instruction::IntToPtr, $$.C, Ty); + } + $$.S.copy($3.S); } | LogicalOps '(' ConstVal ',' ConstVal ')' { - *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")"; - $3.destroy(); $5.destroy(); - $$ = $1; + const Type* Ty = $3.C->getType(); + if (Ty != $5.C->getType()) + error("Logical operator types must match"); + if (!Ty->isInteger()) { + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) + error("Logical operator requires integer operands"); + } + Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $3.S); + $$.C = ConstantExpr::get(Opcode, $3.C, $5.C); + $$.S.copy($3.S); } | SetCondOps '(' ConstVal ',' ConstVal ')' { - *$1 = getCompareOp(*$1, $3.type); - *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")"; - $3.destroy(); $5.destroy(); - $$ = $1; + const Type* Ty = $3.C->getType(); + if (Ty != $5.C->getType()) + error("setcc operand types must match"); + unsigned short pred; + Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $3.S); + $$.C = ConstantExpr::getCompare(Opcode, $3.C, $5.C); + $$.S.makeUnsigned(); } | ICMP IPredicates '(' ConstVal ',' ConstVal ')' { - *$1 += " " + *$2 + " (" + *$4.cnst + "," + *$6.cnst + ")"; - delete $2; $4.destroy(); $6.destroy(); - $$ = $1; + if ($4.C->getType() != $6.C->getType()) + error("icmp operand types must match"); + $$.C = ConstantExpr::getCompare($2, $4.C, $6.C); + $$.S.makeUnsigned(); } | FCMP FPredicates '(' ConstVal ',' ConstVal ')' { - *$1 += " " + *$2 + " (" + *$4.cnst + "," + *$6.cnst + ")"; - delete $2; $4.destroy(); $6.destroy(); - $$ = $1; + if ($4.C->getType() != $6.C->getType()) + error("fcmp operand types must match"); + $$.C = ConstantExpr::getCompare($2, $4.C, $6.C); + $$.S.makeUnsigned(); } | ShiftOps '(' ConstVal ',' ConstVal ')' { - const char* shiftop = $1->c_str(); - if (*$1 == "shr") - shiftop = ($3.type->isUnsigned()) ? "lshr" : "ashr"; - $$ = new std::string(shiftop); - *$$ += "(" + *$3.cnst + "," + *$5.cnst + ")"; - delete $1; $3.destroy(); $5.destroy(); + if (!$5.C->getType()->isInteger() || + cast($5.C->getType())->getBitWidth() != 8) + error("Shift count for shift constant must be unsigned byte"); + const Type* Ty = $3.C->getType(); + if (!$3.C->getType()->isInteger()) + error("Shift constant expression requires integer operand"); + Constant *ShiftAmt = ConstantExpr::getZExt($5.C, Ty); + $$.C = ConstantExpr::get(getBinaryOp($1, Ty, $3.S), $3.C, ShiftAmt); + $$.S.copy($3.S); } | EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' { - *$1 += "(" + *$3.cnst + "," + *$5.cnst + ")"; - $3.destroy(); $5.destroy(); - $$ = $1; + if (!ExtractElementInst::isValidOperands($3.C, $5.C)) + error("Invalid extractelement operands"); + $$.C = ConstantExpr::getExtractElement($3.C, $5.C); + $$.S.copy($3.S.get(0)); } | INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' { - *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")"; - $3.destroy(); $5.destroy(); $7.destroy(); - $$ = $1; + if (!InsertElementInst::isValidOperands($3.C, $5.C, $7.C)) + error("Invalid insertelement operands"); + $$.C = ConstantExpr::getInsertElement($3.C, $5.C, $7.C); + $$.S.copy($3.S); } | SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' { - *$1 += "(" + *$3.cnst + "," + *$5.cnst + "," + *$7.cnst + ")"; - $3.destroy(); $5.destroy(); $7.destroy(); - $$ = $1; - }; + if (!ShuffleVectorInst::isValidOperands($3.C, $5.C, $7.C)) + error("Invalid shufflevector operands"); + $$.C = ConstantExpr::getShuffleVector($3.C, $5.C, $7.C); + $$.S.copy($3.S); + } + ; // ConstVector - A list of comma separated constants. - ConstVector - : ConstVector ',' ConstVal { - *$1 += ", " + *$3.cnst; - $3.destroy(); - $$ = $1; + : ConstVector ',' ConstVal { ($$ = $1)->push_back($3); } + | ConstVal { + $$ = new std::vector(); + $$->push_back($1); } - | ConstVal { $$ = new std::string(*$1.cnst); $1.destroy(); } ; // GlobalType - Match either GLOBAL or CONSTANT for global declarations... -GlobalType : GLOBAL | CONSTANT ; +GlobalType + : GLOBAL { $$ = false; } + | CONSTANT { $$ = true; } + ; //===----------------------------------------------------------------------===// @@ -1277,739 +2685,1258 @@ GlobalType : GLOBAL | CONSTANT ; // Module rule: Capture the result of parsing the whole file into a result // variable... // -Module : DefinitionList { -}; +Module + : FunctionList { + $$ = ParserResult = $1; + CurModule.ModuleDone(); + } + ; -// DefinitionList - Top level definitions +// FunctionList - A list of functions, preceeded by a constant pool. // -DefinitionList : DefinitionList Function { - $$ = 0; - } - | DefinitionList FunctionProto { - *O << *$2 << '\n'; - delete $2; - $$ = 0; - } - | DefinitionList MODULE ASM_TOK AsmBlock { - *O << "module asm " << ' ' << *$4 << '\n'; - $$ = 0; - } - | DefinitionList IMPLEMENTATION { - *O << "implementation\n"; - $$ = 0; +FunctionList + : FunctionList Function { $$ = $1; CurFun.FunctionDone(); } + | FunctionList FunctionProto { $$ = $1; } + | FunctionList MODULE ASM_TOK AsmBlock { $$ = $1; } + | FunctionList IMPLEMENTATION { $$ = $1; } + | ConstPool { + $$ = CurModule.CurrentModule; + // Emit an error if there are any unresolved types left. + if (!CurModule.LateResolveTypes.empty()) { + const ValID &DID = CurModule.LateResolveTypes.begin()->first; + if (DID.Type == ValID::NameVal) { + error("Reference to an undefined type: '"+DID.getName() + "'"); + } else { + error("Reference to an undefined type: #" + itostr(DID.Num)); + } + } } - | ConstPool { $$ = 0; } - -External : EXTERNAL | UNINITIALIZED { $$ = $1; *$$ = "external"; } + ; // ConstPool - Constants with optional names assigned to them. -ConstPool : ConstPool OptAssign TYPE TypesV { - EnumeratedTypes.push_back($4); - if (!$2->empty()) { - NamedTypes[*$2] = $4; - *O << *$2 << " = "; - } - *O << "type " << $4->getNewTy() << '\n'; - delete $2; delete $3; - $$ = 0; +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.PAT->get(), $4.S); + + if (!setTypeName($4, $2) && !$2) { + // If this is a numbered type that is not a redefinition, add it to the + // slot table. + CurModule.Types.push_back($4.PAT->get()); + CurModule.TypeSigns.push_back($4.S); + } + delete $4.PAT; } | ConstPool FunctionProto { // Function prototypes can be in const pool - *O << *$2 << '\n'; - delete $2; - $$ = 0; } | ConstPool MODULE ASM_TOK AsmBlock { // Asm blocks can be in the const pool - *O << *$2 << ' ' << *$3 << ' ' << *$4 << '\n'; - delete $2; delete $3; delete $4; - $$ = 0; - } - | ConstPool OptAssign OptLinkage GlobalType ConstVal GlobalVarAttributes { - if (!$2->empty()) { - std::string Name = getGlobalName($2,*$3, $5.type->getPointerType(), - *$4 == "constant"); - *O << Name << " = "; - } - *O << *$3 << ' ' << *$4 << ' ' << *$5.cnst << ' ' << *$6 << '\n'; - delete $2; delete $3; delete $4; delete $6; - $$ = 0; - } - | ConstPool OptAssign External GlobalType Types GlobalVarAttributes { - if (!$2->empty()) { - std::string Name = getGlobalName($2,*$3,$5->getPointerType(), - *$4 == "constant"); - *O << Name << " = "; - } - *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n'; - delete $2; delete $3; delete $4; delete $6; - $$ = 0; - } - | ConstPool OptAssign DLLIMPORT GlobalType Types GlobalVarAttributes { - if (!$2->empty()) { - std::string Name = getGlobalName($2,*$3,$5->getPointerType(), - *$4 == "constant"); - *O << Name << " = "; - } - *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n'; - delete $2; delete $3; delete $4; delete $6; - $$ = 0; } - | ConstPool OptAssign EXTERN_WEAK GlobalType Types GlobalVarAttributes { - if (!$2->empty()) { - std::string Name = getGlobalName($2,*$3,$5->getPointerType(), - *$4 == "constant"); - *O << Name << " = "; - } - *O << *$3 << ' ' << *$4 << ' ' << $5->getNewTy() << ' ' << *$6 << '\n'; - delete $2; delete $3; delete $4; delete $6; - $$ = 0; + | ConstPool OptAssign OptLinkage GlobalType ConstVal { + if ($5.C == 0) + error("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable($2, $3, $4, $5.C->getType(), $5.C, $5.S); + } GlobalVarAttributes { + CurGV = 0; + } + | ConstPool OptAssign EXTERNAL GlobalType Types { + const Type *Ty = $5.PAT->get(); + CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, Ty, 0, + $5.S); + delete $5.PAT; + } GlobalVarAttributes { + CurGV = 0; + } + | ConstPool OptAssign DLLIMPORT GlobalType Types { + const Type *Ty = $5.PAT->get(); + CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, Ty, 0, + $5.S); + delete $5.PAT; + } GlobalVarAttributes { + CurGV = 0; + } + | ConstPool OptAssign EXTERN_WEAK GlobalType Types { + const Type *Ty = $5.PAT->get(); + CurGV = + ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, Ty, 0, + $5.S); + delete $5.PAT; + } GlobalVarAttributes { + CurGV = 0; } | ConstPool TARGET TargetDefinition { - *O << *$2 << ' ' << *$3 << '\n'; - delete $2; delete $3; - $$ = 0; } | ConstPool DEPLIBS '=' LibrariesDefinition { - *O << *$2 << " = " << *$4 << '\n'; - delete $2; delete $4; - $$ = 0; } | /* empty: end of list */ { - $$ = 0; - }; + } + ; +AsmBlock + : STRINGCONSTANT { + const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); + char *EndStr = UnEscapeLexed($1, true); + std::string NewAsm($1, EndStr); + free($1); -AsmBlock : STRINGCONSTANT ; + if (AsmSoFar.empty()) + CurModule.CurrentModule->setModuleInlineAsm(NewAsm); + else + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm); + } + ; -BigOrLittle : BIG | LITTLE +BigOrLittle + : BIG { $$ = Module::BigEndian; } + | LITTLE { $$ = Module::LittleEndian; } + ; TargetDefinition : ENDIAN '=' BigOrLittle { - *$1 += " = " + *$3; - delete $3; - $$ = $1; + CurModule.setEndianness($3); } | POINTERSIZE '=' EUINT64VAL { - *$1 += " = " + *$3; - if (*$3 == "64") - SizeOfPointer = 64; - delete $3; - $$ = $1; + if ($3 == 32) + CurModule.setPointerSize(Module::Pointer32); + else if ($3 == 64) + CurModule.setPointerSize(Module::Pointer64); + else + error("Invalid pointer size: '" + utostr($3) + "'"); } | TRIPLE '=' STRINGCONSTANT { - *$1 += " = " + *$3; - delete $3; - $$ = $1; + CurModule.CurrentModule->setTargetTriple($3); + free($3); } | DATALAYOUT '=' STRINGCONSTANT { - *$1 += " = " + *$3; - delete $3; - $$ = $1; - }; + CurModule.CurrentModule->setDataLayout($3); + free($3); + } + ; LibrariesDefinition - : '[' LibList ']' { - $2->insert(0, "[ "); - *$2 += " ]"; - $$ = $2; - }; + : '[' LibList ']' + ; LibList : LibList ',' STRINGCONSTANT { - *$1 += ", " + *$3; - delete $3; - $$ = $1; + CurModule.CurrentModule->addLibrary($3); + free($3); } - | STRINGCONSTANT - | /* empty: end of list */ { - $$ = new std::string(); - }; + | STRINGCONSTANT { + CurModule.CurrentModule->addLibrary($1); + free($1); + } + | /* empty: end of list */ { } + ; //===----------------------------------------------------------------------===// // Rules to match Function Headers //===----------------------------------------------------------------------===// -Name : VAR_ID | STRINGCONSTANT; -OptName : Name | /*empty*/ { $$ = new std::string(); }; +Name + : VAR_ID | STRINGCONSTANT + ; + +OptName + : Name + | /*empty*/ { $$ = 0; } + ; -ArgVal : Types OptName { - $$ = new std::string($1->getNewTy()); - if (!$2->empty()) { - std::string Name = getUniqueName($2, $1->resolve()); - *$$ += " " + Name; +ArgVal + : Types OptName { + if ($1.PAT->get() == Type::VoidTy) + error("void typed arguments are invalid"); + $$ = new std::pair($1, $2); } - delete $2; -}; + ; -ArgListH : ArgListH ',' ArgVal { - *$1 += ", " + *$3; +ArgListH + : ArgListH ',' ArgVal { + $$ = $1; + $$->push_back(*$3); delete $3; } | ArgVal { - $$ = $1; - }; - -ArgList : ArgListH { - $$ = $1; + $$ = new std::vector >(); + $$->push_back(*$1); + delete $1; } + ; + +ArgList + : ArgListH { $$ = $1; } | ArgListH ',' DOTDOTDOT { - *$1 += ", ..."; $$ = $1; - delete $3; + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + $$->push_back(std::pair(VoidTI, 0)); } | DOTDOTDOT { - $$ = $1; + $$ = new std::vector >(); + PATypeInfo VoidTI; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); + $$->push_back(std::pair(VoidTI, 0)); } - | /* empty */ { $$ = new std::string(); }; + | /* empty */ { $$ = 0; } + ; FunctionHeaderH : OptCallingConv TypesV Name '(' ArgList ')' OptSection OptAlign { - if (!$1->empty()) { - *$1 += " "; + UnEscapeLexed($3); + std::string FunctionName($3); + free($3); // Free strdup'd memory! + + const Type* RetTy = $2.PAT->get(); + + if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) + error("LLVM functions cannot return aggregate types"); + + Signedness FTySign; + FTySign.makeComposite($2.S); + std::vector ParamTyList; + + // In LLVM 2.0 the signatures of three varargs intrinsics changed to take + // i8*. We check here for those names and override the parameter list + // types to ensure the prototype is correct. + if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") { + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + } else if (FunctionName == "llvm.va_copy") { + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + } else if ($5) { // If there are arguments... + for (std::vector >::iterator + I = $5->begin(), E = $5->end(); I != E; ++I) { + const Type *Ty = I->first.PAT->get(); + ParamTyList.push_back(Ty); + FTySign.add(I->first.S); + } } - *$1 += $2->getNewTy() + " " + *$3 + "(" + *$5 + ")"; - if (!$7->empty()) { - *$1 += " " + *$7; + + bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy; + if (isVarArg) + ParamTyList.pop_back(); + + // Convert the CSRet calling convention into the corresponding parameter + // attribute. + ParamAttrsList *PAL = 0; + if ($1 == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); } - if (!$8->empty()) { - *$1 += " " + *$8; + + const FunctionType *FT = + FunctionType::get(RetTy, ParamTyList, isVarArg, PAL); + const PointerType *PFT = PointerType::get(FT); + delete $2.PAT; + + ValID ID; + if (!FunctionName.empty()) { + ID = ValID::create((char*)FunctionName.c_str()); + } else { + ID = ValID::create((int)CurModule.Values[PFT].size()); + } + ID.S.makeComposite(FTySign); + + Function *Fn = 0; + Module* M = CurModule.CurrentModule; + + // See if this function was forward referenced. If so, recycle the object. + if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { + // Move the function to the end of the list, from whereever it was + // previously inserted. + Fn = cast(FWRef); + M->getFunctionList().remove(Fn); + M->getFunctionList().push_back(Fn); + } else if (!FunctionName.empty()) { + GlobalValue *Conflict = M->getFunction(FunctionName); + if (!Conflict) + Conflict = M->getNamedGlobal(FunctionName); + if (Conflict && PFT == Conflict->getType()) { + if (!CurFun.isDeclare && !Conflict->isDeclaration()) { + // We have two function definitions that conflict, same type, same + // name. We should really check to make sure that this is the result + // of integer type planes collapsing and generate an error if it is + // not, but we'll just rename on the assumption that it is. However, + // let's do it intelligently and rename the internal linkage one + // if there is one. + std::string NewName(makeNameUnique(FunctionName)); + if (Conflict->hasInternalLinkage()) { + Conflict->setName(NewName); + RenameMapKey Key = + makeRenameMapKey(FunctionName, Conflict->getType(), ID.S); + CurModule.RenameMap[Key] = NewName; + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); + } else { + Fn = new Function(FT, CurFun.Linkage, NewName, M); + InsertValue(Fn, CurModule.Values); + RenameMapKey Key = + makeRenameMapKey(FunctionName, PFT, ID.S); + CurModule.RenameMap[Key] = NewName; + } + } else { + // If they are not both definitions, then just use the function we + // found since the types are the same. + Fn = cast(Conflict); + + // Make sure to strip off any argument names so we can't get + // conflicts. + if (Fn->isDeclaration()) + for (Function::arg_iterator AI = Fn->arg_begin(), + AE = Fn->arg_end(); AI != AE; ++AI) + AI->setName(""); + } + } else if (Conflict) { + // We have two globals with the same name and different types. + // Previously, this was permitted because the symbol table had + // "type planes" and names only needed to be distinct within a + // type plane. After PR411 was fixed, this is no loner the case. + // To resolve this we must rename one of the two. + if (Conflict->hasInternalLinkage()) { + // We can safely rename the Conflict. + RenameMapKey Key = + makeRenameMapKey(Conflict->getName(), Conflict->getType(), + CurModule.NamedValueSigns[Conflict->getName()]); + Conflict->setName(makeNameUnique(Conflict->getName())); + CurModule.RenameMap[Key] = Conflict->getName(); + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); + } else { + // We can't quietly rename either of these things, but we must + // rename one of them. Only if the function's linkage is internal can + // we forgo a warning message about the renamed function. + std::string NewName = makeNameUnique(FunctionName); + if (CurFun.Linkage != GlobalValue::InternalLinkage) { + warning("Renaming function '" + FunctionName + "' as '" + NewName + + "' may cause linkage errors"); + } + // Elect to rename the thing we're now defining. + Fn = new Function(FT, CurFun.Linkage, NewName, M); + InsertValue(Fn, CurModule.Values); + RenameMapKey Key = makeRenameMapKey(FunctionName, PFT, ID.S); + CurModule.RenameMap[Key] = NewName; + } + } else { + // There's no conflict, just define the function + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); + } + } else { + // There's no conflict, just define the function + Fn = new Function(FT, CurFun.Linkage, FunctionName, M); + InsertValue(Fn, CurModule.Values); } - delete $3; - delete $5; - delete $7; - delete $8; - $$ = $1; - }; -BEGIN : BEGINTOK { $$ = new std::string("{"); delete $1; } - | '{' { $$ = new std::string ("{"); } -FunctionHeader - : OptLinkage FunctionHeaderH BEGIN { - *O << "define "; - if (!$1->empty()) { - *O << *$1 << ' '; + 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); } - *O << *$2 << ' ' << *$3 << '\n'; - delete $1; delete $2; delete $3; - $$ = 0; + Fn->setCallingConv(upgradeCallingConv($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.PAT->get() == Type::VoidTy && + $5->back().second == 0 && "Not a varargs marker"); + delete $5->back().first.PAT; + $5->pop_back(); // Delete the last entry + } + Function::arg_iterator ArgIt = Fn->arg_begin(); + Function::arg_iterator ArgEnd = Fn->arg_end(); + std::vector >::iterator I = $5->begin(); + std::vector >::iterator E = $5->end(); + for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) { + delete I->first.PAT; // Delete the typeholder... + ValueInfo VI; VI.V = ArgIt; VI.S.copy(I->first.S); + setValueName(VI, I->second); // Insert arg into symtab... + InsertValue(ArgIt); + } + delete $5; // We're now done with the argument list + } + lastCallingConv = OldCallingConv::C; + } + ; + +BEGIN + : BEGINTOK | '{' // Allow BEGIN or '{' to start a function + ; + +FunctionHeader + : OptLinkage { CurFun.Linkage = $1; } FunctionHeaderH BEGIN { + $$ = CurFun.CurrentFunction; + + // Make sure that we keep track of the linkage type even if there was a + // previous "declare". + $$->setLinkage($1); } ; -END : ENDTOK { $$ = new std::string("}"); delete $1; } - | '}' { $$ = new std::string("}"); }; +END + : ENDTOK | '}' // Allow end of '}' to end a function + ; -Function : FunctionHeader BasicBlockList END { - if ($2) - *O << *$2; - *O << *$3 << "\n\n"; - delete $1; delete $2; delete $3; - $$ = 0; -}; +Function + : BasicBlockList END { + $$ = $1; + }; FnDeclareLinkage - : /*default*/ { $$ = new std::string(); } - | DLLIMPORT - | EXTERN_WEAK + : /*default*/ { $$ = GlobalValue::ExternalLinkage; } + | DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; } + | EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; } ; FunctionProto - : DECLARE FnDeclareLinkage FunctionHeaderH { - if (!$2->empty()) - *$1 += " " + *$2; - *$1 += " " + *$3; - delete $2; - delete $3; - $$ = $1; - }; + : DECLARE { CurFun.isDeclare = true; } + FnDeclareLinkage { CurFun.Linkage = $3; } FunctionHeaderH { + $$ = CurFun.CurrentFunction; + CurFun.FunctionDone(); + + } + ; //===----------------------------------------------------------------------===// // Rules to match Basic Blocks //===----------------------------------------------------------------------===// -OptSideEffect : /* empty */ { $$ = new std::string(); } - | SIDEEFFECT; +OptSideEffect + : /* empty */ { $$ = false; } + | SIDEEFFECT { $$ = true; } + ; ConstValueRef - : ESINT64VAL | EUINT64VAL | FPVAL | TRUETOK | FALSETOK | NULL_TOK | UNDEF - | ZEROINITIALIZER - | '<' ConstVector '>' { - $2->insert(0, "<"); - *$2 += ">"; - $$ = $2; + // A reference to a direct constant + : ESINT64VAL { $$ = ValID::create($1); } + | EUINT64VAL { $$ = ValID::create($1); } + | FPVAL { $$ = ValID::create($1); } + | TRUETOK { + $$ = ValID::create(ConstantInt::get(Type::Int1Ty, true)); + $$.S.makeUnsigned(); + } + | FALSETOK { + $$ = ValID::create(ConstantInt::get(Type::Int1Ty, false)); + $$.S.makeUnsigned(); + } + | NULL_TOK { $$ = ValID::createNull(); } + | UNDEF { $$ = ValID::createUndef(); } + | ZEROINITIALIZER { $$ = ValID::createZeroInit(); } + | '<' ConstVector '>' { // Nonempty unsized packed vector + const Type *ETy = (*$2)[0].C->getType(); + int NumElements = $2->size(); + VectorType* pt = VectorType::get(ETy, NumElements); + $$.S.makeComposite((*$2)[0].S); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, $$.S)); + + // Verify all elements are correct type! + std::vector Elems; + for (unsigned i = 0; i < $2->size(); i++) { + Constant *C = (*$2)[i].C; + const Type *CTy = C->getType(); + if (ETy != CTy) + error("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '" + + CTy->getDescription() + "'"); + Elems.push_back(C); + } + $$ = ValID::create(ConstantVector::get(pt, Elems)); + delete PTy; delete $2; + } + | ConstExpr { + $$ = ValID::create($1.C); + $$.S.copy($1.S); } - | ConstExpr | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT { - if (!$2->empty()) { - *$1 += " " + *$2; - } - *$1 += " " + *$3 + ", " + *$5; - delete $2; delete $3; delete $5; - $$ = $1; - }; + char *End = UnEscapeLexed($3, true); + std::string AsmStr = std::string($3, End); + End = UnEscapeLexed($5, true); + std::string Constraints = std::string($5, End); + $$ = ValID::createInlineAsm(AsmStr, Constraints, $2); + free($3); + free($5); + } + ; -SymbolicValueRef : IntVal | Name ; +// SymbolicValueRef - Reference to one of two ways of symbolically refering to // another value. +// +SymbolicValueRef + : INTVAL { $$ = ValID::create($1); $$.S.makeSignless(); } + | Name { $$ = ValID::create($1); $$.S.makeSignless(); } + ; // ValueRef - A reference to a definition... either constant or symbolic ValueRef - : SymbolicValueRef { - $$.val = $1; - $$.constant = false; - $$.type = 0; - } - | ConstValueRef { - $$.val = $1; - $$.constant = true; - $$.type = 0; - } + : SymbolicValueRef | ConstValueRef ; + // ResolvedVal - a 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 { - $1 = $1->resolve(); - std::string Name = getUniqueName($2.val, $1); - $$ = $2; - delete $$.val; - $$.val = new std::string($1->getNewTy() + " " + Name); - $$.type = $1; - }; +ResolvedVal + : Types ValueRef { + const Type *Ty = $1.PAT->get(); + $2.S.copy($1.S); + $$.V = getVal(Ty, $2); + $$.S.copy($1.S); + delete $1.PAT; + } + ; -BasicBlockList : BasicBlockList BasicBlock { - $$ = 0; +BasicBlockList + : BasicBlockList BasicBlock { + $$ = $1; } - | BasicBlock { // Do not allow functions with 0 basic blocks - $$ = 0; + | FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks + $$ = $1; }; // Basic blocks are terminated by branching instructions: // br, br/cc, switch, ret // -BasicBlock : InstructionList BBTerminatorInst { - $$ = 0; - }; +BasicBlock + : InstructionList OptAssign BBTerminatorInst { + ValueInfo VI; VI.V = $3.TI; VI.S.copy($3.S); + setValueName(VI, $2); + InsertValue($3.TI); + $1->getInstList().push_back($3.TI); + InsertValue($1); + $$ = $1; + } + ; -InstructionList : InstructionList Inst { - *O << " " << *$2 << '\n'; - delete $2; - $$ = 0; +InstructionList + : InstructionList Inst { + if ($2.I) + $1->getInstList().push_back($2.I); + $$ = $1; } | /* empty */ { - $$ = 0; + $$ = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++),true); + // Make sure to move the basic block to the correct location in the + // function, instead of leaving it inserted wherever it was first + // referenced. + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, $$); } | LABELSTR { - *O << *$1 << '\n'; - delete $1; - $$ = 0; - }; + $$ = CurBB = getBBVal(ValID::create($1), true); + // Make sure to move the basic block to the correct location in the + // function, instead of leaving it inserted wherever it was first + // referenced. + Function::BasicBlockListType &BBL = + CurFun.CurrentFunction->getBasicBlockList(); + BBL.splice(BBL.end(), BBL, $$); + } + ; -Unwind : UNWIND | EXCEPT { $$ = $1; *$$ = "unwind"; } +Unwind : UNWIND | EXCEPT; -BBTerminatorInst : RET ResolvedVal { // Return with a result... - *O << " " << *$1 << ' ' << *$2.val << '\n'; - delete $1; $2.destroy(); - $$ = 0; +BBTerminatorInst + : RET ResolvedVal { // Return with a result... + $$.TI = new ReturnInst($2.V); + $$.S.makeSignless(); } | RET VOID { // Return with no result... - *O << " " << *$1 << ' ' << $2->getNewTy() << '\n'; - delete $1; - $$ = 0; + $$.TI = new ReturnInst(); + $$.S.makeSignless(); } | BR LABEL ValueRef { // Unconditional Branch... - *O << " " << *$1 << ' ' << $2->getNewTy() << ' ' << *$3.val << '\n'; - delete $1; $3.destroy(); - $$ = 0; + BasicBlock* tmpBB = getBBVal($3); + $$.TI = new BranchInst(tmpBB); + $$.S.makeSignless(); } // Conditional Branch... | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { - std::string Name = getUniqueName($3.val, $2); - *O << " " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " - << $5->getNewTy() << ' ' << *$6.val << ", " << $8->getNewTy() << ' ' - << *$9.val << '\n'; - delete $1; $3.destroy(); $6.destroy(); $9.destroy(); - $$ = 0; + $6.S.makeSignless(); + $9.S.makeSignless(); + BasicBlock* tmpBBA = getBBVal($6); + BasicBlock* tmpBBB = getBBVal($9); + $3.S.makeUnsigned(); + Value* tmpVal = getVal(Type::Int1Ty, $3); + $$.TI = new BranchInst(tmpBBA, tmpBBB, tmpVal); + $$.S.makeSignless(); } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' { - std::string Name = getUniqueName($3.val, $2); - *O << " " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " - << $5->getNewTy() << ' ' << *$6.val << " [" << *$8 << " ]\n"; - delete $1; $3.destroy(); $6.destroy(); + $3.S.copy($2.S); + Value* tmpVal = getVal($2.T, $3); + $6.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($6); + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size()); + $$.TI = S; + $$.S.makeSignless(); + std::vector >::iterator I = $8->begin(), + E = $8->end(); + for (; I != E; ++I) { + if (ConstantInt *CI = dyn_cast(I->first)) + S->addCase(CI, I->second); + else + error("Switch case is constant, but not a simple integer"); + } delete $8; - $$ = 0; } | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' { - std::string Name = getUniqueName($3.val, $2); - *O << " " << *$1 << ' ' << $2->getNewTy() << ' ' << Name << ", " - << $5->getNewTy() << ' ' << *$6.val << "[]\n"; - delete $1; $3.destroy(); $6.destroy(); - $$ = 0; - } - | OptAssign INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')' + $3.S.copy($2.S); + Value* tmpVal = getVal($2.T, $3); + $6.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($6); + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0); + $$.TI = S; + $$.S.makeSignless(); + } + | INVOKE OptCallingConv TypesV ValueRef '(' ValueRefListE ')' TO LABEL ValueRef Unwind LABEL ValueRef { - const TypeInfo* ResTy = getFunctionReturnType($4); - *O << " "; - if (!$1->empty()) { - std::string Name = getUniqueName($1, ResTy); - *O << Name << " = "; - } - *O << *$2 << ' ' << *$3 << ' ' << $4->getNewTy() << ' ' << *$5.val << " ("; - for (unsigned i = 0; i < $7->size(); ++i) { - ValueInfo& VI = (*$7)[i]; - *O << *VI.val; - if (i+1 < $7->size()) - *O << ", "; - VI.destroy(); - } - *O << ") " << *$9 << ' ' << $10->getNewTy() << ' ' << *$11.val << ' ' - << *$12 << ' ' << $13->getNewTy() << ' ' << *$14.val << '\n'; - delete $1; delete $2; delete $3; $5.destroy(); delete $7; - delete $9; $11.destroy(); delete $12; $14.destroy(); - $$ = 0; + const PointerType *PFTy; + const FunctionType *Ty; + Signedness FTySign; + + if (!(PFTy = dyn_cast($3.PAT->get())) || + !(Ty = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + FTySign.makeComposite($3.S); + if ($6) { + for (std::vector::iterator I = $6->begin(), E = $6->end(); + I != E; ++I) { + ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } + } + ParamAttrsList *PAL = 0; + if ($2 == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; + if (isVarArg) ParamTypes.pop_back(); + Ty = FunctionType::get($3.PAT->get(), ParamTypes, isVarArg, PAL); + PFTy = PointerType::get(Ty); + $$.S.copy($3.S); + } else { + FTySign = $3.S; + // Get the signedness of the result type. $3 is the pointer to the + // function type so we get the 0th element to extract the function type, + // and then the 0th element again to get the result type. + $$.S.copy($3.S.get(0).get(0)); + } + + $4.S.makeComposite(FTySign); + Value *V = getVal(PFTy, $4); // Get the function we're calling... + BasicBlock *Normal = getBBVal($10); + BasicBlock *Except = getBBVal($13); + + // Create the call node... + if (!$6) { // Has no arguments? + std::vector Args; + $$.TI = new InvokeInst(V, Normal, Except, Args.begin(), Args.end()); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly! + // + FunctionType::param_iterator I = Ty->param_begin(); + FunctionType::param_iterator E = Ty->param_end(); + std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); + + std::vector Args; + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if ((*ArgI).V->getType() != *I) + error("Parameter " +(*ArgI).V->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back((*ArgI).V); + } + + if (I != E || (ArgI != ArgE && !Ty->isVarArg())) + error("Invalid number of parameters detected"); + + $$.TI = new InvokeInst(V, Normal, Except, Args.begin(), Args.end()); + } + cast($$.TI)->setCallingConv(upgradeCallingConv($2)); + delete $3.PAT; + delete $6; + lastCallingConv = OldCallingConv::C; } | Unwind { - *O << " " << *$1 << '\n'; - delete $1; - $$ = 0; + $$.TI = new UnwindInst(); + $$.S.makeSignless(); } | UNREACHABLE { - *O << " " << *$1 << '\n'; - delete $1; - $$ = 0; - }; + $$.TI = new UnreachableInst(); + $$.S.makeSignless(); + } + ; -JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { - *$1 += " " + $2->getNewTy() + " " + *$3 + ", " + $5->getNewTy() + " " + - *$6.val; - delete $3; $6.destroy(); +JumpTable + : JumpTable IntType ConstValueRef ',' LABEL ValueRef { $$ = $1; + $3.S.copy($2.S); + Constant *V = cast(getExistingValue($2.T, $3)); + + if (V == 0) + error("May only switch on a constant pool value"); + + $6.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($6); + $$->push_back(std::make_pair(V, tmpBB)); } | IntType ConstValueRef ',' LABEL ValueRef { - $2->insert(0, $1->getNewTy() + " " ); - *$2 += ", " + $4->getNewTy() + " " + *$5.val; - $5.destroy(); - $$ = $2; - }; + $$ = new std::vector >(); + $2.S.copy($1.S); + Constant *V = cast(getExistingValue($1.T, $2)); + + if (V == 0) + error("May only switch on a constant pool value"); + + $5.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($5); + $$->push_back(std::make_pair(V, tmpBB)); + } + ; Inst : OptAssign InstVal { - if (!$1->empty()) { - // Get a unique name for this value, based on its type. - std::string Name = getUniqueName($1, $2.type); - *$1 = Name + " = "; - if (deleteUselessCastFlag && *deleteUselessCastName == Name) { - // don't actually delete it, just comment it out - $1->insert(0, "; USELSS BITCAST: "); - delete deleteUselessCastName; - } + bool omit = false; + if ($1) + if (BitCastInst *BCI = dyn_cast($2.I)) + if (BCI->getSrcTy() == BCI->getDestTy() && + BCI->getOperand(0)->getName() == $1) + // This is a useless bit cast causing a name redefinition. It is + // a bit cast from a type to the same type of an operand with the + // same name as the name we would give this instruction. Since this + // instruction results in no code generation, it is safe to omit + // the instruction. This situation can occur because of collapsed + // type planes. For example: + // %X = add int %Y, %Z + // %X = cast int %Y to uint + // After upgrade, this looks like: + // %X = add i32 %Y, %Z + // %X = bitcast i32 to i32 + // The bitcast is clearly useless so we omit it. + omit = true; + if (omit) { + $$.I = 0; + $$.S.makeSignless(); + } else { + ValueInfo VI; VI.V = $2.I; VI.S.copy($2.S); + setValueName(VI, $1); + InsertValue($2.I); + $$ = $2; } - *$1 += *$2.val; - $2.destroy(); - deleteUselessCastFlag = false; - $$ = $1; }; -PHIList - : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes - std::string Name = getUniqueName($3.val, $1); - Name.insert(0, $1->getNewTy() + "["); - Name += "," + *$5.val + "]"; - $$.val = new std::string(Name); - $$.type = $1; - $3.destroy(); $5.destroy(); +PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes + $$.P = new std::list >(); + $$.S.copy($1.S); + $3.S.copy($1.S); + Value* tmpVal = getVal($1.PAT->get(), $3); + $5.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($5); + $$.P->push_back(std::make_pair(tmpVal, tmpBB)); + delete $1.PAT; } | PHIList ',' '[' ValueRef ',' ValueRef ']' { - std::string Name = getUniqueName($4.val, $1.type); - *$1.val += ", [" + Name + "," + *$6.val + "]"; - $4.destroy(); $6.destroy(); $$ = $1; - }; - + $4.S.copy($1.S); + Value* tmpVal = getVal($1.P->front().first->getType(), $4); + $6.S.makeSignless(); + BasicBlock* tmpBB = getBBVal($6); + $1.P->push_back(std::make_pair(tmpVal, tmpBB)); + } + ; -ValueRefList - : ResolvedVal { - $$ = new ValueList(); +ValueRefList : ResolvedVal { // Used for call statements, and memory insts... + $$ = new std::vector(); $$->push_back($1); } | ValueRefList ',' ResolvedVal { $$ = $1; - $$->push_back($3); + $1->push_back($3); }; // ValueRefListE - Just like ValueRefList, except that it may also be empty! ValueRefListE - : ValueRefList { $$ = $1; } - | /*empty*/ { $$ = new ValueList(); } + : ValueRefList + | /*empty*/ { $$ = 0; } ; OptTailCall : TAIL CALL { - *$1 += " " + *$2; - delete $2; - $$ = $1; + $$ = true; + } + | CALL { + $$ = false; } - | CALL ; -InstVal : ArithmeticOps Types ValueRef ',' ValueRef { - const char* op = getDivRemOpcode(*$1, $2); - std::string Name1 = getUniqueName($3.val, $2); - std::string Name2 = getUniqueName($5.val, $2); - $$.val = new std::string(op); - *$$.val += " " + $2->getNewTy() + " " + Name1 + ", " + Name2; - $$.type = $2; - delete $1; $3.destroy(); $5.destroy(); +InstVal + : ArithmeticOps Types ValueRef ',' ValueRef { + $3.S.copy($2.S); + $5.S.copy($2.S); + const Type* Ty = $2.PAT->get(); + if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty)) + error("Arithmetic operator requires integer, FP, or packed operands"); + if (isa(Ty) && + ($1 == URemOp || $1 == SRemOp || $1 == FRemOp || $1 == RemOp)) + error("Remainder not supported on vector types"); + // Upgrade the opcode from obsolete versions before we do anything with it. + Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S); + Value* val1 = getVal(Ty, $3); + Value* val2 = getVal(Ty, $5); + $$.I = BinaryOperator::create(Opcode, val1, val2); + if ($$.I == 0) + error("binary operator returned null"); + $$.S.copy($2.S); + delete $2.PAT; } | LogicalOps Types ValueRef ',' ValueRef { - std::string Name1 = getUniqueName($3.val, $2); - std::string Name2 = getUniqueName($5.val, $2); - *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2; - $$.val = $1; - $$.type = $2; - $3.destroy(); $5.destroy(); + $3.S.copy($2.S); + $5.S.copy($2.S); + const Type *Ty = $2.PAT->get(); + if (!Ty->isInteger()) { + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) + error("Logical operator requires integral operands"); + } + Instruction::BinaryOps Opcode = getBinaryOp($1, Ty, $2.S); + Value* tmpVal1 = getVal(Ty, $3); + Value* tmpVal2 = getVal(Ty, $5); + $$.I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2); + if ($$.I == 0) + error("binary operator returned null"); + $$.S.copy($2.S); + delete $2.PAT; } | SetCondOps Types ValueRef ',' ValueRef { - std::string Name1 = getUniqueName($3.val, $2); - std::string Name2 = getUniqueName($5.val, $2); - *$1 = getCompareOp(*$1, $2); - *$1 += " " + $2->getNewTy() + " " + Name1 + ", " + Name2; - $$.val = $1; - $$.type = TypeInfo::get("bool",BoolTy); - $3.destroy(); $5.destroy(); + $3.S.copy($2.S); + $5.S.copy($2.S); + const Type* Ty = $2.PAT->get(); + if(isa(Ty)) + error("VectorTypes currently not supported in setcc instructions"); + unsigned short pred; + Instruction::OtherOps Opcode = getCompareOp($1, pred, Ty, $2.S); + Value* tmpVal1 = getVal(Ty, $3); + Value* tmpVal2 = getVal(Ty, $5); + $$.I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2); + if ($$.I == 0) + error("binary operator returned null"); + $$.S.makeUnsigned(); + delete $2.PAT; } | ICMP IPredicates Types ValueRef ',' ValueRef { - std::string Name1 = getUniqueName($4.val, $3); - std::string Name2 = getUniqueName($6.val, $3); - *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2; - $$.val = $1; - $$.type = TypeInfo::get("bool",BoolTy); - delete $2; $4.destroy(); $6.destroy(); + $4.S.copy($3.S); + $6.S.copy($3.S); + const Type *Ty = $3.PAT->get(); + if (isa(Ty)) + error("VectorTypes currently not supported in icmp instructions"); + else if (!Ty->isInteger() && !isa(Ty)) + error("icmp requires integer or pointer typed operands"); + Value* tmpVal1 = getVal(Ty, $4); + Value* tmpVal2 = getVal(Ty, $6); + $$.I = new ICmpInst($2, tmpVal1, tmpVal2); + $$.S.makeUnsigned(); + delete $3.PAT; } | FCMP FPredicates Types ValueRef ',' ValueRef { - std::string Name1 = getUniqueName($4.val, $3); - std::string Name2 = getUniqueName($6.val, $3); - *$1 += " " + *$2 + " " + $3->getNewTy() + " " + Name1 + "," + Name2; - $$.val = $1; - $$.type = TypeInfo::get("bool",BoolTy); - delete $2; $4.destroy(); $6.destroy(); + $4.S.copy($3.S); + $6.S.copy($3.S); + const Type *Ty = $3.PAT->get(); + if (isa(Ty)) + error("VectorTypes currently not supported in fcmp instructions"); + else if (!Ty->isFloatingPoint()) + error("fcmp instruction requires floating point operands"); + Value* tmpVal1 = getVal(Ty, $4); + Value* tmpVal2 = getVal(Ty, $6); + $$.I = new FCmpInst($2, tmpVal1, tmpVal2); + $$.S.makeUnsigned(); + delete $3.PAT; } | NOT ResolvedVal { - $$ = $2; - $$.val->insert(0, *$1 + " "); - delete $1; + warning("Use of obsolete 'not' instruction: Replacing with 'xor"); + const Type *Ty = $2.V->getType(); + Value *Ones = ConstantInt::getAllOnesValue(Ty); + if (Ones == 0) + error("Expected integral type for not instruction"); + $$.I = BinaryOperator::create(Instruction::Xor, $2.V, Ones); + if ($$.I == 0) + error("Could not create a xor instruction"); + $$.S.copy($2.S); } | ShiftOps ResolvedVal ',' ResolvedVal { - const char* shiftop = $1->c_str(); - if (*$1 == "shr") - shiftop = ($2.type->isUnsigned()) ? "lshr" : "ashr"; - $$.val = new std::string(shiftop); - *$$.val += " " + *$2.val + ", " + *$4.val; - $$.type = $2.type; - delete $1; $2.destroy(); $4.destroy(); + if (!$4.V->getType()->isInteger() || + cast($4.V->getType())->getBitWidth() != 8) + error("Shift amount must be int8"); + const Type* Ty = $2.V->getType(); + if (!Ty->isInteger()) + error("Shift constant expression requires integer operand"); + Value* ShiftAmt = 0; + if (cast(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth()) + if (Constant *C = dyn_cast($4.V)) + ShiftAmt = ConstantExpr::getZExt(C, Ty); + else + ShiftAmt = new ZExtInst($4.V, Ty, makeNameUnique("shift"), CurBB); + else + ShiftAmt = $4.V; + $$.I = BinaryOperator::create(getBinaryOp($1, Ty, $2.S), $2.V, ShiftAmt); + $$.S.copy($2.S); } | CastOps ResolvedVal TO Types { - std::string source = *$2.val; - const TypeInfo* SrcTy = $2.type->resolve(); - const TypeInfo* DstTy = $4->resolve(); - $$.val = new std::string(); - $$.type = DstTy; - if (*$1 == "cast") { - *$$.val += getCastUpgrade(source, SrcTy, DstTy, false); - } else { - *$$.val += *$1 + " " + source + " to " + DstTy->getNewTy(); - } - // Check to see if this is a useless cast of a value to the same name - // and the same type. Such casts will probably cause redefinition errors - // when assembled and perform no code gen action so just remove them. - if (*$1 == "cast" || *$1 == "bitcast") - if (SrcTy->isInteger() && DstTy->isInteger() && - SrcTy->getBitWidth() == DstTy->getBitWidth()) { - deleteUselessCastFlag = true; // Flag the "Inst" rule - deleteUselessCastName = new std::string(*$2.val); // save the name - size_t pos = deleteUselessCastName->find_first_of("%\"",0); - if (pos != std::string::npos) { - // remove the type portion before val - deleteUselessCastName->erase(0, pos); - } - } - delete $1; $2.destroy(); - delete $3; + const Type *DstTy = $4.PAT->get(); + if (!DstTy->isFirstClassType()) + error("cast instruction to a non-primitive type: '" + + DstTy->getDescription() + "'"); + $$.I = cast(getCast($1, $2.V, $2.S, DstTy, $4.S, true)); + $$.S.copy($4.S); + delete $4.PAT; } | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal { - *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val; - $$.val = $1; - $$.type = $4.type; - $2.destroy(); $4.destroy(); $6.destroy(); + if (!$2.V->getType()->isInteger() || + cast($2.V->getType())->getBitWidth() != 1) + error("select condition must be bool"); + if ($4.V->getType() != $6.V->getType()) + error("select value types should match"); + $$.I = new SelectInst($2.V, $4.V, $6.V); + $$.S.copy($4.S); } | VAARG ResolvedVal ',' Types { - *$1 += " " + *$2.val + ", " + $4->getNewTy(); - $$.val = $1; - $$.type = $4; - $2.destroy(); + const Type *Ty = $4.PAT->get(); + NewVarArgs = true; + $$.I = new VAArgInst($2.V, Ty); + $$.S.copy($4.S); + delete $4.PAT; + } + | VAARG_old ResolvedVal ',' Types { + const Type* ArgTy = $2.V->getType(); + const Type* DstTy = $4.PAT->get(); + ObsoleteVarArgs = true; + Function* NF = cast(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.V); + CurBB->getInstList().push_back(bar); + CurBB->getInstList().push_back(new StoreInst(bar, foo)); + $$.I = new VAArgInst(foo, DstTy); + $$.S.copy($4.S); + delete $4.PAT; + } + | VANEXT_old ResolvedVal ',' Types { + const Type* ArgTy = $2.V->getType(); + const Type* DstTy = $4.PAT->get(); + ObsoleteVarArgs = true; + Function* NF = cast(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.V); + CurBB->getInstList().push_back(bar); + CurBB->getInstList().push_back(new StoreInst(bar, foo)); + Instruction* tmp = new VAArgInst(foo, DstTy); + CurBB->getInstList().push_back(tmp); + $$.I = new LoadInst(foo); + $$.S.copy($4.S); + delete $4.PAT; } | EXTRACTELEMENT ResolvedVal ',' ResolvedVal { - *$1 += " " + *$2.val + ", " + *$4.val; - $$.val = $1; - $2.type = $2.type->resolve();; - $$.type = $2.type->getElementType(); - $2.destroy(); $4.destroy(); + if (!ExtractElementInst::isValidOperands($2.V, $4.V)) + error("Invalid extractelement operands"); + $$.I = new ExtractElementInst($2.V, $4.V); + $$.S.copy($2.S.get(0)); } | INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal { - *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val; - $$.val = $1; - $$.type = $2.type; - $2.destroy(); $4.destroy(); $6.destroy(); + if (!InsertElementInst::isValidOperands($2.V, $4.V, $6.V)) + error("Invalid insertelement operands"); + $$.I = new InsertElementInst($2.V, $4.V, $6.V); + $$.S.copy($2.S); } | SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal { - *$1 += " " + *$2.val + ", " + *$4.val + ", " + *$6.val; - $$.val = $1; - $$.type = $2.type; - $2.destroy(); $4.destroy(); $6.destroy(); + if (!ShuffleVectorInst::isValidOperands($2.V, $4.V, $6.V)) + error("Invalid shufflevector operands"); + $$.I = new ShuffleVectorInst($2.V, $4.V, $6.V); + $$.S.copy($2.S); } | PHI_TOK PHIList { - *$1 += " " + *$2.val; - $$.val = $1; - $$.type = $2.type; - delete $2.val; - } - | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { - if (!$2->empty()) - *$1 += " " + *$2; - if (!$1->empty()) - *$1 += " "; - *$1 += $3->getNewTy() + " " + *$4.val + "("; - for (unsigned i = 0; i < $6->size(); ++i) { - ValueInfo& VI = (*$6)[i]; - *$1 += *VI.val; - if (i+1 < $6->size()) - *$1 += ", "; - VI.destroy(); - } - *$1 += ")"; - $$.val = $1; - $$.type = getFunctionReturnType($3); - delete $2; $4.destroy(); delete $6; - } - | MemoryInst ; + const Type *Ty = $2.P->front().first->getType(); + if (!Ty->isFirstClassType()) + error("PHI node operands must be of first class type"); + PHINode *PHI = new PHINode(Ty); + PHI->reserveOperandSpace($2.P->size()); + while ($2.P->begin() != $2.P->end()) { + if ($2.P->front().first->getType() != Ty) + error("All elements of a PHI node must be of the same type"); + PHI->addIncoming($2.P->front().first, $2.P->front().second); + $2.P->pop_front(); + } + $$.I = PHI; + $$.S.copy($2.S); + delete $2.P; // Free the list... + } + | OptTailCall OptCallingConv TypesV ValueRef '(' ValueRefListE ')' { + // Handle the short call syntax + const PointerType *PFTy; + const FunctionType *FTy; + Signedness FTySign; + if (!(PFTy = dyn_cast($3.PAT->get())) || + !(FTy = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + FTySign.makeComposite($3.S); + if ($6) { + for (std::vector::iterator I = $6->begin(), E = $6->end(); + I != E; ++I) { + ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } + } + + bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; + if (isVarArg) ParamTypes.pop_back(); + + const Type *RetTy = $3.PAT->get(); + if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) + error("Functions cannot return aggregate types"); + + // Deal with CSRetCC + ParamAttrsList *PAL = 0; + if ($2 == OldCallingConv::CSRet) { + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); + } + + FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, PAL); + PFTy = PointerType::get(FTy); + $$.S.copy($3.S); + } else { + FTySign = $3.S; + // Get the signedness of the result type. $3 is the pointer to the + // function type so we get the 0th element to extract the function type, + // and then the 0th element again to get the result type. + $$.S.copy($3.S.get(0).get(0)); + } + $4.S.makeComposite(FTySign); + + // First upgrade any intrinsic calls. + std::vector Args; + if ($6) + for (unsigned i = 0, e = $6->size(); i < e; ++i) + Args.push_back((*$6)[i].V); + Instruction *Inst = upgradeIntrinsicCall(FTy->getReturnType(), $4, Args); + + // If we got an upgraded intrinsic + if (Inst) { + $$.I = Inst; + } else { + // Get the function we're calling + Value *V = getVal(PFTy, $4); + + // Check the argument values match + if (!$6) { // Has no arguments? + // Make sure no arguments is a good thing! + if (FTy->getNumParams() != 0) + error("No arguments passed to a function that expects arguments"); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly! + // + FunctionType::param_iterator I = FTy->param_begin(); + FunctionType::param_iterator E = FTy->param_end(); + std::vector::iterator ArgI = $6->begin(), ArgE = $6->end(); + + for (; ArgI != ArgE && I != E; ++ArgI, ++I) + if ((*ArgI).V->getType() != *I) + error("Parameter " +(*ArgI).V->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + + if (I != E || (ArgI != ArgE && !FTy->isVarArg())) + error("Invalid number of parameters detected"); + } + + // Create the call instruction + CallInst *CI = new CallInst(V, Args.begin(), Args.end()); + CI->setTailCall($1); + CI->setCallingConv(upgradeCallingConv($2)); + $$.I = CI; + } + delete $3.PAT; + delete $6; + lastCallingConv = OldCallingConv::C; + } + | MemoryInst { + $$ = $1; + } + ; // IndexList - List of indices for GEP based instructions... IndexList - : ',' ValueRefList { $$ = $2; } - | /* empty */ { $$ = new ValueList(); } + : ',' ValueRefList { $$ = $2; } + | /* empty */ { $$ = new std::vector(); } ; OptVolatile - : VOLATILE - | /* empty */ { $$ = new std::string(); } + : VOLATILE { $$ = true; } + | /* empty */ { $$ = false; } ; -MemoryInst : MALLOC Types OptCAlign { - *$1 += " " + $2->getNewTy(); - if (!$3->empty()) - *$1 += " " + *$3; - $$.val = $1; - $$.type = $2->getPointerType(); - delete $3; +MemoryInst + : MALLOC Types OptCAlign { + const Type *Ty = $2.PAT->get(); + $$.S.makeComposite($2.S); + $$.I = new MallocInst(Ty, 0, $3); + delete $2.PAT; } | MALLOC Types ',' UINT ValueRef OptCAlign { - std::string Name = getUniqueName($5.val, $4); - *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name; - if (!$6->empty()) - *$1 += " " + *$6; - $$.val = $1; - $$.type = $2->getPointerType(); - $5.destroy(); delete $6; + const Type *Ty = $2.PAT->get(); + $5.S.makeUnsigned(); + $$.S.makeComposite($2.S); + $$.I = new MallocInst(Ty, getVal($4.T, $5), $6); + delete $2.PAT; } | ALLOCA Types OptCAlign { - *$1 += " " + $2->getNewTy(); - if (!$3->empty()) - *$1 += " " + *$3; - $$.val = $1; - $$.type = $2->getPointerType(); - delete $3; + const Type *Ty = $2.PAT->get(); + $$.S.makeComposite($2.S); + $$.I = new AllocaInst(Ty, 0, $3); + delete $2.PAT; } | ALLOCA Types ',' UINT ValueRef OptCAlign { - std::string Name = getUniqueName($5.val, $4); - *$1 += " " + $2->getNewTy() + ", " + $4->getNewTy() + " " + Name; - if (!$6->empty()) - *$1 += " " + *$6; - $$.val = $1; - $$.type = $2->getPointerType(); - $5.destroy(); delete $6; + const Type *Ty = $2.PAT->get(); + $5.S.makeUnsigned(); + $$.S.makeComposite($4.S); + $$.I = new AllocaInst(Ty, getVal($4.T, $5), $6); + delete $2.PAT; } | FREE ResolvedVal { - *$1 += " " + *$2.val; - $$.val = $1; - $$.type = TypeInfo::get("void", VoidTy); - $2.destroy(); + const Type *PTy = $2.V->getType(); + if (!isa(PTy)) + error("Trying to free nonpointer type '" + PTy->getDescription() + "'"); + $$.I = new FreeInst($2.V); + $$.S.makeSignless(); } | OptVolatile LOAD Types ValueRef { - std::string Name = getUniqueName($4.val, $3); - if (!$1->empty()) - *$1 += " "; - *$1 += *$2 + " " + $3->getNewTy() + " " + Name; - $$.val = $1; - $$.type = $3->getElementType(); - delete $2; $4.destroy(); + const Type* Ty = $3.PAT->get(); + $4.S.copy($3.S); + if (!isa(Ty)) + error("Can't load from nonpointer type: " + Ty->getDescription()); + if (!cast(Ty)->getElementType()->isFirstClassType()) + error("Can't load from pointer of non-first-class type: " + + Ty->getDescription()); + Value* tmpVal = getVal(Ty, $4); + $$.I = new LoadInst(tmpVal, "", $1); + $$.S.copy($3.S.get(0)); + delete $3.PAT; } | OptVolatile STORE ResolvedVal ',' Types ValueRef { - std::string Name = getUniqueName($6.val, $5); - if (!$1->empty()) - *$1 += " "; - *$1 += *$2 + " " + *$3.val + ", " + $5->getNewTy() + " " + Name; - $$.val = $1; - $$.type = TypeInfo::get("void", VoidTy); - delete $2; $3.destroy(); $6.destroy(); - } - | GETELEMENTPTR Types ValueRef IndexList { - std::string Name = getUniqueName($3.val, $2); - // Upgrade the indices - for (unsigned i = 0; i < $4->size(); ++i) { - ValueInfo& VI = (*$4)[i]; - if (VI.type->isUnsigned() && !VI.isConstant() && - VI.type->getBitWidth() < 64) { - *O << " %gep_upgrade" << unique << " = zext " << *VI.val - << " to i64\n"; - *VI.val = "i64 %gep_upgrade" + llvm::utostr(unique++); - VI.type = TypeInfo::get("i64",ULongTy); + $6.S.copy($5.S); + const PointerType *PTy = dyn_cast($5.PAT->get()); + if (!PTy) + error("Can't store to a nonpointer type: " + + $5.PAT->get()->getDescription()); + const Type *ElTy = PTy->getElementType(); + Value *StoreVal = $3.V; + Value* tmpVal = getVal(PTy, $6); + if (ElTy != $3.V->getType()) { + StoreVal = handleSRetFuncTypeMerge($3.V, ElTy); + if (!StoreVal) + error("Can't store '" + $3.V->getType()->getDescription() + + "' into space of type '" + ElTy->getDescription() + "'"); + else { + PTy = PointerType::get(StoreVal->getType()); + if (Constant *C = dyn_cast(tmpVal)) + tmpVal = ConstantExpr::getBitCast(C, PTy); + else + tmpVal = new BitCastInst(tmpVal, PTy, "upgrd.cast", CurBB); } } - *$1 += " " + $2->getNewTy() + " " + Name; - for (unsigned i = 0; i < $4->size(); ++i) { - ValueInfo& VI = (*$4)[i]; - *$1 += ", " + *VI.val; - } - $$.val = $1; - $$.type = getGEPIndexedType($2,$4); - $3.destroy(); delete $4; + $$.I = new StoreInst(StoreVal, tmpVal, $1); + $$.S.makeSignless(); + delete $5.PAT; + } + | GETELEMENTPTR Types ValueRef IndexList { + $3.S.copy($2.S); + const Type* Ty = $2.PAT->get(); + if (!isa(Ty)) + error("getelementptr insn requires pointer operand"); + + std::vector VIndices; + upgradeGEPInstIndices(Ty, $4, VIndices); + + Value* tmpVal = getVal(Ty, $3); + $$.I = new GetElementPtrInst(tmpVal, VIndices.begin(), VIndices.end()); + ValueInfo VI; VI.V = tmpVal; VI.S.copy($2.S); + $$.S.copy(getElementSign(VI, VIndices)); + delete $2.PAT; + delete $4; }; + %% int yyerror(const char *ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; - std::string errMsg = where + "error: " + std::string(ErrorMsg) + - " while reading "; - if (yychar == YYEMPTY || yychar == 0) - errMsg += "end-of-file."; - else - errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'"; + std::string errMsg = where + "error: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) + + "'."; std::cerr << "llvm-upgrade: " << errMsg << '\n'; - *O << "llvm-upgrade parse failed.\n"; + std::cout << "llvm-upgrade: parse failed.\n"; exit(1); } -static void warning(const std::string& ErrorMsg) { +void warning(const std::string& ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; - std::string errMsg = where + "warning: " + std::string(ErrorMsg) + - " while reading "; - if (yychar == YYEMPTY || yychar == 0) - errMsg += "end-of-file."; - else - errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'"; + std::string errMsg = where + "warning: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) + + "'."; std::cerr << "llvm-upgrade: " << errMsg << '\n'; } + +void error(const std::string& ErrorMsg, int LineNo) { + if (LineNo == -1) LineNo = Upgradelineno; + Upgradelineno = LineNo; + yyerror(ErrorMsg.c_str()); +} +