X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-upgrade%2FUpgradeParser.cpp.cvs;h=577d94daef24337e10ab756afe2acb16079deedb;hb=7eea8ff06dc8f058bddec924876188e59e0cc599;hp=e289939e2410a4341e9823e4035b01884a34113a;hpb=832254e1c2387c0cbeb0a820b8315fbe85cb003a;p=oota-llvm.git diff --git a/tools/llvm-upgrade/UpgradeParser.cpp.cvs b/tools/llvm-upgrade/UpgradeParser.cpp.cvs index e289939e241..577d94daef2 100644 --- a/tools/llvm-upgrade/UpgradeParser.cpp.cvs +++ b/tools/llvm-upgrade/UpgradeParser.cpp.cvs @@ -377,12 +377,14 @@ #include "llvm/InlineAsm.h" #include "llvm/Instructions.h" #include "llvm/Module.h" -#include "llvm/SymbolTable.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 @@ -420,13 +422,14 @@ 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::pair RenameMapKey; typedef std::map RenameMapType; static void @@ -437,7 +440,10 @@ static struct PerModuleInfo { Module *CurrentModule; std::map Values; // Module level numbered definitions std::map LateResolveValues; - std::vector Types; + std::vector Types; + std::vector TypeSigns; + std::map NamedTypeSigns; + std::map NamedValueSigns; std::map LateResolveTypes; static Module::Endianness Endian; static Module::PointerSize PointerSize; @@ -494,6 +500,9 @@ static struct PerModuleInfo { Values.clear(); // Clear out function local definitions Types.clear(); + TypeSigns.clear(); + NamedTypeSigns.clear(); + NamedValueSigns.clear(); CurrentModule = 0; } @@ -531,7 +540,6 @@ static struct PerFunctionInfo { std::map > BBForwardRefs; std::vector NumberedBlocks; RenameMapType RenameMap; - unsigned LastCC; unsigned NextBBNum; inline PerFunctionInfo() { @@ -568,6 +576,24 @@ static struct PerFunctionInfo { 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); +} + //===----------------------------------------------------------------------===// // Code to handle definitions of all the types @@ -593,7 +619,6 @@ static const Type *getType(const ValID &D, bool DoNotImprovise = false) { break; case ValID::NameVal: // Is it a named definition? if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) { - D.destroy(); // Free old strdup'd memory... return N; } break; @@ -608,7 +633,6 @@ static const Type *getType(const ValID &D, bool DoNotImprovise = false) { // 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() + "'"); @@ -626,7 +650,160 @@ static const Type *getType(const ValID &D, bool DoNotImprovise = false) { Type *Typ = OpaqueType::get(); CurModule.LateResolveTypes.insert(std::make_pair(D, Typ)); return Typ; - } +} + +/// 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; +} + +/// 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; +} + +/// 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; +} + +/// 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; +} + +/// 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; +} + +// 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; +} // getExistingValue - Look up the value specified by the provided type and // the provided ValID. If the value exists and has already been defined, return @@ -661,9 +838,8 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) { case ValID::NameVal: { // Is it a named definition? // Get the name out of the ID - std::string Name(D.Name); - Value* V = 0; - RenameMapKey Key = std::make_pair(Name, Ty); + 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); @@ -671,9 +847,12 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) { if (I != CurFun.RenameMap.end()) LookupName = I->second; else - LookupName = Name; - SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); - V = SymTab.lookup(Ty, LookupName); + 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); @@ -681,10 +860,13 @@ static Value *getExistingValue(const Type *Ty, const ValID &D) { if (I != CurModule.RenameMap.end()) LookupName = I->second; else - LookupName = Name; - V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName); + 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 == 0) + if (!V) return 0; D.destroy(); // Free old strdup'd memory... @@ -776,7 +958,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { // 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-1))); + std::make_pair(V, std::make_pair(ID, Upgradelineno))); if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); @@ -785,6 +967,14 @@ static Value *getVal(const Type *Ty, const ValID &ID) { 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. @@ -807,11 +997,19 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { break; case ValID::NameVal: // Is it a named definition? Name = ID.Name; - if (Value *N = CurFun.CurrentFunction-> - getValueSymbolTable().lookup(Type::LabelTy, Name)) { - if (N->getType() != Type::LabelTy) - error("Name '" + Name + "' does not refer to a BasicBlock"); - BB = cast(N); + 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 { + BB = cast(N); + } } break; } @@ -865,25 +1063,6 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) { // and back patchs after we are done. // -/// 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. -bool FuncTysDifferOnlyBySRet(const FunctionType *F1, - const FunctionType *F2) { - if (F1->getReturnType() != F2->getReturnType() || - F1->getNumParams() != F2->getNumParams() || - F1->getParamAttrs(0) != F2->getParamAttrs(0)) - return false; - unsigned SRetMask = ~unsigned(FunctionType::StructRetAttribute); - for (unsigned i = 0; i < F1->getNumParams(); ++i) { - if (F1->getParamType(i) != F2->getParamType(i) || - unsigned(F1->getParamAttrs(i+1)) & SRetMask != - unsigned(F2->getParamAttrs(i+1)) & SRetMask) - return false; - } - return true; -} - // ResolveDefinitions - If we could not resolve some defs at parsing // time (forward branches, phi functions for loops, etc...) resolve the // defs now... @@ -891,9 +1070,11 @@ bool FuncTysDifferOnlyBySRet(const FunctionType *F1, 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(); @@ -905,7 +1086,7 @@ ResolveDefinitions(std::map &LateResolvers, ValID &DID = PHI->second.first; - Value *TheRealValue = getExistingValue(LRI->first, DID); + Value *TheRealValue = getExistingValue(Ty, DID); if (TheRealValue) { V->replaceAllUsesWith(TheRealValue); delete V; @@ -916,26 +1097,10 @@ ResolveDefinitions(std::map &LateResolvers, InsertValue(V, *FutureLateResolvers); } else { if (DID.Type == ValID::NameVal) { - // 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. Detect this situation and insert a - // cast as necessary. - bool fixed = false; - if (const PointerType *PTy = dyn_cast(V->getType())) - if (const FunctionType *FTy = - dyn_cast(PTy->getElementType())) - if (Function *OtherF = - CurModule.CurrentModule->getNamedFunction(DID.getName())) - if (FuncTysDifferOnlyBySRet(FTy,OtherF->getFunctionType())) { - V->replaceAllUsesWith(ConstantExpr::getBitCast(OtherF, PTy)); - fixed = true; - } - if (!fixed) { - error("Reference to an invalid definition: '" +DID.getName()+ - "' of type '" + V->getType()->getDescription() + "'", - PHI->second.second); + 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 '" + @@ -949,31 +1114,38 @@ ResolveDefinitions(std::map &LateResolvers, LateResolvers.clear(); } -// ResolveTypeTo - A brand new type was just declared. This means that (if -// name is not null) things referencing Name can be resolved. Otherwise, things -// refering to the number can be resolved. Do this now. -// -static void ResolveTypeTo(char *Name, const Type *ToTy) { +/// 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()); + 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()) { - ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); + const Type *OldTy = I->second.get(); + ((DerivedType*)OldTy)->refineAbstractTypeTo(ToTy); CurModule.LateResolveTypes.erase(I); } } -/// @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; -} - /// 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. @@ -1029,12 +1201,12 @@ static inline bool TypeHasInteger(const Type *Ty) { // 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(Value *V, char *NameStr) { +static void setValueName(const ValueInfo &V, char *NameStr) { if (NameStr) { std::string Name(NameStr); // Copy string free(NameStr); // Free old string - if (V->getType() == Type::VoidTy) { + if (V.V->getType() == Type::VoidTy) { error("Can't assign name '" + Name + "' to value with void type"); return; } @@ -1042,26 +1214,18 @@ static void setValueName(Value *V, char *NameStr) { assert(inFunctionScope() && "Must be in function scope"); // Search the function's symbol table for an existing value of this name - Value* Existing = 0; - SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); - SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end(); - for ( ; PI != PE; ++PI) { - SymbolTable::value_const_iterator VI = PI->second.find(Name); - if (VI != PI->second.end()) { - Existing = VI->second; - break; - } - } + 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->getType() && + 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->getType()->getDescription() + "'"); + V.V->getType()->getDescription() + "'"); return; } // In LLVM 2.0 we don't allow names to be re-used for any values in a @@ -1075,13 +1239,13 @@ static void setValueName(Value *V, char *NameStr) { // 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 = std::make_pair(Name,V->getType()); + RenameMapKey Key = makeRenameMapKey(Name, V.V->getType(), V.S); CurFun.RenameMap[Key] = NewName; Name = NewName; } // Set the name. - V->setName(Name); + V.V->setName(Name); } } @@ -1090,7 +1254,8 @@ static void setValueName(Value *V, char *NameStr) { static GlobalVariable * ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, bool isConstantGlobal, const Type *Ty, - Constant *Initializer) { + Constant *Initializer, + const Signedness &Sign) { if (isa(Ty)) error("Cannot declare global vars of function type"); @@ -1110,6 +1275,7 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, } 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 @@ -1128,20 +1294,15 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, // 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)) { - // We found an existing global ov the same name. This isn't allowed + 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 type is internal so just warn about the rename without - // invoking "scarey language" about linkage failures. GVars with - // InternalLinkage can be renamed at will. - warning("Global variable '" + Name + "' was renamed to '"+ - NewName + "'"); - } else { + 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 @@ -1152,7 +1313,7 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, } // Put the renaming in the global rename map - RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty)); + RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S); CurModule.RenameMap[Key] = NewName; // Rename it @@ -1165,6 +1326,8 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, 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; } @@ -1175,21 +1338,26 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, // This function returns true if the type has already been defined, but is // allowed to be redefined in the specified context. If the name is a new name // for the type plane, it is inserted and false is returned. -static bool setTypeName(const Type *T, char *NameStr) { +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 (T == Type::VoidTy) { + 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, T); + 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); @@ -1199,7 +1367,7 @@ static bool setTypeName(const Type *T, char *NameStr) { // 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(T); + const_cast(OpTy)->refineAbstractTypeTo(Ty); return true; } @@ -1207,11 +1375,11 @@ static bool setTypeName(const Type *T, char *NameStr) { // the redefinition is identical to the original. This will be so if // Existing and T point to the same Type object. In this one case we // allow the equivalent redefinition. - if (Existing == T) return true; // Yes, it's equal. + 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 '" + - T->getDescription() + "' type plane"); + Ty->getDescription() + "' type plane"); } return false; @@ -1243,7 +1411,7 @@ namespace { OpaqueType *UpRefTy; UpRefRecord(unsigned NL, OpaqueType *URTy) - : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {} + : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) { } }; } @@ -1257,7 +1425,7 @@ static std::vector UpRefs; /// 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) { +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; @@ -1273,10 +1441,11 @@ static PATypeHolder HandleUpRefs(const Type *ty) { // this variable. OpaqueType *TypeToResolve = 0; - for (unsigned i = 0; i != UpRefs.size(); ++i) { + unsigned i = 0; + for (; i != UpRefs.size(); ++i) { UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " - << UpRefs[i].second->getDescription() << ") = " - << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); + << 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; @@ -1287,8 +1456,9 @@ static PATypeHolder HandleUpRefs(const Type *ty) { TypeToResolve = UpRefs[i].UpRefTy; } else { UR_OUT(" * Resolving upreference for " - << UpRefs[i].second->getDescription() << "\n"; - std::string OldName = UpRefs[i].UpRefTy->getDescription()); + << UpRefs[i].UpRefTy->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"); @@ -1301,14 +1471,115 @@ static PATypeHolder HandleUpRefs(const Type *ty) { if (TypeToResolve) { UR_OUT(" * Resolving upreference for " - << UpRefs[i].second->getDescription() << "\n"; + << UpRefs[i].UpRefTy->getDescription() << "\n"; std::string OldName = TypeToResolve->getDescription()); + ResolveTypeSign(TypeToResolve, Sign); TypeToResolve->refineAbstractTypeTo(Ty); } return Ty; } +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; + } + 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; + } + return true; + } + return false; + } + return kind == that.kind; +} + +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; + } +} + +void Signedness::destroy() { + if (isNamed()) { + delete name; + } else if (isComposite()) { + delete sv; + } +} + +#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) { @@ -1323,7 +1594,7 @@ getTermOp(TermOps op) { } static inline Instruction::BinaryOps -getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) { +getBinaryOp(BinaryOps op, const Type *Ty, const Signedness& Sign) { switch (op) { default : assert(0 && "Invalid OldBinaryOps"); case SetEQ : @@ -1339,12 +1610,12 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) { // This is an obsolete instruction so we must upgrade it based on the // types of its operands. bool isFP = Ty->isFloatingPoint(); - if (const PackedType* PTy = dyn_cast(Ty)) - // If its a packed type we want to use the element type + 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 == Signed) + else if (Sign.isSigned()) return Instruction::SDiv; return Instruction::UDiv; } @@ -1355,13 +1626,13 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) { // This is an obsolete instruction so we must upgrade it based on the // types of its operands. bool isFP = Ty->isFloatingPoint(); - if (const PackedType* PTy = dyn_cast(Ty)) - // If its a packed type we want to use the element type + 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 == Signed) + else if (Sign.isSigned()) return Instruction::SRem; return Instruction::URem; } @@ -1372,7 +1643,7 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) { case AShrOp : return Instruction::AShr; case ShlOp : return Instruction::Shl; case ShrOp : - if (Sign == Signed) + if (Sign.isSigned()) return Instruction::AShr; return Instruction::LShr; case AndOp : return Instruction::And; @@ -1383,8 +1654,8 @@ getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) { static inline Instruction::OtherOps getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty, - Signedness Sign) { - bool isSigned = Sign == Signed; + const Signedness &Sign) { + bool isSigned = Sign.isSigned(); bool isFP = Ty->isFloatingPoint(); switch (op) { default : assert(0 && "Invalid OldSetCC"); @@ -1464,7 +1735,7 @@ static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) { } static inline Instruction::OtherOps -getOtherOp(OtherOps op, Signedness Sign) { +getOtherOp(OtherOps op, const Signedness &Sign) { switch (op) { default : assert(0 && "Invalid OldOtherOps"); case PHIOp : return Instruction::PHI; @@ -1482,8 +1753,8 @@ getOtherOp(OtherOps op, Signedness Sign) { } static inline Value* -getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, - Signedness DstSign, bool ForceInstruction = false) { +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) { @@ -1520,7 +1791,8 @@ getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy, } // Determine the opcode to use by calling CastInst::getCastOpcode Opcode = - CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed); + CastInst::getCastOpcode(Src, SrcSign.isSigned(), DstTy, + DstSign.isSigned()); } else switch (op) { default: assert(0 && "Invalid cast token"); @@ -1548,90 +1820,158 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, std::vector& Args) { std::string Name = ID.Type == ValID::NameVal ? ID.Name : ""; - if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") { - if (Args.size() != 2) - error("Invalid prototype for " + Name + " prototype"); - return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]); - } else { - 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); - } 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); + 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; + case 'b': + if (Name.length() == 14 && !memcmp(&Name[5], "bswap.i", 7)) { + const Type* ArgTy = Args[0]->getType(); + Name += ".i" + utostr(cast(ArgTy)->getBitWidth()); + Function *F = cast( + CurModule.CurrentModule->getOrInsertFunction(Name, RetTy, ArgTy, + (void*)0)); + return new CallInst(F, Args[0]); + } + break; + case 'c': + if ((Name.length() <= 14 && !memcmp(&Name[5], "ctpop.i", 7)) || + (Name.length() <= 13 && !memcmp(&Name[5], "ctlz.i", 6)) || + (Name.length() <= 13 && !memcmp(&Name[5], "cttz.i", 6))) { + // These intrinsics changed their result type. + const Type* ArgTy = Args[0]->getType(); + Function *OldF = CurModule.CurrentModule->getFunction(Name); + if (OldF) + OldF->setName("upgrd.rm." + Name); + + Function *NewF = cast( + CurModule.CurrentModule->getOrInsertFunction(Name, Type::Int32Ty, + ArgTy, (void*)0)); + + Instruction *Call = new CallInst(NewF, Args[0], "", CurBB); + return CastInst::createIntegerCast(Call, RetTy, false); + } + break; + + 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[0], Args.size()); + } 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[0], Args.size()); + } } } return 0; } -const Type* upgradeGEPIndices(const Type* PTy, - std::vector *Indices, - std::vector &VIndices, - std::vector *CIndices = 0) { - // Traverse the indices with a gep_type_iterator so we can build the list - // of constant and value indices for use later. Also perform upgrades - VIndices.clear(); - if (CIndices) CIndices->clear(); - for (unsigned i = 0, e = Indices->size(); i != e; ++i) - VIndices.push_back((*Indices)[i].V); - generic_gep_type_iterator::iterator> - GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()), - GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end()); - for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) { - Value *Index = VIndices[i]; - if (CIndices && !isa(Index)) - error("Indices to constant getelementptr must be constants"); - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte - // struct indices to i32 struct indices with ZExt for compatibility. - else if (isa(*GTI)) { // Only change struct indices - if (ConstantInt *CUI = dyn_cast(Index)) - if (CUI->getType()->getBitWidth() == 8) - Index = - ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty); +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); + } + } + } + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, (Value**)&Result[0], + Result.size(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); + } + 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); + } + + + 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 == Unsigned) { - if (CIndices) + 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); - VIndices[i] = Index; } + } } - // Add to the CIndices list, if requested. - if (CIndices) - CIndices->push_back(cast(Index)); - } - - const Type *IdxTy = - GetElementPtrInst::getIndexedType(PTy, VIndices, true); - if (!IdxTy) + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true); + if (!Ty) error("Index list invalid for constant getelementptr"); - return IdxTy; + } + return Ty; } unsigned upgradeCallingConv(unsigned CC) { @@ -1681,10 +2021,10 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in, //Not all functions use vaarg, so make a second check for ObsoleteVarArgs { Function* F; - if ((F = Result->getNamedFunction("llvm.va_start")) + if ((F = Result->getFunction("llvm.va_start")) && F->getFunctionType()->getNumParams() == 0) ObsoleteVarArgs = true; - if((F = Result->getNamedFunction("llvm.va_copy")) + if((F = Result->getFunction("llvm.va_copy")) && F->getFunctionType()->getNumParams() == 1) ObsoleteVarArgs = true; } @@ -1695,7 +2035,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in, } if(ObsoleteVarArgs) { - if(Function* F = Result->getNamedFunction("llvm.va_start")) { + if(Function* F = Result->getFunction("llvm.va_start")) { if (F->arg_size() != 0) { error("Obsolete va_start takes 0 argument"); return 0; @@ -1724,7 +2064,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in, Result->getFunctionList().erase(F); } - if(Function* F = Result->getNamedFunction("llvm.va_end")) { + if(Function* F = Result->getFunction("llvm.va_end")) { if(F->arg_size() != 1) { error("Obsolete va_end takes 1 argument"); return 0; @@ -1750,7 +2090,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in, Result->getFunctionList().erase(F); } - if(Function* F = Result->getNamedFunction("llvm.va_copy")) { + if(Function* F = Result->getFunction("llvm.va_copy")) { if(F->arg_size() != 1) { error("Obsolete va_copy takes 1 argument"); return 0; @@ -1811,13 +2151,13 @@ using namespace llvm; #endif #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -#line 1435 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1775 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" typedef union YYSTYPE { llvm::Module *ModuleVal; llvm::Function *FunctionVal; std::pair *ArgVal; llvm::BasicBlock *BasicBlockVal; - llvm::TerminatorInst *TermInstVal; + llvm::TermInstInfo TermInstVal; llvm::InstrInfo InstVal; llvm::ConstInfo ConstVal; llvm::ValueInfo ValueVal; @@ -1854,7 +2194,7 @@ typedef union YYSTYPE { llvm::Module::Endianness Endianness; } YYSTYPE; /* Line 196 of yacc.c. */ -#line 1858 "UpgradeParser.tab.c" +#line 2198 "UpgradeParser.tab.c" # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 @@ -1866,7 +2206,7 @@ typedef union YYSTYPE { /* Line 219 of yacc.c. */ -#line 1870 "UpgradeParser.tab.c" +#line 2210 "UpgradeParser.tab.c" #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ @@ -2017,16 +2357,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 4 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 1736 +#define YYLAST 1630 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 166 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 79 +#define YYNNTS 81 /* YYNRULES -- Number of rules. */ -#define YYNRULES 308 +#define YYNRULES 310 /* YYNRULES -- Number of states. */ -#define YYNSTATES 604 +#define YYNSTATES 606 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 @@ -2108,15 +2448,16 @@ static const unsigned short int yyprhs[] = 528, 529, 537, 538, 546, 547, 555, 559, 564, 565, 567, 569, 571, 575, 579, 583, 587, 591, 595, 597, 598, 600, 602, 604, 605, 608, 612, 614, 616, 620, - 622, 623, 632, 634, 636, 640, 642, 644, 647, 648, - 650, 652, 653, 658, 659, 661, 663, 665, 667, 669, - 671, 673, 675, 677, 681, 683, 689, 691, 693, 695, - 697, 700, 703, 706, 710, 713, 714, 716, 718, 720, - 723, 726, 730, 740, 750, 759, 773, 775, 777, 784, - 790, 793, 800, 808, 810, 814, 816, 817, 820, 822, - 828, 834, 840, 847, 854, 857, 862, 867, 874, 879, - 884, 889, 894, 901, 908, 911, 919, 921, 924, 925, - 927, 928, 932, 939, 943, 950, 953, 958, 965 + 622, 623, 632, 634, 636, 637, 642, 644, 646, 649, + 650, 652, 654, 655, 656, 662, 663, 665, 667, 669, + 671, 673, 675, 677, 679, 681, 685, 687, 693, 695, + 697, 699, 701, 704, 707, 710, 714, 717, 718, 720, + 722, 724, 727, 730, 734, 744, 754, 763, 777, 779, + 781, 788, 794, 797, 804, 812, 814, 818, 820, 821, + 824, 826, 832, 838, 844, 851, 858, 861, 866, 871, + 878, 883, 888, 893, 898, 905, 912, 915, 923, 925, + 928, 929, 931, 932, 936, 943, 947, 954, 957, 962, + 969 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ @@ -2147,7 +2488,7 @@ static const short int yyrhs[] = -1, 191, -1, 8, -1, 193, -1, 8, -1, 193, -1, 9, -1, 10, -1, 11, -1, 12, -1, 13, -1, 14, -1, 15, -1, 16, -1, 17, -1, 18, - -1, 19, -1, 21, -1, 192, -1, 48, -1, 227, + -1, 19, -1, 21, -1, 192, -1, 48, -1, 229, -1, 154, 4, -1, 190, 155, 195, 156, -1, 157, 4, 158, 193, 159, -1, 160, 4, 158, 193, 161, -1, 162, 194, 163, -1, 162, 163, -1, 160, 162, @@ -2158,10 +2499,10 @@ static const short int yyrhs[] = 191, 160, 198, 161, -1, 191, 162, 198, 163, -1, 191, 162, 163, -1, 191, 160, 162, 198, 163, 161, -1, 191, 160, 162, 163, 161, -1, 191, 38, -1, - 191, 39, -1, 191, 227, -1, 191, 197, -1, 191, + 191, 39, -1, 191, 229, -1, 191, 197, -1, 191, 26, -1, 176, 168, -1, 177, 4, -1, 9, 27, -1, 9, 28, -1, 179, 7, -1, 175, 155, 196, - 36, 191, 156, -1, 110, 155, 196, 242, 156, -1, + 36, 191, 156, -1, 110, 155, 196, 244, 156, -1, 112, 155, 196, 153, 196, 153, 196, 156, -1, 169, 155, 196, 153, 196, 156, -1, 170, 155, 196, 153, 196, 156, -1, 171, 155, 196, 153, 196, 156, -1, @@ -2171,9 +2512,9 @@ static const short int yyrhs[] = 115, 155, 196, 153, 196, 153, 196, 156, -1, 116, 155, 196, 153, 196, 153, 196, 156, -1, 198, 153, 196, -1, 196, -1, 32, -1, 33, -1, 201, -1, - 201, 221, -1, 201, 223, -1, 201, 62, 61, 207, + 201, 222, -1, 201, 224, -1, 201, 62, 61, 207, -1, 201, 25, -1, 202, -1, 202, 180, 20, 189, - -1, 202, 223, -1, 202, 62, 61, 207, -1, -1, + -1, 202, 224, -1, 202, 62, 61, 207, -1, -1, 202, 180, 181, 199, 196, 203, 187, -1, -1, 202, 180, 50, 199, 191, 204, 187, -1, -1, 202, 180, 45, 199, 191, 205, 187, -1, -1, 202, 180, 47, @@ -2185,76 +2526,78 @@ static const short int yyrhs[] = 24, -1, 212, -1, -1, 191, 213, -1, 215, 153, 214, -1, 214, -1, 215, -1, 215, 153, 37, -1, 37, -1, -1, 182, 189, 212, 155, 216, 156, 186, - 183, -1, 29, -1, 162, -1, 181, 217, 218, -1, - 30, -1, 163, -1, 230, 220, -1, -1, 45, -1, - 47, -1, -1, 31, 224, 222, 217, -1, -1, 63, - -1, 3, -1, 4, -1, 7, -1, 27, -1, 28, - -1, 38, -1, 39, -1, 26, -1, 160, 198, 161, - -1, 197, -1, 61, 225, 24, 153, 24, -1, 167, - -1, 212, -1, 227, -1, 226, -1, 191, 228, -1, - 230, 231, -1, 219, 231, -1, 232, 180, 234, -1, - 232, 236, -1, -1, 23, -1, 77, -1, 78, -1, - 72, 229, -1, 72, 8, -1, 73, 21, 228, -1, - 73, 9, 228, 153, 21, 228, 153, 21, 228, -1, - 74, 178, 228, 153, 21, 228, 157, 235, 159, -1, - 74, 178, 228, 153, 21, 228, 157, 159, -1, 75, - 182, 189, 228, 155, 239, 156, 36, 21, 228, 233, - 21, 228, -1, 233, -1, 76, -1, 235, 178, 226, - 153, 21, 228, -1, 178, 226, 153, 21, 228, -1, - 180, 241, -1, 191, 157, 228, 153, 228, 159, -1, - 237, 153, 157, 228, 153, 228, 159, -1, 229, -1, - 238, 153, 229, -1, 238, -1, -1, 60, 59, -1, - 59, -1, 169, 191, 228, 153, 228, -1, 170, 191, - 228, 153, 228, -1, 171, 191, 228, 153, 228, -1, - 103, 172, 191, 228, 153, 228, -1, 104, 173, 191, - 228, 153, 228, -1, 49, 229, -1, 174, 229, 153, - 229, -1, 175, 229, 36, 191, -1, 112, 229, 153, - 229, 153, 229, -1, 113, 229, 153, 191, -1, 117, - 229, 153, 191, -1, 118, 229, 153, 191, -1, 114, - 229, 153, 229, -1, 115, 229, 153, 229, 153, 229, - -1, 116, 229, 153, 229, 153, 229, -1, 111, 237, - -1, 240, 182, 189, 228, 155, 239, 156, -1, 244, - -1, 153, 238, -1, -1, 35, -1, -1, 105, 191, - 184, -1, 105, 191, 153, 15, 228, 184, -1, 106, - 191, 184, -1, 106, 191, 153, 15, 228, 184, -1, - 107, 229, -1, 243, 108, 191, 228, -1, 243, 109, - 229, 153, 191, 228, -1, 110, 191, 228, 242, -1 + 183, -1, 29, -1, 162, -1, -1, 181, 220, 217, + 218, -1, 30, -1, 163, -1, 232, 221, -1, -1, + 45, -1, 47, -1, -1, -1, 31, 225, 223, 226, + 217, -1, -1, 63, -1, 3, -1, 4, -1, 7, + -1, 27, -1, 28, -1, 38, -1, 39, -1, 26, + -1, 160, 198, 161, -1, 197, -1, 61, 227, 24, + 153, 24, -1, 167, -1, 212, -1, 229, -1, 228, + -1, 191, 230, -1, 232, 233, -1, 219, 233, -1, + 234, 180, 236, -1, 234, 238, -1, -1, 23, -1, + 77, -1, 78, -1, 72, 231, -1, 72, 8, -1, + 73, 21, 230, -1, 73, 9, 230, 153, 21, 230, + 153, 21, 230, -1, 74, 178, 230, 153, 21, 230, + 157, 237, 159, -1, 74, 178, 230, 153, 21, 230, + 157, 159, -1, 75, 182, 189, 230, 155, 241, 156, + 36, 21, 230, 235, 21, 230, -1, 235, -1, 76, + -1, 237, 178, 228, 153, 21, 230, -1, 178, 228, + 153, 21, 230, -1, 180, 243, -1, 191, 157, 230, + 153, 230, 159, -1, 239, 153, 157, 230, 153, 230, + 159, -1, 231, -1, 240, 153, 231, -1, 240, -1, + -1, 60, 59, -1, 59, -1, 169, 191, 230, 153, + 230, -1, 170, 191, 230, 153, 230, -1, 171, 191, + 230, 153, 230, -1, 103, 172, 191, 230, 153, 230, + -1, 104, 173, 191, 230, 153, 230, -1, 49, 231, + -1, 174, 231, 153, 231, -1, 175, 231, 36, 191, + -1, 112, 231, 153, 231, 153, 231, -1, 113, 231, + 153, 191, -1, 117, 231, 153, 191, -1, 118, 231, + 153, 191, -1, 114, 231, 153, 231, -1, 115, 231, + 153, 231, 153, 231, -1, 116, 231, 153, 231, 153, + 231, -1, 111, 239, -1, 242, 182, 189, 230, 155, + 241, 156, -1, 246, -1, 153, 240, -1, -1, 35, + -1, -1, 105, 191, 184, -1, 105, 191, 153, 15, + 230, 184, -1, 106, 191, 184, -1, 106, 191, 153, + 15, 230, 184, -1, 107, 231, -1, 245, 108, 191, + 230, -1, 245, 109, 231, 153, 191, 230, -1, 110, + 191, 230, 244, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const unsigned short int yyrline[] = { - 0, 1575, 1575, 1576, 1584, 1585, 1595, 1595, 1595, 1595, - 1595, 1595, 1595, 1595, 1595, 1595, 1595, 1599, 1599, 1599, - 1603, 1603, 1603, 1603, 1603, 1603, 1607, 1607, 1608, 1608, - 1609, 1609, 1610, 1610, 1611, 1611, 1615, 1615, 1616, 1616, - 1617, 1617, 1618, 1618, 1619, 1619, 1620, 1620, 1621, 1621, - 1622, 1623, 1626, 1626, 1626, 1626, 1630, 1630, 1630, 1630, - 1630, 1630, 1630, 1631, 1631, 1631, 1631, 1631, 1631, 1637, - 1637, 1637, 1637, 1641, 1641, 1641, 1641, 1645, 1645, 1649, - 1649, 1654, 1657, 1662, 1663, 1664, 1665, 1666, 1667, 1668, - 1669, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1690, - 1691, 1699, 1700, 1708, 1717, 1718, 1725, 1726, 1730, 1734, - 1750, 1751, 1758, 1759, 1766, 1774, 1774, 1774, 1774, 1774, - 1774, 1774, 1775, 1775, 1775, 1775, 1775, 1780, 1784, 1788, - 1793, 1802, 1823, 1829, 1842, 1851, 1855, 1866, 1870, 1883, - 1887, 1894, 1895, 1901, 1908, 1920, 1950, 1963, 1986, 2014, - 2036, 2047, 2069, 2080, 2089, 2094, 2152, 2159, 2167, 2174, - 2181, 2185, 2189, 2198, 2213, 2226, 2235, 2263, 2276, 2285, - 2291, 2297, 2308, 2314, 2320, 2331, 2332, 2341, 2342, 2354, - 2363, 2364, 2365, 2366, 2367, 2383, 2403, 2405, 2407, 2407, - 2414, 2414, 2421, 2421, 2428, 2428, 2436, 2438, 2440, 2445, - 2459, 2460, 2464, 2467, 2475, 2479, 2486, 2490, 2494, 2498, - 2506, 2506, 2510, 2511, 2515, 2523, 2528, 2536, 2537, 2544, - 2551, 2555, 2670, 2670, 2674, 2684, 2684, 2688, 2692, 2694, - 2695, 2699, 2699, 2711, 2712, 2717, 2718, 2719, 2720, 2721, - 2722, 2723, 2724, 2725, 2746, 2749, 2764, 2765, 2770, 2770, - 2778, 2787, 2790, 2799, 2809, 2814, 2823, 2834, 2834, 2837, - 2840, 2843, 2847, 2853, 2868, 2874, 2930, 2933, 2939, 2949, - 2962, 2991, 2999, 3007, 3011, 3018, 3019, 3023, 3026, 3032, - 3049, 3065, 3079, 3091, 3103, 3114, 3132, 3141, 3150, 3157, - 3178, 3202, 3208, 3214, 3220, 3236, 3314, 3322, 3323, 3327, - 3328, 3332, 3338, 3344, 3350, 3356, 3363, 3375, 3389 + 0, 1915, 1915, 1916, 1924, 1925, 1935, 1935, 1935, 1935, + 1935, 1935, 1935, 1935, 1935, 1935, 1935, 1939, 1939, 1939, + 1943, 1943, 1943, 1943, 1943, 1943, 1947, 1947, 1948, 1948, + 1949, 1949, 1950, 1950, 1951, 1951, 1955, 1955, 1956, 1956, + 1957, 1957, 1958, 1958, 1959, 1959, 1960, 1960, 1961, 1961, + 1962, 1963, 1966, 1966, 1966, 1966, 1970, 1970, 1970, 1970, + 1970, 1970, 1970, 1971, 1971, 1971, 1971, 1971, 1971, 1977, + 1977, 1977, 1977, 1981, 1981, 1981, 1981, 1985, 1985, 1989, + 1989, 1994, 1997, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2030, + 2031, 2039, 2040, 2048, 2057, 2058, 2065, 2066, 2070, 2074, + 2090, 2091, 2098, 2099, 2106, 2114, 2114, 2114, 2114, 2114, + 2114, 2114, 2115, 2115, 2115, 2115, 2115, 2120, 2124, 2128, + 2133, 2142, 2169, 2175, 2188, 2199, 2203, 2216, 2220, 2234, + 2238, 2245, 2246, 2252, 2259, 2271, 2301, 2314, 2337, 2365, + 2387, 2398, 2420, 2431, 2440, 2445, 2504, 2511, 2519, 2526, + 2533, 2537, 2541, 2550, 2565, 2577, 2586, 2614, 2627, 2636, + 2642, 2648, 2659, 2665, 2671, 2682, 2683, 2692, 2693, 2705, + 2714, 2715, 2716, 2717, 2718, 2734, 2754, 2756, 2758, 2758, + 2765, 2765, 2773, 2773, 2781, 2781, 2790, 2792, 2794, 2799, + 2813, 2814, 2818, 2821, 2829, 2833, 2840, 2844, 2848, 2852, + 2860, 2860, 2864, 2865, 2869, 2877, 2882, 2890, 2891, 2898, + 2905, 2909, 3099, 3099, 3103, 3103, 3113, 3113, 3117, 3122, + 3123, 3124, 3128, 3129, 3128, 3141, 3142, 3147, 3148, 3149, + 3150, 3154, 3158, 3159, 3160, 3161, 3182, 3186, 3200, 3201, + 3206, 3206, 3214, 3224, 3227, 3236, 3247, 3252, 3261, 3272, + 3272, 3275, 3279, 3283, 3288, 3298, 3316, 3325, 3398, 3402, + 3409, 3421, 3436, 3466, 3476, 3486, 3490, 3497, 3498, 3502, + 3505, 3511, 3530, 3548, 3564, 3578, 3592, 3603, 3621, 3630, + 3639, 3646, 3667, 3691, 3697, 3703, 3709, 3725, 3818, 3826, + 3827, 3831, 3832, 3836, 3842, 3849, 3855, 3862, 3869, 3882, + 3908 }; #endif @@ -2297,7 +2640,7 @@ static const char *const yytname[] = "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition", "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal", "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", - "END", "Function", "FnDeclareLinkage", "FunctionProto", "@5", + "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7", "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList", "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList", @@ -2356,15 +2699,16 @@ static const unsigned char yyr1[] = 204, 202, 205, 202, 206, 202, 202, 202, 202, 207, 208, 208, 209, 209, 209, 209, 210, 211, 211, 211, 212, 212, 213, 213, 214, 215, 215, 216, 216, 216, - 216, 217, 218, 218, 219, 220, 220, 221, 222, 222, - 222, 224, 223, 225, 225, 226, 226, 226, 226, 226, - 226, 226, 226, 226, 226, 226, 227, 227, 228, 228, - 229, 230, 230, 231, 232, 232, 232, 233, 233, 234, - 234, 234, 234, 234, 234, 234, 234, 234, 235, 235, - 236, 237, 237, 238, 238, 239, 239, 240, 240, 241, - 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 241, 241, 241, 241, 242, 242, 243, - 243, 244, 244, 244, 244, 244, 244, 244, 244 + 216, 217, 218, 218, 220, 219, 221, 221, 222, 223, + 223, 223, 225, 226, 224, 227, 227, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 229, 229, + 230, 230, 231, 232, 232, 233, 234, 234, 234, 235, + 235, 236, 236, 236, 236, 236, 236, 236, 236, 236, + 237, 237, 238, 239, 239, 240, 240, 241, 241, 242, + 242, 243, 243, 243, 243, 243, 243, 243, 243, 243, + 243, 243, 243, 243, 243, 243, 243, 243, 243, 244, + 244, 245, 245, 246, 246, 246, 246, 246, 246, 246, + 246 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -2392,15 +2736,16 @@ static const unsigned char yyr2[] = 0, 7, 0, 7, 0, 7, 3, 4, 0, 1, 1, 1, 3, 3, 3, 3, 3, 3, 1, 0, 1, 1, 1, 0, 2, 3, 1, 1, 3, 1, - 0, 8, 1, 1, 3, 1, 1, 2, 0, 1, - 1, 0, 4, 0, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 1, 5, 1, 1, 1, 1, - 2, 2, 2, 3, 2, 0, 1, 1, 1, 2, - 2, 3, 9, 9, 8, 13, 1, 1, 6, 5, - 2, 6, 7, 1, 3, 1, 0, 2, 1, 5, - 5, 5, 6, 6, 2, 4, 4, 6, 4, 4, - 4, 4, 6, 6, 2, 7, 1, 2, 0, 1, - 0, 3, 6, 3, 6, 2, 4, 6, 4 + 0, 8, 1, 1, 0, 4, 1, 1, 2, 0, + 1, 1, 0, 0, 5, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 1, 5, 1, 1, + 1, 1, 2, 2, 2, 3, 2, 0, 1, 1, + 1, 2, 2, 3, 9, 9, 8, 13, 1, 1, + 6, 5, 2, 6, 7, 1, 3, 1, 0, 2, + 1, 5, 5, 5, 6, 6, 2, 4, 4, 6, + 4, 4, 4, 4, 6, 6, 2, 7, 1, 2, + 0, 1, 0, 3, 6, 3, 6, 2, 4, 6, + 4 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -2408,161 +2753,163 @@ static const unsigned char yyr2[] = means the default is an error. */ static const unsigned short int yydefact[] = { - 198, 0, 90, 184, 1, 183, 231, 83, 84, 85, - 86, 87, 88, 89, 0, 91, 255, 180, 181, 255, - 210, 211, 0, 0, 0, 90, 0, 186, 228, 0, - 0, 92, 93, 94, 95, 96, 97, 0, 0, 256, - 252, 82, 225, 226, 227, 251, 0, 0, 0, 0, - 196, 0, 0, 0, 0, 0, 0, 0, 81, 229, - 230, 91, 199, 182, 98, 2, 3, 111, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 128, 0, 0, 0, 0, 246, 0, 0, 110, 127, - 114, 247, 129, 222, 223, 224, 300, 254, 0, 0, - 0, 0, 209, 197, 187, 185, 177, 178, 0, 0, - 0, 0, 232, 130, 0, 0, 0, 113, 135, 139, - 0, 0, 144, 138, 299, 0, 278, 0, 0, 0, - 0, 91, 267, 257, 258, 6, 7, 8, 9, 10, + 198, 0, 90, 184, 1, 183, 232, 83, 84, 85, + 86, 87, 88, 89, 0, 224, 257, 180, 181, 257, + 210, 211, 0, 0, 0, 90, 0, 186, 229, 0, + 91, 258, 254, 82, 226, 227, 228, 253, 0, 0, + 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, + 81, 230, 231, 233, 199, 182, 0, 92, 93, 94, + 95, 96, 97, 0, 0, 302, 256, 0, 0, 0, + 0, 209, 197, 187, 2, 3, 111, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, + 0, 0, 0, 0, 248, 185, 0, 110, 127, 114, + 249, 129, 177, 178, 0, 0, 0, 0, 91, 98, + 0, 222, 223, 225, 301, 0, 280, 0, 0, 0, + 0, 91, 269, 259, 260, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 52, 53, 54, 55, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, - 0, 266, 253, 91, 270, 0, 296, 204, 201, 200, - 202, 203, 205, 208, 0, 192, 194, 190, 115, 116, + 0, 268, 255, 91, 272, 0, 298, 204, 201, 200, + 202, 203, 205, 208, 0, 130, 0, 0, 0, 113, + 135, 139, 0, 144, 138, 192, 194, 190, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 0, 0, 0, 188, 0, 0, 0, 0, 0, 134, - 220, 143, 141, 0, 0, 284, 277, 260, 259, 0, - 0, 72, 76, 71, 75, 70, 74, 69, 73, 77, - 78, 0, 0, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 0, 50, 51, 46, 47, 48, 49, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 0, 101, 101, 305, 0, 0, 294, 0, 0, 0, + 0, 0, 0, 188, 234, 0, 0, 286, 279, 262, + 261, 0, 0, 72, 76, 71, 75, 70, 74, 69, + 73, 77, 78, 0, 0, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 0, 50, 51, 46, 47, + 48, 49, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 0, 101, 101, 307, 0, 0, 296, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 206, 0, 0, 0, 0, + 0, 134, 143, 141, 0, 106, 106, 106, 160, 161, + 4, 5, 158, 159, 162, 157, 153, 154, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 206, 106, 106, 106, 160, 161, 4, - 5, 158, 159, 162, 157, 153, 154, 0, 0, 0, + 0, 0, 0, 0, 156, 155, 106, 220, 237, 238, + 239, 244, 240, 241, 242, 243, 235, 0, 246, 251, + 250, 252, 0, 263, 0, 0, 0, 0, 0, 303, + 0, 305, 300, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 156, 155, 106, 112, 112, 137, 0, - 140, 219, 213, 216, 217, 0, 0, 131, 235, 236, - 237, 242, 238, 239, 240, 241, 233, 0, 244, 249, - 248, 250, 0, 261, 0, 0, 0, 0, 0, 301, - 0, 303, 298, 0, 0, 0, 0, 0, 0, 0, + 207, 112, 112, 137, 0, 140, 0, 131, 0, 193, + 195, 191, 0, 0, 0, 0, 0, 0, 0, 146, + 176, 0, 0, 0, 150, 0, 147, 0, 0, 0, + 0, 0, 189, 219, 213, 216, 217, 0, 236, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 207, 0, 193, 195, 191, 0, 0, 0, 0, 0, - 0, 0, 146, 176, 0, 0, 0, 150, 0, 147, - 0, 0, 0, 0, 0, 189, 132, 133, 136, 212, - 214, 0, 104, 142, 234, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 308, 0, 0, 0, - 288, 291, 0, 0, 289, 290, 0, 0, 0, 285, - 286, 0, 306, 0, 0, 0, 108, 106, 0, 0, - 298, 0, 0, 0, 0, 0, 145, 135, 114, 0, - 148, 149, 0, 0, 0, 0, 0, 218, 215, 105, - 99, 0, 243, 0, 0, 276, 0, 0, 101, 102, - 101, 273, 297, 0, 0, 0, 0, 0, 279, 280, - 281, 276, 0, 103, 109, 107, 0, 0, 0, 0, - 0, 0, 0, 175, 152, 0, 0, 0, 0, 0, - 0, 0, 221, 0, 0, 0, 275, 0, 282, 283, - 0, 302, 304, 0, 0, 0, 287, 292, 293, 0, - 307, 0, 0, 164, 0, 0, 0, 0, 151, 0, - 0, 0, 0, 0, 100, 245, 0, 0, 0, 274, - 271, 0, 295, 0, 0, 0, 172, 0, 0, 166, - 167, 168, 171, 163, 0, 264, 0, 0, 0, 272, - 169, 170, 0, 0, 0, 262, 0, 263, 0, 0, - 165, 173, 174, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 268, 265 + 310, 0, 0, 0, 290, 293, 0, 0, 291, 292, + 0, 0, 0, 287, 288, 0, 308, 0, 132, 133, + 136, 142, 0, 0, 108, 106, 0, 0, 300, 0, + 0, 0, 0, 0, 145, 135, 114, 0, 148, 149, + 0, 0, 0, 0, 0, 212, 214, 0, 104, 0, + 245, 0, 0, 278, 0, 0, 101, 102, 101, 275, + 299, 0, 0, 0, 0, 0, 281, 282, 283, 278, + 0, 103, 109, 107, 0, 0, 0, 0, 0, 0, + 0, 175, 152, 0, 0, 0, 0, 0, 0, 218, + 215, 105, 99, 0, 0, 0, 277, 0, 284, 285, + 0, 304, 306, 0, 0, 0, 289, 294, 295, 0, + 309, 0, 0, 164, 0, 0, 0, 0, 151, 0, + 0, 0, 0, 0, 0, 221, 247, 0, 0, 0, + 276, 273, 0, 297, 0, 0, 0, 172, 0, 0, + 166, 167, 168, 171, 163, 100, 0, 266, 0, 0, + 0, 274, 169, 170, 0, 0, 0, 264, 0, 265, + 0, 0, 165, 173, 174, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 270, 267 }; /* YYDEFGOTO[NTERM-NUM]. */ static const short int yydefgoto[] = { - -1, 85, 311, 328, 329, 330, 263, 280, 331, 332, - 219, 220, 251, 221, 25, 15, 37, 522, 369, 456, - 480, 392, 457, 86, 87, 222, 89, 90, 120, 233, - 403, 358, 404, 108, 1, 2, 3, 335, 306, 304, - 305, 63, 200, 50, 103, 204, 91, 420, 343, 344, - 345, 38, 95, 16, 44, 17, 61, 18, 28, 425, - 359, 92, 361, 491, 19, 40, 41, 191, 192, 577, - 97, 286, 526, 527, 193, 194, 436, 195, 196 + -1, 94, 312, 329, 330, 331, 255, 272, 332, 333, + 219, 220, 243, 221, 25, 15, 63, 555, 359, 454, + 522, 389, 455, 95, 96, 222, 98, 99, 202, 304, + 400, 348, 401, 104, 1, 2, 3, 336, 307, 305, + 306, 55, 190, 42, 72, 194, 100, 476, 415, 416, + 417, 64, 113, 16, 30, 36, 17, 53, 18, 28, + 108, 419, 349, 101, 351, 489, 19, 32, 33, 181, + 182, 579, 66, 278, 526, 527, 183, 184, 430, 185, + 186 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -541 +#define YYPACT_NINF -542 static const short int yypact[] = { - -541, 28, 61, 478, -541, -541, -541, -541, -541, -541, - -541, -541, -541, -541, 23, 152, 45, -541, -541, -9, - -541, -541, -20, -51, 76, 69, 12, -541, 97, 149, - 172, -541, -541, -541, -541, -541, -541, 1331, -19, -541, - -541, 137, -541, -541, -541, -541, 49, 58, 60, 62, - -541, 72, 149, 1331, 88, 88, 88, 88, -541, -541, - -541, 152, -541, -541, -541, -541, -541, 75, -541, -541, - -541, -541, -541, -541, -541, -541, -541, -541, -541, -541, - -541, 227, 228, 3, 691, -541, 137, 79, -541, -541, - -46, -541, -541, -541, -541, -541, 1585, -541, 212, 136, - 233, 214, 216, -541, -541, -541, -541, -541, 1392, 1392, - 1392, 1433, -541, -541, 83, 87, 711, -541, -541, -46, - -70, 89, 777, -541, -541, 1392, -541, 183, 1453, 6, - 309, 152, -541, -541, -541, -541, -541, -541, -541, -541, - -541, -541, -541, -541, -541, -541, -541, -541, -541, -541, - -541, -541, -541, -541, -541, -541, -541, -541, -541, 59, - 142, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392, - 1392, 1392, 1392, -541, -541, -541, -541, -541, -541, -541, - -541, -541, -541, -541, -541, -541, 1392, 1392, 1392, 1392, - 1392, -541, -541, 152, -541, 86, -541, -541, -541, -541, - -541, -541, -541, -541, -129, -541, -541, -541, 169, 196, - 242, 200, 246, 203, 252, 205, 253, 251, 258, 221, - 255, 259, 533, -541, 1392, 1392, 99, -63, 1392, -541, - 1173, -541, 128, 126, 894, -541, -541, 75, -541, 894, - 894, -541, -541, -541, -541, -541, -541, -541, -541, -541, - -541, 894, 1331, -541, -541, -541, -541, -541, -541, -541, - -541, -541, -541, 1392, -541, -541, -541, -541, -541, -541, - -541, -541, -541, -541, -541, -541, -541, -541, -541, -541, - 1392, 130, 133, -541, 894, 132, 138, 139, 143, 144, - 151, 155, 156, 157, 894, 894, 894, 163, 254, 1331, - 1392, 1392, 271, -541, 164, 164, 164, -541, -541, -541, - -541, -541, -541, -541, -541, -541, -541, 59, 142, 173, - 174, 175, 176, 177, 1214, 1494, 732, 281, 178, 179, - 180, 182, 190, -541, -541, 164, -42, -135, -541, 166, - -46, -541, 137, -541, 193, 191, 1234, -541, -541, -541, - -541, -541, -541, -541, -541, -541, 290, 1433, -541, -541, - -541, -541, 201, -541, 202, 894, 894, 894, 7, -541, - 10, -541, 204, 894, 199, 1392, 1392, 1392, 1392, 1392, - 1392, 1392, 211, 215, 217, 1392, 1392, 894, 894, 223, - -541, -21, -541, -541, -541, 210, 219, 1433, 1433, 1433, - 1433, 1433, -541, -541, 4, 752, -91, -541, -8, -541, - 1433, 1433, 1433, 1433, 1433, -541, -541, -541, -541, -541, - -541, 1275, 324, -541, -541, 343, 37, 348, 356, 224, - 225, 229, 894, 376, 894, 1392, -541, 230, 894, 232, - -541, -541, 234, 235, -541, -541, 894, 894, 894, -541, - -541, 226, -541, 1392, 362, 385, -541, 164, 1433, 1433, - 204, 238, 239, 240, 241, 1433, -541, 243, -17, -5, - -541, -541, 247, 250, 261, 262, 359, -541, -541, -541, - 339, 268, -541, 894, 894, 1392, 894, 894, 269, -541, - 269, -541, 270, 894, 272, 1392, 1392, 1392, -541, -541, - -541, 1392, 894, -541, -541, -541, 273, 274, 249, 1433, - 1433, 1433, 1433, -541, -541, 245, 1433, 1433, 1433, 1433, - 1392, 395, -541, 383, 275, 267, 270, 279, -541, -541, - 351, -541, -541, 1392, 277, 894, -541, -541, -541, 282, - -541, 1433, 1433, -541, 278, 283, 284, 288, -541, 289, - 291, 295, 296, 297, -541, -541, 423, 43, 410, -541, - -541, 298, -541, 300, 305, 1433, -541, 1433, 1433, -541, - -541, -541, -541, -541, 894, -541, 1020, 64, 441, -541, - -541, -541, 307, 311, 314, -541, 312, -541, 1020, 894, - -541, -541, -541, 450, 319, 150, 894, 452, 453, -541, - 894, 894, -541, -541 + -542, 13, 162, 567, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, 83, -542, 19, -542, -542, -14, + -542, -542, 50, -87, 87, 233, 27, -542, 123, 141, + 175, -542, -542, 98, -542, -542, -542, -542, 33, 40, + 66, 68, -542, 14, 141, 1265, 156, 156, 156, 156, + -542, -542, -542, -542, -542, -542, 221, -542, -542, -542, + -542, -542, -542, 1265, -19, 1479, -542, 204, 135, 226, + 227, 235, -542, -542, -542, -542, 81, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + 256, 257, 4, 15, -542, -542, 108, -542, -542, 12, + -542, -542, -542, -542, 1306, 1306, 1306, 1326, 175, -542, + 98, -542, -542, -542, -542, 1306, -542, 205, 1367, 116, + 479, 175, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, 355, + 429, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, + 1306, 1306, 1306, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, 1306, 1306, 1306, 1306, + 1306, -542, -542, 175, -542, 86, -542, -542, -542, -542, + -542, -542, -542, -542, -13, -542, 110, 111, 75, -542, + -542, 12, -81, 1046, -542, -542, -542, -542, 174, 208, + 266, 210, 267, 212, 268, 230, 277, 275, 278, 246, + 280, 279, 566, -542, -542, 136, 766, -542, -542, 81, + -542, 766, 766, -542, -542, -542, -542, -542, -542, -542, + -542, -542, -542, 766, 1265, -542, -542, -542, -542, -542, + -542, -542, -542, -542, -542, 1306, -542, -542, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, -542, -542, + -542, -542, 1306, 137, 145, -542, 766, 132, 146, 147, + 148, 149, 151, 152, 158, 160, 766, 766, 766, 161, + 281, 1265, 1306, 1306, 291, -542, 1306, 1306, 155, -27, + 1306, -542, -542, 165, 163, 176, 176, 176, -542, -542, + -542, -542, -542, -542, -542, -542, -542, -542, 355, 429, + 172, 177, 178, 179, 182, 1087, 1387, 529, 311, 184, + 185, 186, 188, 189, -542, -542, 176, 1107, -542, -542, + -542, -542, -542, -542, -542, -542, 282, 1326, -542, -542, + -542, -542, 193, -542, 194, 766, 766, 766, 7, -542, + 20, -542, 195, 766, 192, 1306, 1306, 1306, 1306, 1306, + 1306, 1306, 200, 201, 206, 1306, 1306, 766, 766, 207, + -542, -59, -149, -542, 196, 12, 1148, -542, 44, -542, + -542, -542, 203, 211, 1326, 1326, 1326, 1326, 1326, -542, + -542, -8, 741, -82, -542, 10, -542, 1326, 1326, 1326, + 1326, 1326, -542, -542, 98, -542, 214, 209, -542, 337, + -34, 342, 348, 215, 218, 219, 766, 371, 766, 1306, + -542, 223, 766, 224, -542, -542, 225, 234, -542, -542, + 766, 766, 766, -542, -542, 228, -542, 1306, -542, -542, + -542, -542, 362, 375, -542, 176, 1326, 1326, 195, 236, + 237, 240, 243, 1326, -542, 238, -25, 11, -542, -542, + 244, 245, 247, 250, 352, -542, -542, 1205, 370, 252, + -542, 766, 766, 1306, 766, 766, 258, -542, 258, -542, + 259, 766, 264, 1306, 1306, 1306, -542, -542, -542, 1306, + 766, -542, -542, -542, 270, 271, 263, 1326, 1326, 1326, + 1326, -542, -542, 260, 1326, 1326, 1326, 1326, 1306, -542, + -542, -542, 368, 402, 274, 276, 259, 287, -542, -542, + 374, -542, -542, 1306, 285, 766, -542, -542, -542, 290, + -542, 1326, 1326, -542, 283, 295, 284, 294, -542, 296, + 297, 299, 302, 303, 430, -542, -542, 414, 41, 425, + -542, -542, 305, -542, 306, 310, 1326, -542, 1326, 1326, + -542, -542, -542, -542, -542, -542, 766, -542, 893, 144, + 448, -542, -542, -542, 314, 315, 316, -542, 331, -542, + 893, 766, -542, -542, -542, 464, 334, 180, 766, 481, + 482, -542, 766, 766, -542, -542 }; /* YYPGOTO[NTERM-NUM]. */ static const short int yypgoto[] = { - -541, -541, -541, 379, 380, 381, 161, 162, 386, 388, - -128, -127, -540, -541, 438, 456, -111, -541, -277, 63, - -541, -297, -541, -47, -541, -37, -541, -53, 40, -541, - -99, 264, -307, 84, -541, -541, -541, -541, -541, -541, - -541, 435, -541, -541, -541, -541, 8, -541, 68, -541, - -541, 427, -541, -541, -541, -541, -541, 487, -541, -541, - -489, -199, 67, -124, -541, 472, -541, -103, -541, -541, - -541, -541, 71, -7, -541, -541, 33, -541, -541 + -542, -542, -542, 435, 439, 441, 191, 197, 442, 445, + -119, -116, -541, -542, 478, 489, -107, -542, -267, 37, + -542, -238, -542, -60, -542, -45, -542, -74, -51, -542, + -101, 300, -252, 134, -542, -542, -542, -542, -542, -542, + -542, 473, -542, -542, -542, -542, 8, -542, 46, -542, + -542, 410, -542, -542, -542, -542, -542, -542, 518, -542, + -542, -542, -528, 142, -90, -113, -542, 505, -542, -72, + -542, -542, -542, -542, 97, 28, -542, -542, 70, -542, + -542 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If @@ -2572,358 +2919,338 @@ static const short int yypgoto[] = #define YYTABLE_NINF -180 static const short int yytable[] = { - 88, 235, 249, 250, 238, 371, 105, 115, 393, 394, - 93, 26, 223, 454, 39, 239, 88, 576, 406, 408, - 252, 42, 432, 334, 302, 434, 417, 240, 4, 123, - 303, 119, 46, 47, 48, 360, 455, 588, 415, 283, - 360, 360, 287, 288, 289, 290, 291, 292, 293, 26, - 426, 49, 360, 241, 242, 243, 244, 245, 246, 247, - 248, -179, 465, 119, 433, 297, 298, 433, 39, 119, - 470, 205, 206, 207, 241, 242, 243, 244, 245, 246, - 247, 248, 299, 228, 29, 360, 5, 586, 234, 53, - 228, 234, 6, 229, 121, 360, 360, 360, 469, 594, - 339, 51, 7, 8, 9, 10, 11, 12, 13, -112, - 7, 8, 9, 10, 54, 12, 55, 416, 123, 56, - 106, 107, 123, 14, 281, 282, 234, 284, 285, 234, - 234, 234, 234, 234, 234, 234, -139, 52, -112, 109, - 110, 111, 59, 94, 60, 465, -139, 123, 465, 294, - 295, 296, 234, 234, 43, 471, 227, 465, 515, 20, - 505, 21, 232, 466, 58, 116, 360, 360, 360, 264, - 265, 336, 337, 62, 360, 340, 64, 389, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 360, 360, - 465, 198, 199, 342, 300, 301, 307, 308, 482, -72, - -72, 98, 575, -71, -71, 365, -70, -70, -69, -69, - 99, 531, 100, 532, 101, 88, 30, 31, 32, 33, - 34, 35, 36, 587, 309, 310, 366, 133, 134, 102, - -113, 113, 114, 360, 122, 360, 197, 201, 202, 360, - 203, 224, 236, 367, 230, 225, -76, 360, 360, 360, - -75, 439, 387, 441, 442, 443, -74, -73, -79, 312, - 338, 449, 88, 388, 234, -80, 313, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 346, 347, 368, 360, 360, 370, 360, 360, 373, - 386, 374, 375, 340, 360, 390, 376, 377, 460, 461, - 462, 463, 464, 360, 378, 409, 362, 363, 379, 380, - 381, 472, 473, 474, 475, 476, 385, 391, 364, 241, - 242, 243, 244, 245, 246, 247, 248, 418, 397, 398, - 399, 400, 401, 410, 411, 412, 360, 413, 234, 440, - 234, 234, 234, 444, 445, 414, 421, 422, 234, 450, - 419, 372, 468, 424, 427, 428, 438, 435, 454, 506, - 507, 382, 383, 384, 446, 458, 513, 481, 447, 483, - 448, 536, 537, 538, 459, 360, 453, 484, 486, 485, - 489, 501, 487, 493, 342, 495, 503, 496, 497, 504, - 360, 509, 510, 511, 512, 520, 521, 360, 234, 554, - 516, 360, 360, 517, 514, 543, 548, 555, 433, 559, - 544, 545, 546, 547, 518, 519, 502, 549, 550, 551, - 552, 523, 530, 533, 557, 535, 541, 542, 556, 249, - 250, 565, 429, 430, 431, 558, 560, 567, 562, 566, - 437, 568, 563, 564, 574, 569, 578, 570, 234, 249, - 250, 571, 572, 573, 451, 452, 580, 579, 234, 234, - 234, 581, 589, 590, 234, 593, 582, 591, 583, 584, - 592, 596, 597, 600, 601, 186, 187, 188, 395, 96, - 396, 57, 189, 553, 190, 479, 333, 104, 112, 478, - 27, 45, 598, 508, 539, 0, 234, 0, -82, 488, - 20, 490, 21, 0, 0, 494, 492, 0, 0, 6, - -82, -82, 0, 498, 499, 500, 0, 0, 0, -82, - -82, -82, -82, -82, -82, -82, 0, 0, -82, 22, - 0, 0, 0, 0, 0, 0, 23, 0, 65, 66, - 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 524, 525, 0, 528, 529, 20, 0, 21, 0, 314, - 534, 0, 0, 0, 0, 0, 0, 0, 0, 540, - 0, 315, 316, 0, 0, 0, 0, 0, 0, 0, + 97, 241, 227, 110, 242, 230, 223, 361, 197, 31, + 111, 26, 449, 4, 244, 204, 34, 578, 97, 201, + 74, 75, 426, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 428, 88, 20, 590, 21, + 275, 26, 31, 279, 280, 281, 282, 283, 284, 285, + 588, 233, 234, 235, 236, 237, 238, 239, 240, 205, + 206, 207, 596, 89, 427, 43, 289, 290, 390, 391, + 226, 463, 300, 226, 403, 405, 291, 427, 452, 468, + 74, 75, 301, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 420, 88, 20, 412, 21, + 448, 453, 38, 39, 40, 204, 273, 274, 226, 276, + 277, 226, 226, 226, 226, 226, 226, 226, 225, 463, + 20, 41, 21, 89, 201, 231, 300, 480, -139, 201, + -112, 286, 287, 288, 226, 226, 384, 232, -139, 204, + 294, 352, 353, 112, 29, 463, 295, 299, 44, 35, + 467, 464, 303, 354, 233, 234, 235, 236, 237, 238, + 239, 240, -179, 463, 463, 54, 198, -112, 51, 90, + 52, 71, 91, 469, 513, 92, 204, 93, 200, 50, + 379, 105, 106, 107, 355, 67, 362, 5, 102, 103, + 188, 189, 68, 6, 292, 293, 372, 373, 374, 97, + 577, 308, 309, 7, 8, 9, 10, 11, 12, 13, + 356, -72, -72, -71, -71, -70, -70, 503, 69, 531, + 70, 532, 381, 382, 14, 109, 385, 357, 187, 90, + 191, 377, 91, -69, -69, 92, -113, 93, 298, 56, + 57, 58, 59, 60, 61, 62, 97, 378, 226, 310, + 311, 192, 433, 45, 435, 436, 437, 123, 124, 193, + 195, 196, 443, 203, 228, 423, 424, 425, 296, 297, + -76, -75, -74, 431, 7, 8, 9, 10, 46, 12, + 47, -73, -79, 48, 313, -80, 314, 445, 446, 363, + 358, 337, 414, 458, 459, 460, 461, 462, 360, 364, + 365, 366, 367, 589, 368, 369, 470, 471, 472, 473, + 474, 370, 385, 371, 375, 380, 383, 376, 386, 387, + 226, 434, 226, 226, 226, 438, 439, 394, 466, 388, + 226, 444, 395, 396, 397, 406, 486, 398, 488, 407, + 408, 409, 492, 410, 411, 418, 421, 422, 429, 432, + 496, 497, 498, 440, 441, 504, 505, 450, 456, 442, + 447, 479, 511, 481, 335, 478, 457, 477, 350, 482, + 483, 484, 485, 350, 350, 487, 491, 493, 494, 502, + 536, 537, 538, 499, 226, 350, 501, 495, 518, 507, + 508, 524, 525, 509, 528, 529, 510, 514, 515, 512, + 516, 534, 500, 517, 452, 523, 544, 545, 546, 547, + 540, 530, 533, 549, 550, 551, 552, 535, 350, 543, + 560, 548, 475, 541, 542, 554, 556, 557, 350, 350, + 350, 427, 414, 558, 575, 576, 566, 568, 226, 241, + 564, 565, 242, 559, 561, 562, 563, 569, 226, 226, + 226, 567, 570, 571, 226, 572, 256, 257, 573, 574, + 241, 580, 582, 242, 581, 584, 583, 585, 586, 591, + 592, 593, 594, 553, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 595, 598, 587, 599, 226, 233, + 234, 235, 236, 237, 238, 239, 240, 350, 350, 350, + 176, 597, 602, 603, 177, 350, 178, 179, 601, 392, + 180, 65, 604, 605, 49, 521, 393, 73, 224, 350, + 350, 27, 334, 520, 37, 600, 490, 539, 506, 0, + 0, 0, 0, 0, 74, 75, 0, 199, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 0, + 88, 20, 0, 21, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 350, 0, + 350, 74, 75, 0, 350, 0, 0, 89, 0, 0, + 0, 0, 350, 350, 350, 0, 0, -82, 20, 20, + 21, 21, 315, 0, 0, 0, 0, 0, 6, -82, + -82, 0, 0, 0, 316, 317, 0, 0, -82, -82, + -82, -82, -82, -82, -82, 0, 0, -82, 22, 0, + 0, 0, 0, 350, 350, 23, 350, 350, 0, 24, + 0, 0, 0, 350, 0, 0, 0, 0, 0, 0, + 0, 0, 350, 0, 0, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 318, + 319, 0, 0, 0, 0, 0, 320, 350, 321, 0, + 322, 323, 324, 90, 0, 0, 91, 0, 0, 92, + 0, 93, 404, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 350, 0, + 0, 0, 0, 325, 0, 0, 326, 0, 327, 0, + 0, 328, 0, 350, 0, 0, 0, 0, 0, 0, + 350, 0, 0, 0, 350, 350, 74, 75, 0, 199, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 0, 88, 20, 0, 21, 0, 0, 0, 338, + 339, 74, 75, 340, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 20, 89, + 21, 0, 341, 342, 343, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 344, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 561, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 317, 318, 0, 0, - 0, 585, 0, 319, 0, 320, 0, 321, 322, 323, - 0, 0, 0, 0, 0, 0, 595, 0, 0, 0, - 0, 0, 0, 599, 0, 0, 0, 602, 603, 0, - 0, 0, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 0, 0, 0, 0, 0, - 324, 0, 0, 325, 0, 326, 65, 66, 327, 117, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 0, 79, 20, 0, 21, 65, 66, 0, 117, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 0, 79, 20, 0, 21, 0, 65, 66, 80, - 117, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 0, 79, 20, 0, 21, 65, 66, 80, - 117, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 0, 79, 20, 0, 21, 0, 0, 0, - 80, 0, 65, 66, 0, 117, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 0, 79, 20, - 80, 21, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 231, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 80, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 318, + 319, 0, 0, 0, 0, 0, 320, 0, 321, 0, + 322, 323, 324, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 90, 338, 339, 91, 0, + 340, 92, 0, 93, 465, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 0, 341, + 342, 343, 0, 0, 0, 0, 347, 0, 0, 0, + 0, 344, 345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 81, 0, 0, 82, 0, - 0, 83, 0, 84, 118, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 81, 0, 0, 82, 0, - 0, 83, 0, 84, 226, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 81, 0, 0, 82, - 0, 0, 83, 0, 84, 407, 0, 348, 349, 65, - 66, 350, 0, 0, 0, 0, 81, 0, 0, 82, - 0, 0, 83, 0, 84, 467, 20, 0, 21, 0, - 351, 352, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 81, 354, 355, 82, 0, 0, 83, 0, 84, + 0, 0, 0, 0, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 356, 0, 0, 0, 0, + 0, 0, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 318, 319, 0, 0, + 0, 0, 0, 320, 0, 321, 0, 322, 323, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 317, 318, 0, - 0, 0, 0, 0, 319, 0, 320, 0, 321, 322, - 323, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 348, 349, 0, 0, 350, 0, 0, - 0, 0, 0, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 351, 352, 353, 0, - 0, 0, 0, 0, 357, 0, 0, 0, 354, 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 0, 0, 0, 0, 0, + 0, 74, 75, 347, 199, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 0, 88, 20, 0, + 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 302, 0, 0, 0, 0, 0, 0, + 0, 0, 74, 75, 89, 199, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 0, 88, 20, + 0, 21, 74, 75, 0, 199, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 0, 88, 20, + 0, 21, 0, 0, 0, 89, 0, 0, 0, 0, + 0, 0, 0, 0, 413, 0, 0, 0, 0, 0, + 0, 0, 0, 74, 75, 89, 199, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 0, 88, + 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 451, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, + 74, 75, 0, 199, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 0, 88, 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 317, 318, 0, 0, 0, 0, 0, - 319, 0, 320, 0, 321, 322, 323, 0, 0, 0, + 0, 90, 519, 0, 91, 0, 399, 92, 0, 93, + 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, + 0, 90, 0, 0, 91, 0, 0, 92, 0, 93, + 74, 75, 0, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 0, 88, 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 0, 0, 0, 0, 0, 0, 65, 66, - 357, 117, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 0, 79, 20, 0, 21, 0, 0, + 0, 0, 90, 0, 0, 91, 0, 0, 92, 0, + 93, 74, 75, 89, 199, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 0, 88, 20, 0, + 21, 74, 75, 0, 199, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 0, 88, 20, 0, + 21, 0, 0, 0, 89, 0, 0, 0, 0, 90, + 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, + 0, 0, 74, 75, 89, 229, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 0, 88, 20, + 0, 21, 74, 75, 0, 199, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 0, 88, 20, + 0, 21, 0, 0, 0, 89, 0, 0, 0, 90, + 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, + 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 341, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 66, 80, 117, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 0, 79, 20, 0, 21, 65, - 66, 0, 117, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 0, 79, 20, 0, 21, 0, - 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, - 0, 423, 0, 0, 0, 0, 0, 0, 0, 0, - 65, 66, 80, 117, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 0, 79, 20, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 477, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 80, 0, 0, 0, 81, 0, 0, - 82, 0, 0, 83, 0, 84, 65, 66, 0, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 0, 79, 20, 0, 21, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 81, 0, - 0, 82, 0, 402, 83, 0, 84, 0, 0, 80, - 0, 0, 0, 0, 0, 0, 0, 0, 81, 0, - 0, 82, 0, 0, 83, 0, 84, 65, 66, 0, - 117, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 0, 79, 20, 0, 21, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 81, - 0, 0, 82, 0, 0, 83, 0, 84, 65, 66, - 80, 117, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 0, 79, 20, 0, 21, 65, 66, - 0, 237, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 0, 79, 20, 0, 21, 0, 0, - 0, 80, 0, 0, 0, 81, 0, 0, 82, 0, - 0, 83, 0, 84, 0, 0, 0, 0, 0, 65, - 66, 80, 117, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 0, 79, 20, 0, 21, 0, + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 90, 0, 0, 91, 0, 0, 92, 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 80, 0, 0, 0, 81, 0, 0, 82, - 0, 0, 83, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 114, 0, 0, 0, 0, 0, + 0, 90, 0, 0, 91, 0, 0, 92, 115, 93, + 0, 0, 0, 0, 0, 0, 0, 0, 116, 117, + 0, 90, 0, 0, 91, 0, 0, 92, 0, 402, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 0, 0, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, - 82, 0, 0, 83, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, - 82, 0, 0, 83, 0, 84, 0, 0, 0, 0, - 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 125, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 126, 127, 0, 0, 81, 0, - 0, 82, 0, 0, 83, 0, 405, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 0, 0, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185 + 0, 0, 0, 0, 0, 0, 0, 0, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175 }; static const short int yycheck[] = { - 37, 125, 130, 130, 128, 282, 53, 4, 305, 306, - 29, 3, 111, 34, 23, 9, 53, 557, 325, 326, - 131, 30, 15, 222, 153, 15, 161, 21, 0, 164, - 159, 84, 52, 53, 54, 234, 57, 577, 335, 163, - 239, 240, 166, 167, 168, 169, 170, 171, 172, 41, - 357, 71, 251, 10, 11, 12, 13, 14, 15, 16, - 17, 0, 153, 116, 57, 189, 190, 57, 23, 122, - 161, 108, 109, 110, 10, 11, 12, 13, 14, 15, - 16, 17, 193, 153, 61, 284, 25, 576, 125, 20, - 153, 128, 31, 163, 86, 294, 295, 296, 405, 588, - 163, 152, 41, 42, 43, 44, 45, 46, 47, 155, - 41, 42, 43, 44, 45, 46, 47, 159, 164, 50, - 32, 33, 164, 62, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 153, 61, 155, 55, - 56, 57, 45, 162, 47, 153, 163, 164, 153, 186, - 187, 188, 189, 190, 163, 163, 116, 153, 163, 22, - 457, 24, 122, 159, 152, 162, 365, 366, 367, 27, - 28, 224, 225, 24, 373, 228, 4, 301, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 387, 388, - 153, 55, 56, 230, 108, 109, 27, 28, 161, 3, - 4, 152, 159, 3, 4, 252, 3, 4, 3, 4, - 152, 488, 152, 490, 152, 252, 64, 65, 66, 67, - 68, 69, 70, 159, 3, 4, 263, 77, 78, 157, - 155, 4, 4, 432, 155, 434, 24, 4, 24, 438, - 24, 158, 59, 280, 155, 158, 4, 446, 447, 448, - 4, 375, 299, 377, 378, 379, 4, 4, 7, 4, - 161, 385, 299, 300, 301, 7, 7, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 153, 156, 153, 483, 484, 153, 486, 487, 157, - 36, 153, 153, 346, 493, 24, 153, 153, 397, 398, - 399, 400, 401, 502, 153, 24, 239, 240, 153, 153, - 153, 410, 411, 412, 413, 414, 153, 153, 251, 10, - 11, 12, 13, 14, 15, 16, 17, 161, 155, 155, - 155, 155, 155, 155, 155, 155, 535, 155, 375, 376, - 377, 378, 379, 380, 381, 155, 153, 156, 385, 386, - 342, 284, 405, 63, 153, 153, 157, 153, 34, 458, - 459, 294, 295, 296, 153, 155, 465, 24, 153, 21, - 153, 495, 496, 497, 155, 574, 153, 21, 153, 155, - 4, 155, 153, 153, 421, 153, 24, 153, 153, 4, - 589, 153, 153, 153, 153, 36, 57, 596, 435, 4, - 153, 600, 601, 153, 161, 156, 161, 24, 57, 533, - 509, 510, 511, 512, 153, 153, 453, 516, 517, 518, - 519, 153, 153, 153, 157, 153, 153, 153, 153, 557, - 557, 153, 365, 366, 367, 156, 159, 153, 156, 156, - 373, 153, 541, 542, 21, 156, 36, 156, 485, 577, - 577, 156, 156, 156, 387, 388, 156, 159, 495, 496, - 497, 156, 21, 156, 501, 153, 565, 156, 567, 568, - 156, 21, 153, 21, 21, 96, 96, 96, 317, 41, - 318, 25, 96, 520, 96, 422, 222, 52, 61, 421, - 3, 19, 595, 460, 501, -1, 533, -1, 20, 432, - 22, 434, 24, -1, -1, 438, 435, -1, -1, 31, - 32, 33, -1, 446, 447, 448, -1, -1, -1, 41, - 42, 43, 44, 45, 46, 47, -1, -1, 50, 51, - -1, -1, -1, -1, -1, -1, 58, -1, 5, 6, - 62, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 483, 484, -1, 486, 487, 22, -1, 24, -1, 26, - 493, -1, -1, -1, -1, -1, -1, -1, -1, 502, + 45, 120, 115, 63, 120, 118, 107, 274, 4, 23, + 29, 3, 161, 0, 121, 164, 30, 558, 63, 93, + 5, 6, 15, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 15, 21, 22, 579, 24, + 153, 33, 23, 156, 157, 158, 159, 160, 161, 162, + 578, 10, 11, 12, 13, 14, 15, 16, 17, 104, + 105, 106, 590, 48, 57, 152, 179, 180, 306, 307, + 115, 153, 153, 118, 326, 327, 183, 57, 34, 161, + 5, 6, 163, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 347, 21, 22, 336, 24, + 159, 57, 52, 53, 54, 164, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 110, 153, + 22, 71, 24, 48, 198, 9, 153, 161, 153, 203, + 155, 176, 177, 178, 179, 180, 163, 21, 163, 164, + 153, 231, 232, 162, 61, 153, 159, 198, 61, 163, + 402, 159, 203, 243, 10, 11, 12, 13, 14, 15, + 16, 17, 0, 153, 153, 24, 162, 155, 45, 154, + 47, 157, 157, 163, 163, 160, 164, 162, 163, 152, + 293, 47, 48, 49, 244, 152, 276, 25, 32, 33, + 55, 56, 152, 31, 108, 109, 286, 287, 288, 244, + 159, 27, 28, 41, 42, 43, 44, 45, 46, 47, + 255, 3, 4, 3, 4, 3, 4, 455, 152, 486, + 152, 488, 296, 297, 62, 4, 300, 272, 24, 154, + 4, 291, 157, 3, 4, 160, 155, 162, 163, 64, + 65, 66, 67, 68, 69, 70, 291, 292, 293, 3, + 4, 24, 365, 20, 367, 368, 369, 77, 78, 24, + 4, 4, 375, 155, 59, 355, 356, 357, 158, 158, + 4, 4, 4, 363, 41, 42, 43, 44, 45, 46, + 47, 4, 7, 50, 4, 7, 7, 377, 378, 157, + 153, 155, 337, 394, 395, 396, 397, 398, 153, 153, + 153, 153, 153, 159, 153, 153, 407, 408, 409, 410, + 411, 153, 386, 153, 153, 24, 161, 36, 153, 156, + 365, 366, 367, 368, 369, 370, 371, 155, 402, 153, + 375, 376, 155, 155, 155, 24, 426, 155, 428, 155, + 155, 155, 432, 155, 155, 63, 153, 153, 153, 157, + 440, 441, 442, 153, 153, 456, 457, 161, 155, 153, + 153, 24, 463, 21, 222, 156, 155, 153, 226, 21, + 155, 153, 153, 231, 232, 4, 153, 153, 153, 4, + 493, 494, 495, 155, 429, 243, 24, 153, 36, 153, + 153, 481, 482, 153, 484, 485, 153, 153, 153, 161, + 153, 491, 447, 153, 34, 153, 507, 508, 509, 510, + 500, 153, 153, 514, 515, 516, 517, 153, 276, 156, + 533, 161, 414, 153, 153, 57, 24, 153, 286, 287, + 288, 57, 477, 157, 4, 21, 153, 153, 483, 558, + 541, 542, 558, 156, 159, 535, 156, 153, 493, 494, + 495, 156, 156, 156, 499, 156, 27, 28, 156, 156, + 579, 36, 156, 579, 159, 566, 156, 568, 569, 21, + 156, 156, 156, 518, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 153, 21, 576, 153, 533, 10, + 11, 12, 13, 14, 15, 16, 17, 355, 356, 357, + 65, 591, 21, 21, 65, 363, 65, 65, 598, 318, + 65, 33, 602, 603, 25, 478, 319, 44, 108, 377, + 378, 3, 222, 477, 19, 597, 429, 499, 458, -1, + -1, -1, -1, -1, 5, 6, -1, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, + 21, 22, -1, 24, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 426, -1, + 428, 5, 6, -1, 432, -1, -1, 48, -1, -1, + -1, -1, 440, 441, 442, -1, -1, 20, 22, 22, + 24, 24, 26, -1, -1, -1, -1, -1, 31, 32, + 33, -1, -1, -1, 38, 39, -1, -1, 41, 42, + 43, 44, 45, 46, 47, -1, -1, 50, 51, -1, + -1, -1, -1, 481, 482, 58, 484, 485, -1, 62, + -1, -1, -1, 491, -1, -1, -1, -1, -1, -1, + -1, -1, 500, -1, -1, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, -1, -1, -1, -1, -1, 110, 535, 112, -1, + 114, 115, 116, 154, -1, -1, 157, -1, -1, 160, + -1, 162, 163, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 576, -1, + -1, -1, -1, 157, -1, -1, 160, -1, 162, -1, + -1, 165, -1, 591, -1, -1, -1, -1, -1, -1, + 598, -1, -1, -1, 602, 603, 5, 6, -1, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, -1, 21, 22, -1, 24, -1, -1, -1, 3, + 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 48, + 24, -1, 26, 27, 28, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 38, 39, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 61, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, -1, -1, -1, -1, -1, 110, -1, 112, -1, + 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 154, 3, 4, 157, -1, + 7, 160, -1, 162, 163, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, -1, 26, + 27, 28, -1, -1, -1, -1, 160, -1, -1, -1, -1, 38, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 61, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 535, -1, -1, -1, -1, -1, -1, -1, -1, -1, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, -1, -1, - -1, 574, -1, 110, -1, 112, -1, 114, 115, 116, - -1, -1, -1, -1, -1, -1, 589, -1, -1, -1, - -1, -1, -1, 596, -1, -1, -1, 600, 601, -1, + -1, -1, -1, 110, -1, 112, -1, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, -1, -1, -1, -1, -1, - 157, -1, -1, 160, -1, 162, 5, 6, 165, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, -1, 21, 22, -1, 24, 5, 6, -1, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, -1, 21, 22, -1, 24, -1, 5, 6, 48, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, -1, 21, 22, -1, 24, 5, 6, 48, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, - 48, -1, 5, 6, -1, 8, 9, 10, 11, 12, + -1, 5, 6, 160, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, 5, 6, 48, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, - 48, 24, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 24, 5, 6, -1, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 48, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 154, -1, -1, 157, -1, - -1, 160, -1, 162, 163, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 154, -1, -1, 157, -1, - -1, 160, -1, 162, 163, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 154, -1, -1, 157, - -1, -1, 160, -1, 162, 163, -1, 3, 4, 5, - 6, 7, -1, -1, -1, -1, 154, -1, -1, 157, - -1, -1, 160, -1, 162, 163, 22, -1, 24, -1, - 26, 27, 28, -1, -1, -1, -1, -1, -1, -1, - -1, 154, 38, 39, 157, -1, -1, 160, -1, 162, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 61, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, -1, - -1, -1, -1, -1, 110, -1, 112, -1, 114, 115, - 116, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 3, 4, -1, -1, 7, -1, -1, - -1, -1, -1, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 26, 27, 28, -1, - -1, -1, -1, -1, 160, -1, -1, -1, 38, 39, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 61, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, -1, -1, -1, -1, -1, - 110, -1, 112, -1, 114, 115, 116, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, -1, -1, -1, -1, -1, -1, 5, 6, - 160, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, + -1, -1, -1, 5, 6, 48, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, -1, 21, + 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 48, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, + 5, 6, -1, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 37, -1, -1, -1, -1, -1, -1, -1, -1, 5, - 6, 48, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, -1, 21, 22, -1, 24, 5, - 6, -1, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, - -1, -1, 48, -1, -1, -1, -1, -1, -1, -1, - -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, - 5, 6, 48, 8, 9, 10, 11, 12, 13, 14, + -1, 154, 37, -1, 157, -1, 159, 160, -1, 162, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, 154, -1, -1, 157, -1, -1, 160, -1, 162, + 5, 6, -1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 37, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 48, -1, -1, -1, 154, -1, -1, - 157, -1, -1, 160, -1, 162, 5, 6, -1, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, -1, 21, 22, -1, 24, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 154, -1, - -1, 157, -1, 159, 160, -1, 162, -1, -1, 48, - -1, -1, -1, -1, -1, -1, -1, -1, 154, -1, - -1, 157, -1, -1, 160, -1, 162, 5, 6, -1, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, -1, 21, 22, -1, 24, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 154, - -1, -1, 157, -1, -1, 160, -1, 162, 5, 6, - 48, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, -1, 21, 22, -1, 24, 5, 6, - -1, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, -1, 21, 22, -1, 24, -1, -1, - -1, 48, -1, -1, -1, 154, -1, -1, 157, -1, - -1, 160, -1, 162, -1, -1, -1, -1, -1, 5, - 6, 48, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, -1, 21, 22, -1, 24, -1, + -1, -1, 154, -1, -1, 157, -1, -1, 160, -1, + 162, 5, 6, 48, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, 5, 6, -1, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, -1, 21, 22, -1, + 24, -1, -1, -1, 48, -1, -1, -1, -1, 154, + -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, + -1, -1, 5, 6, 48, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, 5, 6, -1, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, -1, 21, 22, + -1, 24, -1, -1, -1, 48, -1, -1, -1, 154, + -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, + -1, -1, -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 48, -1, -1, -1, 154, -1, -1, 157, - -1, -1, 160, -1, 162, -1, -1, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 154, -1, -1, 157, -1, -1, 160, -1, 162, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 154, -1, -1, - 157, -1, -1, 160, -1, 162, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 154, -1, -1, - 157, -1, -1, 160, -1, 162, -1, -1, -1, -1, - 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 49, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, 60, -1, -1, 154, -1, - -1, 157, -1, -1, 160, -1, 162, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, -1, -1, 110, 111, 112, 113, 114, - 115, 116, 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151 + -1, -1, -1, -1, 35, -1, -1, -1, -1, -1, + -1, 154, -1, -1, 157, -1, -1, 160, 49, 162, + -1, -1, -1, -1, -1, -1, -1, -1, 59, 60, + -1, 154, -1, -1, 157, -1, -1, 160, -1, 162, + -1, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, -1, -1, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -2931,66 +3258,66 @@ static const short int yycheck[] = static const unsigned char yystos[] = { 0, 200, 201, 202, 0, 25, 31, 41, 42, 43, - 44, 45, 46, 47, 62, 181, 219, 221, 223, 230, - 22, 24, 51, 58, 62, 180, 212, 223, 224, 61, - 64, 65, 66, 67, 68, 69, 70, 182, 217, 23, - 231, 232, 30, 163, 220, 231, 52, 53, 54, 71, - 209, 152, 61, 20, 45, 47, 50, 181, 152, 45, - 47, 222, 24, 207, 4, 5, 6, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, - 48, 154, 157, 160, 162, 167, 189, 190, 191, 192, - 193, 212, 227, 29, 162, 218, 180, 236, 152, 152, - 152, 152, 157, 210, 207, 189, 32, 33, 199, 199, - 199, 199, 217, 4, 4, 4, 162, 8, 163, 193, - 194, 212, 155, 164, 35, 49, 59, 60, 72, 73, + 44, 45, 46, 47, 62, 181, 219, 222, 224, 232, + 22, 24, 51, 58, 62, 180, 212, 224, 225, 61, + 220, 23, 233, 234, 30, 163, 221, 233, 52, 53, + 54, 71, 209, 152, 61, 20, 45, 47, 50, 181, + 152, 45, 47, 223, 24, 207, 64, 65, 66, 67, + 68, 69, 70, 182, 217, 180, 238, 152, 152, 152, + 152, 157, 210, 207, 5, 6, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 21, 48, + 154, 157, 160, 162, 167, 189, 190, 191, 192, 193, + 212, 229, 32, 33, 199, 199, 199, 199, 226, 4, + 189, 29, 162, 218, 35, 49, 59, 60, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 110, 111, 112, 113, 114, 115, 116, 117, 118, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 169, 170, 171, 174, - 175, 233, 234, 240, 241, 243, 244, 24, 55, 56, - 208, 4, 24, 24, 211, 191, 191, 191, 9, 10, + 175, 235, 236, 242, 243, 245, 246, 24, 55, 56, + 208, 4, 24, 24, 211, 4, 4, 4, 162, 8, + 163, 193, 194, 155, 164, 191, 191, 191, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 176, - 177, 179, 191, 196, 158, 158, 163, 194, 153, 163, - 155, 37, 194, 195, 191, 229, 59, 8, 229, 9, - 21, 10, 11, 12, 13, 14, 15, 16, 17, 176, - 177, 178, 182, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 172, 27, 28, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 173, 191, 191, 229, 191, 191, 237, 229, 229, 229, - 229, 229, 229, 229, 191, 191, 191, 229, 229, 182, - 108, 109, 153, 159, 205, 206, 204, 27, 28, 3, - 4, 168, 4, 7, 26, 38, 39, 103, 104, 110, - 112, 114, 115, 116, 157, 160, 162, 165, 169, 170, - 171, 174, 175, 197, 227, 203, 193, 193, 161, 163, - 193, 37, 191, 214, 215, 216, 153, 156, 3, 4, - 7, 26, 27, 28, 38, 39, 61, 160, 197, 226, - 227, 228, 228, 228, 228, 189, 191, 191, 153, 184, - 153, 184, 228, 157, 153, 153, 153, 153, 153, 153, - 153, 153, 228, 228, 228, 153, 36, 189, 191, 229, - 24, 153, 187, 187, 187, 172, 173, 155, 155, 155, - 155, 155, 159, 196, 198, 162, 198, 163, 198, 24, - 155, 155, 155, 155, 155, 187, 159, 161, 161, 212, - 213, 153, 156, 37, 63, 225, 198, 153, 153, 228, - 228, 228, 15, 57, 15, 153, 242, 228, 157, 229, - 191, 229, 229, 229, 191, 191, 153, 153, 153, 229, - 191, 228, 228, 153, 34, 57, 185, 188, 155, 155, - 196, 196, 196, 196, 196, 153, 159, 163, 193, 198, - 161, 163, 196, 196, 196, 196, 196, 37, 214, 185, - 186, 24, 161, 21, 21, 155, 153, 153, 228, 4, - 228, 229, 238, 153, 228, 153, 153, 153, 228, 228, - 228, 155, 191, 24, 4, 187, 196, 196, 242, 153, - 153, 153, 153, 196, 161, 163, 153, 153, 153, 153, - 36, 57, 183, 153, 228, 228, 238, 239, 228, 228, - 153, 184, 184, 153, 228, 153, 229, 229, 229, 239, - 228, 153, 153, 156, 196, 196, 196, 196, 161, 196, - 196, 196, 196, 191, 4, 24, 153, 157, 156, 229, - 159, 228, 156, 196, 196, 153, 156, 153, 153, 156, - 156, 156, 156, 156, 21, 159, 178, 235, 36, 159, - 156, 156, 196, 196, 196, 228, 226, 159, 178, 21, - 156, 156, 156, 153, 226, 228, 21, 153, 233, 228, - 21, 21, 228, 228 + 177, 179, 191, 196, 217, 212, 191, 231, 59, 8, + 231, 9, 21, 10, 11, 12, 13, 14, 15, 16, + 17, 176, 177, 178, 182, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 172, 27, 28, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 173, 191, 191, 231, 191, 191, 239, 231, + 231, 231, 231, 231, 231, 231, 191, 191, 191, 231, + 231, 182, 108, 109, 153, 159, 158, 158, 163, 194, + 153, 163, 37, 194, 195, 205, 206, 204, 27, 28, + 3, 4, 168, 4, 7, 26, 38, 39, 103, 104, + 110, 112, 114, 115, 116, 157, 160, 162, 165, 169, + 170, 171, 174, 175, 197, 229, 203, 155, 3, 4, + 7, 26, 27, 28, 38, 39, 61, 160, 197, 228, + 229, 230, 230, 230, 230, 189, 191, 191, 153, 184, + 153, 184, 230, 157, 153, 153, 153, 153, 153, 153, + 153, 153, 230, 230, 230, 153, 36, 189, 191, 231, + 24, 193, 193, 161, 163, 193, 153, 156, 153, 187, + 187, 187, 172, 173, 155, 155, 155, 155, 155, 159, + 196, 198, 162, 198, 163, 198, 24, 155, 155, 155, + 155, 155, 187, 37, 191, 214, 215, 216, 63, 227, + 198, 153, 153, 230, 230, 230, 15, 57, 15, 153, + 244, 230, 157, 231, 191, 231, 231, 231, 191, 191, + 153, 153, 153, 231, 191, 230, 230, 153, 159, 161, + 161, 37, 34, 57, 185, 188, 155, 155, 196, 196, + 196, 196, 196, 153, 159, 163, 193, 198, 161, 163, + 196, 196, 196, 196, 196, 212, 213, 153, 156, 24, + 161, 21, 21, 155, 153, 153, 230, 4, 230, 231, + 240, 153, 230, 153, 153, 153, 230, 230, 230, 155, + 191, 24, 4, 187, 196, 196, 244, 153, 153, 153, + 153, 196, 161, 163, 153, 153, 153, 153, 36, 37, + 214, 185, 186, 153, 230, 230, 240, 241, 230, 230, + 153, 184, 184, 153, 230, 153, 231, 231, 231, 241, + 230, 153, 153, 156, 196, 196, 196, 196, 161, 196, + 196, 196, 196, 191, 57, 183, 24, 153, 157, 156, + 231, 159, 230, 156, 196, 196, 153, 156, 153, 153, + 156, 156, 156, 156, 156, 4, 21, 159, 178, 237, + 36, 159, 156, 156, 196, 196, 196, 230, 228, 159, + 178, 21, 156, 156, 156, 153, 228, 230, 21, 153, + 235, 230, 21, 21, 230, 230 }; #define yyerrok (yyerrstatus = 0) @@ -3660,7 +3987,7 @@ yyreduce: switch (yyn) { case 3: -#line 1576 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1916 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range! error("Value too large for type"); @@ -3669,7 +3996,7 @@ yyreduce: break; case 5: -#line 1585 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1925 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range! error("Value too large for type"); @@ -3678,240 +4005,240 @@ yyreduce: break; case 26: -#line 1607 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1947 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_EQ; ;} break; case 27: -#line 1607 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1947 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_NE; ;} break; case 28: -#line 1608 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1948 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_SLT; ;} break; case 29: -#line 1608 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1948 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_SGT; ;} break; case 30: -#line 1609 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_SLE; ;} break; case 31: -#line 1609 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_SGE; ;} break; case 32: -#line 1610 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_ULT; ;} break; case 33: -#line 1610 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_UGT; ;} break; case 34: -#line 1611 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1951 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_ULE; ;} break; case 35: -#line 1611 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1951 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.IPred) = ICmpInst::ICMP_UGE; ;} break; case 36: -#line 1615 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1955 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;} break; case 37: -#line 1615 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1955 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_ONE; ;} break; case 38: -#line 1616 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1956 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_OLT; ;} break; case 39: -#line 1616 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1956 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_OGT; ;} break; case 40: -#line 1617 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1957 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_OLE; ;} break; case 41: -#line 1617 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1957 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_OGE; ;} break; case 42: -#line 1618 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1958 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_ORD; ;} break; case 43: -#line 1618 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1958 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_UNO; ;} break; case 44: -#line 1619 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1959 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;} break; case 45: -#line 1619 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1959 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_UNE; ;} break; case 46: -#line 1620 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1960 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_ULT; ;} break; case 47: -#line 1620 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1960 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_UGT; ;} break; case 48: -#line 1621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1961 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_ULE; ;} break; case 49: -#line 1621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1961 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_UGE; ;} break; case 50: -#line 1622 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1962 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;} break; case 51: -#line 1623 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1963 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;} break; case 81: -#line 1654 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1994 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.StrVal) = (yyvsp[-1].StrVal); ;} break; case 82: -#line 1657 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 1997 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.StrVal) = 0; ;} break; case 83: -#line 1662 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2002 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} break; case 84: -#line 1663 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2003 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} break; case 85: -#line 1664 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2004 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} break; case 86: -#line 1665 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2005 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;} break; case 87: -#line 1666 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2006 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} break; case 88: -#line 1667 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2007 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} break; case 89: -#line 1668 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2008 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} break; case 90: -#line 1669 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2009 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 91: -#line 1673 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;} +#line 2013 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::C; ;} break; case 92: -#line 1674 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;} +#line 2014 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::C; ;} break; case 93: -#line 1675 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::CSRet; ;} +#line 2015 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::CSRet; ;} break; case 94: -#line 1676 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Fast; ;} +#line 2016 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::Fast; ;} break; case 95: -#line 1677 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Cold; ;} +#line 2017 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::Cold; ;} break; case 96: -#line 1678 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;} +#line 2018 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::X86_StdCall; ;} break; case 97: -#line 1679 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;} +#line 2019 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.UIntVal) = lastCallingConv = OldCallingConv::X86_FastCall; ;} break; case 98: -#line 1680 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2020 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val)) error("Calling conv too large"); - (yyval.UIntVal) = (yyvsp[0].UInt64Val); + (yyval.UIntVal) = lastCallingConv = (yyvsp[0].UInt64Val); ;} break; case 99: -#line 1690 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2030 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.UIntVal) = 0; ;} break; case 100: -#line 1691 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2031 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.UIntVal) = (yyvsp[0].UInt64Val); if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) @@ -3920,12 +4247,12 @@ yyreduce: break; case 101: -#line 1699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2039 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.UIntVal) = 0; ;} break; case 102: -#line 1700 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2040 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.UIntVal) = (yyvsp[0].UInt64Val); if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) @@ -3934,7 +4261,7 @@ yyreduce: break; case 103: -#line 1708 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2048 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i) if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\') @@ -3944,27 +4271,27 @@ yyreduce: break; case 104: -#line 1717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2057 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.StrVal) = 0; ;} break; case 105: -#line 1718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2058 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.StrVal) = (yyvsp[0].StrVal); ;} break; case 106: -#line 1725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2065 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" {;} break; case 107: -#line 1726 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2066 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" {;} break; case 108: -#line 1730 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2070 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurGV->setSection((yyvsp[0].StrVal)); free((yyvsp[0].StrVal)); @@ -3972,7 +4299,7 @@ yyreduce: break; case 109: -#line 1734 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2074 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val))) error("Alignment must be a power of two"); @@ -3982,177 +4309,188 @@ yyreduce: break; case 111: -#line 1751 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2091 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.makeSignless(); ;} break; case 113: -#line 1759 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2099 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.makeSignless(); ;} break; case 114: -#line 1766 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2106 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!UpRefs.empty()) - error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).T)->getDescription()); + error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription()); (yyval.TypeVal) = (yyvsp[0].TypeVal); ;} break; case 127: -#line 1780 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2120 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T); - (yyval.TypeVal).S = (yyvsp[0].PrimType).S; + (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T); + (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S); ;} break; case 128: -#line 1784 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TypeVal).T = new PATypeHolder(OpaqueType::get()); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get()); + (yyval.TypeVal).S.makeSignless(); ;} break; case 129: -#line 1788 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2128 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Named types are also simple types... + (yyval.TypeVal).S.copy(getTypeSign((yyvsp[0].ValIDVal))); const Type* tmp = getType((yyvsp[0].ValIDVal)); - (yyval.TypeVal).T = new PATypeHolder(tmp); - (yyval.TypeVal).S = Signless; // FIXME: what if its signed? + (yyval.TypeVal).PAT = new PATypeHolder(tmp); ;} break; case 130: -#line 1793 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2133 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Type UpReference if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) error("Value out of range"); OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector... - (yyval.TypeVal).T = new PATypeHolder(OT); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder(OT); + (yyval.TypeVal).S.makeSignless(); UR_OUT("New Upreference!\n"); ;} break; case 131: -#line 1802 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2142 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Function derived type? + (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S); std::vector Params; for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(), E = (yyvsp[-1].TypeList)->end(); I != E; ++I) { - Params.push_back(I->T->get()); - delete I->T; - } - FunctionType::ParamAttrsList ParamAttrs; - if (CurFun.LastCC == OldCallingConv::CSRet) { - ParamAttrs.push_back(FunctionType::NoAttributeSet); - ParamAttrs.push_back(FunctionType::StructRetAttribute); + Params.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); } bool isVarArg = Params.size() && Params.back() == Type::VoidTy; if (isVarArg) Params.pop_back(); - (yyval.TypeVal).T = new PATypeHolder( - HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).T->get(),Params,isVarArg, ParamAttrs))); - (yyval.TypeVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; // Delete the return type handle + 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); + } + + const FunctionType *FTy = + FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg, PAL); + + (yyval.TypeVal).PAT = new PATypeHolder( HandleUpRefs(FTy, (yyval.TypeVal).S) ); + delete (yyvsp[-3].TypeVal).PAT; // Delete the return type handle delete (yyvsp[-1].TypeList); // Delete the argument list ;} break; case 132: -#line 1823 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2169 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Sized array type? - (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).T->get(), - (unsigned)(yyvsp[-3].UInt64Val)))); - (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).PAT->get(), + (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 133: -#line 1829 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { // Packed array type? - const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).T->get(); - if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val)) - error("Unsigned result not equal to signed result"); - if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint())) - error("Elements of a PackedType must be integer or floating point"); - if (!isPowerOf2_32((yyvsp[-3].UInt64Val))) - error("PackedType length should be a power of 2"); - (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy, - (unsigned)(yyvsp[-3].UInt64Val)))); - (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; +#line 2175 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { // Vector type? + const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).PAT->get(); + if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val)) + 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((yyvsp[-3].UInt64Val))) + error("VectorType length should be a power of 2"); + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy, + (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 134: -#line 1842 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2188 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Structure type? std::vector Elements; + (yyval.TypeVal).S.makeComposite(); for (std::list::iterator I = (yyvsp[-1].TypeList)->begin(), - E = (yyvsp[-1].TypeList)->end(); I != E; ++I) - Elements.push_back(I->T->get()); - (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements))); - (yyval.TypeVal).S = Signless; + E = (yyvsp[-1].TypeList)->end(); I != E; ++I) { + Elements.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); + } + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), (yyval.TypeVal).S)); delete (yyvsp[-1].TypeList); ;} break; case 135: -#line 1851 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2199 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Empty structure type? - (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector())); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector())); + (yyval.TypeVal).S.makeComposite(); ;} break; case 136: -#line 1855 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2203 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Packed Structure type? + (yyval.TypeVal).S.makeComposite(); std::vector Elements; for (std::list::iterator I = (yyvsp[-2].TypeList)->begin(), E = (yyvsp[-2].TypeList)->end(); I != E; ++I) { - Elements.push_back(I->T->get()); - delete I->T; + Elements.push_back(I->PAT->get()); + (yyval.TypeVal).S.add(I->S); + delete I->PAT; } - (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true))); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true), + (yyval.TypeVal).S)); delete (yyvsp[-2].TypeList); ;} break; case 137: -#line 1866 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2216 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Empty packed structure type? - (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector(),true)); - (yyval.TypeVal).S = Signless; + (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector(),true)); + (yyval.TypeVal).S.makeComposite(); ;} break; case 138: -#line 1870 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2220 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Pointer type? - if ((yyvsp[-1].TypeVal).T->get() == Type::LabelTy) + if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy) error("Cannot form a pointer to a basic block"); - (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).T->get()))); - (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S); + (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).PAT->get()), + (yyval.TypeVal).S)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 139: -#line 1883 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2234 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.TypeList) = new std::list(); (yyval.TypeList)->push_back((yyvsp[0].TypeVal)); @@ -4160,47 +4498,47 @@ yyreduce: break; case 140: -#line 1887 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2238 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal)); ;} break; case 142: -#line 1895 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2246 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { PATypeInfo VoidTI; - VoidTI.T = new PATypeHolder(Type::VoidTy); - VoidTI.S = Signless; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI); ;} break; case 143: -#line 1901 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2252 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.TypeList) = new std::list(); PATypeInfo VoidTI; - VoidTI.T = new PATypeHolder(Type::VoidTy); - VoidTI.S = Signless; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); (yyval.TypeList)->push_back(VoidTI); ;} break; case 144: -#line 1908 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2259 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.TypeList) = new std::list(); ;} break; case 145: -#line 1920 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2271 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Nonempty unsized arr - const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal).T->get()); + const ArrayType *ATy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); if (ATy == 0) error("Cannot make array constant with type: '" + - (yyvsp[-3].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); const Type *ETy = ATy->getElementType(); int NumElements = ATy->getNumElements(); @@ -4222,36 +4560,36 @@ yyreduce: Elems.push_back(C); } (yyval.ConstVal).C = ConstantArray::get(ATy, Elems); - (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; delete (yyvsp[-1].ConstVector); ;} break; case 146: -#line 1950 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2301 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).T->get()); + const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); if (ATy == 0) error("Cannot make array constant with type: '" + - (yyvsp[-2].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-2].TypeVal).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) +""); (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector()); - (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S; - delete (yyvsp[-2].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 147: -#line 1963 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).T->get()); + const ArrayType *ATy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); if (ATy == 0) error("Cannot make array constant with type: '" + - (yyvsp[-2].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'"); int NumElements = ATy->getNumElements(); const Type *ETy = dyn_cast(ATy->getElementType()); if (!ETy || cast(ETy)->getBitWidth() != 8) @@ -4267,18 +4605,18 @@ yyreduce: Vals.push_back(ConstantInt::get(ETy, *C)); free((yyvsp[0].StrVal)); (yyval.ConstVal).C = ConstantArray::get(ATy, Vals); - (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S; - delete (yyvsp[-2].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 148: -#line 1986 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2337 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Nonempty unsized arr - const PackedType *PTy = dyn_cast((yyvsp[-3].TypeVal).T->get()); + const VectorType *PTy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); if (PTy == 0) error("Cannot make packed constant with type: '" + - (yyvsp[-3].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); const Type *ETy = PTy->getElementType(); int NumElements = PTy->getNumElements(); // Verify that we have the correct size... @@ -4297,20 +4635,20 @@ yyreduce: ValTy->getDescription() + "'"); Elems.push_back(C); } - (yyval.ConstVal).C = ConstantPacked::get(PTy, Elems); - (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; + (yyval.ConstVal).C = ConstantVector::get(PTy, Elems); + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; delete (yyvsp[-1].ConstVector); ;} break; case 149: -#line 2014 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2365 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const StructType *STy = dyn_cast((yyvsp[-3].TypeVal).T->get()); + const StructType *STy = dyn_cast((yyvsp[-3].TypeVal).PAT->get()); if (STy == 0) error("Cannot make struct constant with type: '" + - (yyvsp[-3].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'"); if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes()) error("Illegal number of initializers for structure type"); @@ -4324,34 +4662,34 @@ yyreduce: Fields.push_back(C); } (yyval.ConstVal).C = ConstantStruct::get(STy, Fields); - (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; delete (yyvsp[-1].ConstVector); ;} break; case 150: -#line 2036 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2387 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const StructType *STy = dyn_cast((yyvsp[-2].TypeVal).T->get()); + const StructType *STy = dyn_cast((yyvsp[-2].TypeVal).PAT->get()); if (STy == 0) error("Cannot make struct constant with type: '" + - (yyvsp[-2].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'"); if (STy->getNumContainedTypes() != 0) error("Illegal number of initializers for structure type"); (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector()); - (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S; - delete (yyvsp[-2].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S); + delete (yyvsp[-2].TypeVal).PAT; ;} break; case 151: -#line 2047 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2398 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const StructType *STy = dyn_cast((yyvsp[-5].TypeVal).T->get()); + const StructType *STy = dyn_cast((yyvsp[-5].TypeVal).PAT->get()); if (STy == 0) error("Cannot make packed struct constant with type: '" + - (yyvsp[-5].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'"); if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes()) error("Illegal number of initializers for packed structure type"); @@ -4365,56 +4703,56 @@ yyreduce: Fields.push_back(C); } (yyval.ConstVal).C = ConstantStruct::get(STy, Fields); - (yyval.ConstVal).S = (yyvsp[-5].TypeVal).S; - delete (yyvsp[-5].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S); + delete (yyvsp[-5].TypeVal).PAT; delete (yyvsp[-2].ConstVector); ;} break; case 152: -#line 2069 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2420 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const StructType *STy = dyn_cast((yyvsp[-4].TypeVal).T->get()); + const StructType *STy = dyn_cast((yyvsp[-4].TypeVal).PAT->get()); if (STy == 0) error("Cannot make packed struct constant with type: '" + - (yyvsp[-4].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-4].TypeVal).PAT->get()->getDescription() + "'"); if (STy->getNumContainedTypes() != 0) error("Illegal number of initializers for packed structure type"); (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector()); - (yyval.ConstVal).S = (yyvsp[-4].TypeVal).S; - delete (yyvsp[-4].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S); + delete (yyvsp[-4].TypeVal).PAT; ;} break; case 153: -#line 2080 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2431 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).T->get()); + const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); if (PTy == 0) error("Cannot make null pointer constant with type: '" + - (yyvsp[-1].TypeVal).T->get()->getDescription() + "'"); + (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'"); (yyval.ConstVal).C = ConstantPointerNull::get(PTy); - (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 154: -#line 2089 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2440 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).T->get()); - (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).PAT->get()); + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 155: -#line 2094 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2445 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal).T->get()); + const PointerType *Ty = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); if (Ty == 0) error("Global const reference must be a pointer type, not" + - (yyvsp[-1].TypeVal).T->get()->getDescription()); + (yyvsp[-1].TypeVal).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 @@ -4425,6 +4763,7 @@ yyreduce: // Function *SavedCurFn = CurFun.CurrentFunction; CurFun.CurrentFunction = 0; + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal)); CurFun.CurrentFunction = SavedCurFn; @@ -4465,89 +4804,89 @@ yyreduce: } } (yyval.ConstVal).C = cast(V); - (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; // Free the type handle + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; // Free the type handle ;} break; case 156: -#line 2152 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2504 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if ((yyvsp[-1].TypeVal).T->get() != (yyvsp[0].ConstVal).C->getType()) + if ((yyvsp[-1].TypeVal).PAT->get() != (yyvsp[0].ConstVal).C->getType()) error("Mismatched types for constant expression"); (yyval.ConstVal) = (yyvsp[0].ConstVal); - (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 157: -#line 2159 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-1].TypeVal).T->get(); + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) error("Cannot create a null initialized value of this type"); (yyval.ConstVal).C = Constant::getNullValue(Ty); - (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S; - delete (yyvsp[-1].TypeVal).T; + (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 158: -#line 2167 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2519 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // integral constants const Type *Ty = (yyvsp[-1].PrimType).T; if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val))) error("Constant value doesn't fit in type"); (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val)); - (yyval.ConstVal).S = Signed; + (yyval.ConstVal).S.makeSigned(); ;} break; case 159: -#line 2174 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2526 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // integral constants const Type *Ty = (yyvsp[-1].PrimType).T; if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val))) error("Constant value doesn't fit in type"); (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val)); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 160: -#line 2181 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2533 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Boolean constants (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 161: -#line 2185 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2537 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Boolean constants (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 162: -#line 2189 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2541 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Float & Double constants if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal))) error("Floating point constant invalid for type"); (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)); - (yyval.ConstVal).S = Signless; + (yyval.ConstVal).S.makeSignless(); ;} break; case 163: -#line 2198 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2550 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType(); - const Type* DstTy = (yyvsp[-1].TypeVal).T->get(); - Signedness SrcSign = (yyvsp[-3].ConstVal).S; - Signedness DstSign = (yyvsp[-1].TypeVal).S; + const Type* DstTy = (yyvsp[-1].TypeVal).PAT->get(); + Signedness SrcSign((yyvsp[-3].ConstVal).S); + Signedness DstSign((yyvsp[-1].TypeVal).S); if (!SrcTy->isFirstClassType()) error("cast constant expression from a non-primitive type: '" + SrcTy->getDescription() + "'"); @@ -4555,30 +4894,29 @@ yyreduce: error("cast constant expression to a non-primitive type: '" + DstTy->getDescription() + "'"); (yyval.ConstVal).C = cast(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign)); - (yyval.ConstVal).S = DstSign; - delete (yyvsp[-1].TypeVal).T; + (yyval.ConstVal).S.copy(DstSign); + delete (yyvsp[-1].TypeVal).PAT; ;} break; case 164: -#line 2213 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2565 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type *Ty = (yyvsp[-2].ConstVal).C->getType(); if (!isa(Ty)) error("GetElementPtr requires a pointer operand"); - std::vector VIndices; std::vector CIndices; - upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices); + upgradeGEPCEIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), CIndices); delete (yyvsp[-1].ValueList); - (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, CIndices); - (yyval.ConstVal).S = Signless; + (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, &CIndices[0], CIndices.size()); + (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices)); ;} break; case 165: -#line 2226 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2577 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() || cast((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1) @@ -4586,12 +4924,12 @@ yyreduce: if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) error("Select operand types must match"); (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 166: -#line 2235 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2586 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type *Ty = (yyvsp[-3].ConstVal).C->getType(); if (Ty != (yyvsp[-1].ConstVal).C->getType()) @@ -4618,29 +4956,29 @@ yyreduce: ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy)); (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty); } - (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 167: -#line 2263 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2614 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type* Ty = (yyvsp[-3].ConstVal).C->getType(); if (Ty != (yyvsp[-1].ConstVal).C->getType()) error("Logical operator types must match"); if (!Ty->isInteger()) { - if (!isa(Ty) || - !cast(Ty)->getElementType()->isInteger()) + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) error("Logical operator requires integer operands"); } Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S); (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 168: -#line 2276 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2627 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type* Ty = (yyvsp[-3].ConstVal).C->getType(); if (Ty != (yyvsp[-1].ConstVal).C->getType()) @@ -4648,32 +4986,32 @@ yyreduce: unsigned short pred; Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S); (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 169: -#line 2285 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2636 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) error("icmp operand types must match"); (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 170: -#line 2291 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2642 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType()) error("fcmp operand types must match"); (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = Unsigned; + (yyval.ConstVal).S.makeUnsigned(); ;} break; case 171: -#line 2297 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2648 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() || cast((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8) @@ -4683,47 +5021,47 @@ yyreduce: error("Shift constant expression requires integer operand"); Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty); (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt); - (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S); ;} break; case 172: -#line 2308 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2659 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) error("Invalid extractelement operands"); (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S.get(0)); ;} break; case 173: -#line 2314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2665 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) error("Invalid insertelement operands"); (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S); ;} break; case 174: -#line 2320 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2671 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C)) error("Invalid shufflevector operands"); (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C); - (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S; + (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S); ;} break; case 175: -#line 2331 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2682 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;} break; case 176: -#line 2332 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2683 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ConstVector) = new std::vector(); (yyval.ConstVector)->push_back((yyvsp[0].ConstVal)); @@ -4731,17 +5069,17 @@ yyreduce: break; case 177: -#line 2341 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2692 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = false; ;} break; case 178: -#line 2342 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2693 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = true; ;} break; case 179: -#line 2354 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2705 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal); CurModule.ModuleDone(); @@ -4749,27 +5087,27 @@ yyreduce: break; case 180: -#line 2363 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2714 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;} break; case 181: -#line 2364 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2715 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;} break; case 182: -#line 2365 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2716 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;} break; case 183: -#line 2366 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;} break; case 184: -#line 2367 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ModuleVal) = CurModule.CurrentModule; // Emit an error if there are any unresolved types left. @@ -4785,7 +5123,7 @@ yyreduce: break; case 185: -#line 2383 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2734 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Eagerly resolve types. This is not an optimization, this is a // requirement that is due to the fact that we could have this: @@ -4796,115 +5134,118 @@ yyreduce: // If types are not resolved eagerly, then the two types will not be // determined to be the same type! // - const Type* Ty = (yyvsp[0].TypeVal).T->get(); - ResolveTypeTo((yyvsp[-2].StrVal), Ty); + ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S); - if (!setTypeName(Ty, (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) { - // If this is a named type that is not a redefinition, add it to the slot - // table. - CurModule.Types.push_back(Ty); + if (!setTypeName((yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) { + // If this is a numbered type that is not a redefinition, add it to the + // slot table. + CurModule.Types.push_back((yyvsp[0].TypeVal).PAT->get()); + CurModule.TypeSigns.push_back((yyvsp[0].TypeVal).S); } - delete (yyvsp[0].TypeVal).T; + delete (yyvsp[0].TypeVal).PAT; ;} break; case 186: -#line 2403 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2754 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Function prototypes can be in const pool ;} break; case 187: -#line 2405 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2756 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Asm blocks can be in the const pool ;} break; case 188: -#line 2407 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2758 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].ConstVal).C == 0) error("Global value initializer is not a constant"); - CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C, (yyvsp[0].ConstVal).S); ;} break; case 189: -#line 2411 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2762 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurGV = 0; ;} break; case 190: -#line 2414 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2765 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[0].TypeVal).T->get(); - CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0); - delete (yyvsp[0].TypeVal).T; + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; case 191: -#line 2418 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2770 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurGV = 0; ;} break; case 192: -#line 2421 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2773 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[0].TypeVal).T->get(); - CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0); - delete (yyvsp[0].TypeVal).T; + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); + CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; case 193: -#line 2425 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2778 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurGV = 0; ;} break; case 194: -#line 2428 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2781 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[0].TypeVal).T->get(); + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); CurGV = - ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0); - delete (yyvsp[0].TypeVal).T; + ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0, + (yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; case 195: -#line 2433 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2787 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurGV = 0; ;} break; case 196: -#line 2436 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2790 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ;} break; case 197: -#line 2438 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2792 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ;} break; case 198: -#line 2440 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2794 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ;} break; case 199: -#line 2445 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2799 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true); @@ -4919,24 +5260,24 @@ yyreduce: break; case 200: -#line 2459 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2813 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Endianness) = Module::BigEndian; ;} break; case 201: -#line 2460 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2814 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.Endianness) = Module::LittleEndian; ;} break; case 202: -#line 2464 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2818 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurModule.setEndianness((yyvsp[0].Endianness)); ;} break; case 203: -#line 2467 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2821 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].UInt64Val) == 32) CurModule.setPointerSize(Module::Pointer32); @@ -4948,7 +5289,7 @@ yyreduce: break; case 204: -#line 2475 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2829 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal)); free((yyvsp[0].StrVal)); @@ -4956,7 +5297,7 @@ yyreduce: break; case 205: -#line 2479 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2833 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal)); free((yyvsp[0].StrVal)); @@ -4964,7 +5305,7 @@ yyreduce: break; case 207: -#line 2490 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2844 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal)); free((yyvsp[0].StrVal)); @@ -4972,7 +5313,7 @@ yyreduce: break; case 208: -#line 2494 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2848 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal)); free((yyvsp[0].StrVal)); @@ -4980,26 +5321,26 @@ yyreduce: break; case 209: -#line 2498 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2852 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { ;} break; case 213: -#line 2511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2865 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.StrVal) = 0; ;} break; case 214: -#line 2515 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2869 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - if ((yyvsp[-1].TypeVal).T->get() == Type::VoidTy) + if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy) error("void typed arguments are invalid"); (yyval.ArgVal) = new std::pair((yyvsp[-1].TypeVal), (yyvsp[0].StrVal)); ;} break; case 215: -#line 2523 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2877 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = (yyvsp[-2].ArgList); (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal)); @@ -5008,7 +5349,7 @@ yyreduce: break; case 216: -#line 2528 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2882 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = new std::vector >(); (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal)); @@ -5017,83 +5358,89 @@ yyreduce: break; case 217: -#line 2536 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2890 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = (yyvsp[0].ArgList); ;} break; case 218: -#line 2537 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2891 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = (yyvsp[-2].ArgList); PATypeInfo VoidTI; - VoidTI.T = new PATypeHolder(Type::VoidTy); - VoidTI.S = Signless; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); (yyval.ArgList)->push_back(std::pair(VoidTI, 0)); ;} break; case 219: -#line 2544 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2898 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = new std::vector >(); PATypeInfo VoidTI; - VoidTI.T = new PATypeHolder(Type::VoidTy); - VoidTI.S = Signless; + VoidTI.PAT = new PATypeHolder(Type::VoidTy); + VoidTI.S.makeSignless(); (yyval.ArgList)->push_back(std::pair(VoidTI, 0)); ;} break; case 220: -#line 2551 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2905 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ArgList) = 0; ;} break; case 221: -#line 2555 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 2909 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { UnEscapeLexed((yyvsp[-5].StrVal)); std::string FunctionName((yyvsp[-5].StrVal)); free((yyvsp[-5].StrVal)); // Free strdup'd memory! - const Type* RetTy = (yyvsp[-6].TypeVal).T->get(); + const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get(); if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) error("LLVM functions cannot return aggregate types"); - std::vector ParamTypeList; + Signedness FTySign; + FTySign.makeComposite((yyvsp[-6].TypeVal).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") { - ParamTypeList.push_back(PointerType::get(Type::Int8Ty)); + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); } else if (FunctionName == "llvm.va_copy") { - ParamTypeList.push_back(PointerType::get(Type::Int8Ty)); - ParamTypeList.push_back(PointerType::get(Type::Int8Ty)); + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); + ParamTyList.push_back(PointerType::get(Type::Int8Ty)); } else if ((yyvsp[-3].ArgList)) { // If there are arguments... for (std::vector >::iterator I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) { - const Type *Ty = I->first.T->get(); - ParamTypeList.push_back(Ty); + const Type *Ty = I->first.PAT->get(); + ParamTyList.push_back(Ty); + FTySign.add(I->first.S); } } - bool isVarArg = - ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; - if (isVarArg) ParamTypeList.pop_back(); + bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy; + if (isVarArg) + ParamTyList.pop_back(); // Convert the CSRet calling convention into the corresponding parameter // attribute. - FunctionType::ParamAttrsList ParamAttrs; + ParamAttrsList *PAL = 0; if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) { - ParamAttrs.push_back(FunctionType::NoAttributeSet); // result - ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg + ParamAttrsVector Attrs; + ParamAttrsWithIndex PAWI; + PAWI.index = 1; PAWI.attrs = ParamAttr::StructRet; // first arg + Attrs.push_back(PAWI); + PAL = ParamAttrsList::get(Attrs); } - const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg, - ParamAttrs); + const FunctionType *FT = + FunctionType::get(RetTy, ParamTyList, isVarArg, PAL); const PointerType *PFT = PointerType::get(FT); - delete (yyvsp[-6].TypeVal).T; + delete (yyvsp[-6].TypeVal).PAT; ValID ID; if (!FunctionName.empty()) { @@ -5101,34 +5448,99 @@ yyreduce: } 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); - CurModule.CurrentModule->getFunctionList().remove(Fn); - CurModule.CurrentModule->getFunctionList().push_back(Fn); - } else if (!FunctionName.empty() && // Merge with an earlier prototype? - (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) { - // If this is the case, either we need to be a forward decl, or it needs - // to be. - if (!CurFun.isDeclare && !Fn->isDeclaration()) - error("Redefinition of function '" + FunctionName + "'"); - - // 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 { // Not already defined? - Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName, - CurModule.CurrentModule); - + 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); } + CurFun.FunctionStart(Fn); if (CurFun.isDeclare) { @@ -5147,58 +5559,77 @@ yyreduce: // Add all of the arguments we parsed to the function... if ((yyvsp[-3].ArgList)) { // Is null if empty... if (isVarArg) { // Nuke the last entry - assert((yyvsp[-3].ArgList)->back().first.T->get() == Type::VoidTy && + assert((yyvsp[-3].ArgList)->back().first.PAT->get() == Type::VoidTy && (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker"); - delete (yyvsp[-3].ArgList)->back().first.T; + delete (yyvsp[-3].ArgList)->back().first.PAT; (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry } Function::arg_iterator ArgIt = Fn->arg_begin(); - for (std::vector >::iterator - I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I, ++ArgIt) { - delete I->first.T; // Delete the typeholder... - setValueName(ArgIt, I->second); // Insert arg into symtab... + Function::arg_iterator ArgEnd = Fn->arg_end(); + std::vector >::iterator I = (yyvsp[-3].ArgList)->begin(); + std::vector >::iterator E = (yyvsp[-3].ArgList)->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 (yyvsp[-3].ArgList); // We're now done with the argument list } + lastCallingConv = OldCallingConv::C; ;} break; case 224: -#line 2674 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.Linkage = (yyvsp[0].Linkage); ;} + break; + + case 225: +#line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FunctionVal) = CurFun.CurrentFunction; // Make sure that we keep track of the linkage type even if there was a // previous "declare". - (yyval.FunctionVal)->setLinkage((yyvsp[-2].Linkage)); + (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage)); ;} break; - case 227: -#line 2688 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 228: +#line 3117 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); ;} break; case 229: -#line 2694 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.Linkage = GlobalValue::DLLImportLinkage; ;} +#line 3122 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 230: -#line 2695 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; ;} +#line 3123 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} break; case 231: -#line 2699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { CurFun.isDeclare = true; ;} +#line 3124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} break; case 232: -#line 2699 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3128 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.isDeclare = true; ;} + break; + + case 233: +#line 3129 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { CurFun.Linkage = (yyvsp[0].Linkage); ;} + break; + + case 234: +#line 3129 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FunctionVal) = CurFun.CurrentFunction; CurFun.FunctionDone(); @@ -5206,64 +5637,70 @@ yyreduce: ;} break; - case 233: -#line 2711 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 235: +#line 3141 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = false; ;} break; - case 234: -#line 2712 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 236: +#line 3142 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = true; ;} break; - case 235: -#line 2717 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;} + case 237: +#line 3147 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;} break; - case 236: -#line 2718 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 238: +#line 3148 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;} break; - case 237: -#line 2719 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 239: +#line 3149 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;} break; - case 238: -#line 2720 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); ;} + case 240: +#line 3150 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); + (yyval.ValIDVal).S.makeUnsigned(); + ;} break; - case 239: -#line 2721 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); ;} + case 241: +#line 3154 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); + (yyval.ValIDVal).S.makeUnsigned(); + ;} break; - case 240: -#line 2722 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 242: +#line 3158 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::createNull(); ;} break; - case 241: -#line 2723 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 243: +#line 3159 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::createUndef(); ;} break; - case 242: -#line 2724 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 244: +#line 3160 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::createZeroInit(); ;} break; - case 243: -#line 2725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 245: +#line 3161 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Nonempty unsized packed vector const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType(); int NumElements = (yyvsp[-1].ConstVector)->size(); - PackedType* pt = PackedType::get(ETy, NumElements); - PATypeHolder* PTy = new PATypeHolder( - HandleUpRefs(PackedType::get(ETy, NumElements))); + VectorType* pt = VectorType::get(ETy, NumElements); + (yyval.ValIDVal).S.makeComposite((*(yyvsp[-1].ConstVector))[0].S); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, (yyval.ValIDVal).S)); // Verify all elements are correct type! std::vector Elems; @@ -5276,20 +5713,21 @@ yyreduce: CTy->getDescription() + "'"); Elems.push_back(C); } - (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, Elems)); + (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems)); delete PTy; delete (yyvsp[-1].ConstVector); ;} break; - case 244: -#line 2746 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 246: +#line 3182 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C); + (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S); ;} break; - case 245: -#line 2749 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 247: +#line 3186 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { char *End = UnEscapeLexed((yyvsp[-2].StrVal), true); std::string AsmStr = std::string((yyvsp[-2].StrVal), End); @@ -5301,53 +5739,55 @@ yyreduce: ;} break; - case 246: -#line 2764 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); ;} + case 248: +#line 3200 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;} break; - case 247: -#line 2765 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" - { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); ;} + case 249: +#line 3201 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;} break; - case 250: -#line 2778 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 252: +#line 3214 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-1].TypeVal).T->get(); - (yyval.ValueVal).S = (yyvsp[-1].TypeVal).S; + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal)); - delete (yyvsp[-1].TypeVal).T; + (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S); + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 251: -#line 2787 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 253: +#line 3224 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); ;} break; - case 252: -#line 2790 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 254: +#line 3227 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Do not allow functions with 0 basic blocks (yyval.FunctionVal) = (yyvsp[-1].FunctionVal); ;} break; - case 253: -#line 2799 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 255: +#line 3236 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal)); - InsertValue((yyvsp[0].TermInstVal)); - (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal)); + ValueInfo VI; VI.V = (yyvsp[0].TermInstVal).TI; VI.S.copy((yyvsp[0].TermInstVal).S); + setValueName(VI, (yyvsp[-1].StrVal)); + InsertValue((yyvsp[0].TermInstVal).TI); + (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal).TI); InsertValue((yyvsp[-2].BasicBlockVal)); (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal); ;} break; - case 254: -#line 2809 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 256: +#line 3247 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if ((yyvsp[0].InstVal).I) (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I); @@ -5355,10 +5795,10 @@ yyreduce: ;} break; - case 255: -#line 2814 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 257: +#line 3252 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true); + (yyval.BasicBlockVal) = 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. @@ -5368,8 +5808,8 @@ yyreduce: ;} break; - case 256: -#line 2823 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 258: +#line 3261 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true); // Make sure to move the basic block to the correct location in the @@ -5381,45 +5821,55 @@ yyreduce: ;} break; - case 259: -#line 2837 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 261: +#line 3275 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Return with a result... - (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal).V); + (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 260: -#line 2840 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 262: +#line 3279 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Return with no result... - (yyval.TermInstVal) = new ReturnInst(); + (yyval.TermInstVal).TI = new ReturnInst(); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 261: -#line 2843 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 263: +#line 3283 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Unconditional Branch... BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); - (yyval.TermInstVal) = new BranchInst(tmpBB); + (yyval.TermInstVal).TI = new BranchInst(tmpBB); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 262: -#line 2847 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 264: +#line 3288 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { + (yyvsp[-3].ValIDVal).S.makeSignless(); + (yyvsp[0].ValIDVal).S.makeSignless(); BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal)); BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal)); + (yyvsp[-6].ValIDVal).S.makeUnsigned(); Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal)); - (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal); + (yyval.TermInstVal).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 263: -#line 2853 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 265: +#line 3298 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { + (yyvsp[-6].ValIDVal).S.copy((yyvsp[-7].PrimType).S); Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal)); + (yyvsp[-3].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal)); SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size()); - (yyval.TermInstVal) = S; + (yyval.TermInstVal).TI = S; + (yyval.TermInstVal).S.makeSignless(); std::vector >::iterator I = (yyvsp[-1].JumpTable)->begin(), E = (yyvsp[-1].JumpTable)->end(); for (; I != E; ++I) { @@ -5432,48 +5882,67 @@ yyreduce: ;} break; - case 264: -#line 2868 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 266: +#line 3316 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { + (yyvsp[-5].ValIDVal).S.copy((yyvsp[-6].PrimType).S); Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal)); + (yyvsp[-2].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal)); SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0); - (yyval.TermInstVal) = S; + (yyval.TermInstVal).TI = S; + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 265: -#line 2875 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 267: +#line 3326 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const PointerType *PFTy; const FunctionType *Ty; + Signedness FTySign; - if (!(PFTy = dyn_cast((yyvsp[-10].TypeVal).T->get())) || + if (!(PFTy = dyn_cast((yyvsp[-10].TypeVal).PAT->get())) || !(Ty = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; + FTySign.makeComposite((yyvsp[-10].TypeVal).S); if ((yyvsp[-7].ValueList)) { for (std::vector::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end(); - I != E; ++I) + I != E; ++I) { ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } } - FunctionType::ParamAttrsList ParamAttrs; + ParamAttrsList *PAL = 0; if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) { - ParamAttrs.push_back(FunctionType::NoAttributeSet); - ParamAttrs.push_back(FunctionType::StructRetAttribute); + 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((yyvsp[-10].TypeVal).T->get(), ParamTypes, isVarArg, ParamAttrs); + Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, PAL); PFTy = PointerType::get(Ty); + (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S); + } else { + FTySign = (yyvsp[-10].TypeVal).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. + (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S.get(0).get(0)); } + + (yyvsp[-9].ValIDVal).S.makeComposite(FTySign); Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling... BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal)); BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal)); // Create the call node... if (!(yyvsp[-7].ValueList)) { // Has no arguments? - (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, std::vector()); + (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, 0, 0); } else { // Has arguments? // Loop through FunctionType's arguments and ensure they are specified // correctly! @@ -5493,58 +5962,65 @@ yyreduce: if (I != E || (ArgI != ArgE && !Ty->isVarArg())) error("Invalid number of parameters detected"); - (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, Args); + (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); } - cast((yyval.TermInstVal))->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal))); - delete (yyvsp[-10].TypeVal).T; + cast((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal))); + delete (yyvsp[-10].TypeVal).PAT; delete (yyvsp[-7].ValueList); + lastCallingConv = OldCallingConv::C; ;} break; - case 266: -#line 2930 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 268: +#line 3398 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TermInstVal) = new UnwindInst(); + (yyval.TermInstVal).TI = new UnwindInst(); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 267: -#line 2933 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 269: +#line 3402 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - (yyval.TermInstVal) = new UnreachableInst(); + (yyval.TermInstVal).TI = new UnreachableInst(); + (yyval.TermInstVal).S.makeSignless(); ;} break; - case 268: -#line 2939 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 270: +#line 3409 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.JumpTable) = (yyvsp[-5].JumpTable); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S); Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal))); if (V == 0) error("May only switch on a constant pool value"); + (yyvsp[0].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); ;} break; - case 269: -#line 2949 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 271: +#line 3421 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.JumpTable) = new std::vector >(); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S); Constant *V = cast(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal))); if (V == 0) error("May only switch on a constant pool value"); + (yyvsp[0].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal)); (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); ;} break; - case 270: -#line 2962 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 272: +#line 3436 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { bool omit = false; if ((yyvsp[-1].StrVal)) @@ -5566,81 +6042,88 @@ yyreduce: omit = true; if (omit) { (yyval.InstVal).I = 0; - (yyval.InstVal).S = Signless; + (yyval.InstVal).S.makeSignless(); } else { - setValueName((yyvsp[0].InstVal).I, (yyvsp[-1].StrVal)); + ValueInfo VI; VI.V = (yyvsp[0].InstVal).I; VI.S.copy((yyvsp[0].InstVal).S); + setValueName(VI, (yyvsp[-1].StrVal)); InsertValue((yyvsp[0].InstVal).I); (yyval.InstVal) = (yyvsp[0].InstVal); } ;} break; - case 271: -#line 2991 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 273: +#line 3466 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Used for PHI nodes (yyval.PHIList).P = new std::list >(); - (yyval.PHIList).S = (yyvsp[-5].TypeVal).S; - Value* tmpVal = getVal((yyvsp[-5].TypeVal).T->get(), (yyvsp[-3].ValIDVal)); + (yyval.PHIList).S.copy((yyvsp[-5].TypeVal).S); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-5].TypeVal).S); + Value* tmpVal = getVal((yyvsp[-5].TypeVal).PAT->get(), (yyvsp[-3].ValIDVal)); + (yyvsp[-1].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal)); (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB)); - delete (yyvsp[-5].TypeVal).T; + delete (yyvsp[-5].TypeVal).PAT; ;} break; - case 272: -#line 2999 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 274: +#line 3476 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.PHIList) = (yyvsp[-6].PHIList); + (yyvsp[-3].ValIDVal).S.copy((yyvsp[-6].PHIList).S); Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal)); + (yyvsp[-1].ValIDVal).S.makeSignless(); BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal)); (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB)); ;} break; - case 273: -#line 3007 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 275: +#line 3486 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { // Used for call statements, and memory insts... (yyval.ValueList) = new std::vector(); (yyval.ValueList)->push_back((yyvsp[0].ValueVal)); ;} break; - case 274: -#line 3011 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 276: +#line 3490 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValueList) = (yyvsp[-2].ValueList); (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal)); ;} break; - case 276: -#line 3019 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 278: +#line 3498 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValueList) = 0; ;} break; - case 277: -#line 3023 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 279: +#line 3502 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = true; ;} break; - case 278: -#line 3026 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 280: +#line 3505 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = false; ;} break; - case 279: -#line 3032 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 281: +#line 3511 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type* Ty = (yyvsp[-3].TypeVal).T->get(); - if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty)) + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type* Ty = (yyvsp[-3].TypeVal).PAT->get(); + if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa(Ty)) error("Arithmetic operator requires integer, FP, or packed operands"); - if (isa(Ty) && + if (isa(Ty) && ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp)) - error("Remainder not supported on packed types"); + error("Remainder not supported on vector types"); // Upgrade the opcode from obsolete versions before we do anything with it. Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S); Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal)); @@ -5648,18 +6131,20 @@ yyreduce: (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2); if ((yyval.InstVal).I == 0) error("binary operator returned null"); - (yyval.InstVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; ;} break; - case 280: -#line 3049 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 282: +#line 3530 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-3].TypeVal).T->get(); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).PAT->get(); if (!Ty->isInteger()) { - if (!isa(Ty) || - !cast(Ty)->getElementType()->isInteger()) + if (!isa(Ty) || + !cast(Ty)->getElementType()->isInteger()) error("Logical operator requires integral operands"); } Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S); @@ -5668,17 +6153,19 @@ yyreduce: (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2); if ((yyval.InstVal).I == 0) error("binary operator returned null"); - (yyval.InstVal).S = (yyvsp[-3].TypeVal).S; - delete (yyvsp[-3].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S); + delete (yyvsp[-3].TypeVal).PAT; ;} break; - case 281: -#line 3065 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 283: +#line 3548 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type* Ty = (yyvsp[-3].TypeVal).T->get(); - if(isa(Ty)) - error("PackedTypes currently not supported in setcc instructions"); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type* Ty = (yyvsp[-3].TypeVal).PAT->get(); + if(isa(Ty)) + error("VectorTypes currently not supported in setcc instructions"); unsigned short pred; Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S); Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal)); @@ -5686,45 +6173,49 @@ yyreduce: (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2); if ((yyval.InstVal).I == 0) error("binary operator returned null"); - (yyval.InstVal).S = Unsigned; - delete (yyvsp[-3].TypeVal).T; + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; - case 282: -#line 3079 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 284: +#line 3564 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-3].TypeVal).T->get(); - if (isa(Ty)) - error("PackedTypes currently not supported in icmp instructions"); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).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, (yyvsp[-2].ValIDVal)); Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2); - (yyval.InstVal).S = Unsigned; - delete (yyvsp[-3].TypeVal).T; + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; - case 283: -#line 3091 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 285: +#line 3578 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-3].TypeVal).T->get(); - if (isa(Ty)) - error("PackedTypes currently not supported in fcmp instructions"); + (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S); + const Type *Ty = (yyvsp[-3].TypeVal).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, (yyvsp[-2].ValIDVal)); Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal)); (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2); - (yyval.InstVal).S = Unsigned; - delete (yyvsp[-3].TypeVal).T; + (yyval.InstVal).S.makeUnsigned(); + delete (yyvsp[-3].TypeVal).PAT; ;} break; - case 284: -#line 3103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 286: +#line 3592 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { warning("Use of obsolete 'not' instruction: Replacing with 'xor"); const Type *Ty = (yyvsp[0].ValueVal).V->getType(); @@ -5734,12 +6225,12 @@ yyreduce: (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones); if ((yyval.InstVal).I == 0) error("Could not create a xor instruction"); - (yyval.InstVal).S = (yyvsp[0].ValueVal).S + (yyval.InstVal).S.copy((yyvsp[0].ValueVal).S); ;} break; - case 285: -#line 3114 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 287: +#line 3603 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!(yyvsp[0].ValueVal).V->getType()->isInteger() || cast((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8) @@ -5756,25 +6247,25 @@ yyreduce: else ShiftAmt = (yyvsp[0].ValueVal).V; (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt); - (yyval.InstVal).S = (yyvsp[-2].ValueVal).S; + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S); ;} break; - case 286: -#line 3132 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 288: +#line 3621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *DstTy = (yyvsp[0].TypeVal).T->get(); + const Type *DstTy = (yyvsp[0].TypeVal).PAT->get(); if (!DstTy->isFirstClassType()) error("cast instruction to a non-primitive type: '" + DstTy->getDescription() + "'"); (yyval.InstVal).I = cast(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true)); - (yyval.InstVal).S = (yyvsp[0].TypeVal).S; - delete (yyvsp[0].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 287: -#line 3141 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 289: +#line 3630 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() || cast((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1) @@ -5782,26 +6273,26 @@ yyreduce: if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType()) error("select value types should match"); (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); - (yyval.InstVal).S = (yyvsp[-4].ValueVal).S; + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S); ;} break; - case 288: -#line 3150 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 290: +#line 3639 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[0].TypeVal).T->get(); + const Type *Ty = (yyvsp[0].TypeVal).PAT->get(); NewVarArgs = true; (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty); - (yyval.InstVal).S = (yyvsp[0].TypeVal).S; - delete (yyvsp[0].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 289: -#line 3157 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 291: +#line 3646 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType(); - const Type* DstTy = (yyvsp[0].TypeVal).T->get(); + const Type* DstTy = (yyvsp[0].TypeVal).PAT->get(); ObsoleteVarArgs = true; Function* NF = cast(CurModule.CurrentModule-> getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0)); @@ -5817,16 +6308,16 @@ yyreduce: CurBB->getInstList().push_back(bar); CurBB->getInstList().push_back(new StoreInst(bar, foo)); (yyval.InstVal).I = new VAArgInst(foo, DstTy); - (yyval.InstVal).S = (yyvsp[0].TypeVal).S; - delete (yyvsp[0].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 290: -#line 3178 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 292: +#line 3667 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType(); - const Type* DstTy = (yyvsp[0].TypeVal).T->get(); + const Type* DstTy = (yyvsp[0].TypeVal).PAT->get(); ObsoleteVarArgs = true; Function* NF = cast(CurModule.CurrentModule-> getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0)); @@ -5845,43 +6336,43 @@ yyreduce: Instruction* tmp = new VAArgInst(foo, DstTy); CurBB->getInstList().push_back(tmp); (yyval.InstVal).I = new LoadInst(foo); - (yyval.InstVal).S = (yyvsp[0].TypeVal).S; - delete (yyvsp[0].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S); + delete (yyvsp[0].TypeVal).PAT; ;} break; - case 291: -#line 3202 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 293: +#line 3691 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) error("Invalid extractelement operands"); (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); - (yyval.InstVal).S = (yyvsp[-2].ValueVal).S; + (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S.get(0)); ;} break; - case 292: -#line 3208 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 294: +#line 3697 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) error("Invalid insertelement operands"); (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); - (yyval.InstVal).S = (yyvsp[-4].ValueVal).S; + (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S); ;} break; - case 293: -#line 3214 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 295: +#line 3703 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V)) error("Invalid shufflevector operands"); (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V); - (yyval.InstVal).S = (yyvsp[-4].ValueVal).S; + (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S); ;} break; - case 294: -#line 3220 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 296: +#line 3709 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType(); if (!Ty->isFirstClassType()) @@ -5895,55 +6386,70 @@ yyreduce: (yyvsp[0].PHIList).P->pop_front(); } (yyval.InstVal).I = PHI; - (yyval.InstVal).S = (yyvsp[0].PHIList).S; + (yyval.InstVal).S.copy((yyvsp[0].PHIList).S); delete (yyvsp[0].PHIList).P; // Free the list... ;} break; - case 295: -#line 3236 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 297: +#line 3725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - // Handle the short call syntax const PointerType *PFTy; const FunctionType *FTy; - if (!(PFTy = dyn_cast((yyvsp[-4].TypeVal).T->get())) || + Signedness FTySign; + if (!(PFTy = dyn_cast((yyvsp[-4].TypeVal).PAT->get())) || !(FTy = dyn_cast(PFTy->getElementType()))) { // Pull out the types of all of the arguments... std::vector ParamTypes; + FTySign.makeComposite((yyvsp[-4].TypeVal).S); if ((yyvsp[-1].ValueList)) { for (std::vector::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end(); - I != E; ++I) + I != E; ++I) { ParamTypes.push_back((*I).V->getType()); + FTySign.add(I->S); + } } - FunctionType::ParamAttrsList ParamAttrs; - if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) { - ParamAttrs.push_back(FunctionType::NoAttributeSet); - ParamAttrs.push_back(FunctionType::StructRetAttribute); - } bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy; if (isVarArg) ParamTypes.pop_back(); - const Type *RetTy = (yyvsp[-4].TypeVal).T->get(); + const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get(); if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy) error("Functions cannot return aggregate types"); - FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs); + // Deal with CSRetCC + ParamAttrsList *PAL = 0; + if ((yyvsp[-5].UIntVal) == 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); + (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S); + } else { + FTySign = (yyvsp[-4].TypeVal).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. + (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S.get(0).get(0)); } + (yyvsp[-3].ValIDVal).S.makeComposite(FTySign); // First upgrade any intrinsic calls. std::vector Args; if ((yyvsp[-1].ValueList)) for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i) Args.push_back((*(yyvsp[-1].ValueList))[i].V); - Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args); + Instruction *Inst = upgradeIntrinsicCall(FTy->getReturnType(), (yyvsp[-3].ValIDVal), Args); // If we got an upgraded intrinsic if (Inst) { (yyval.InstVal).I = Inst; - (yyval.InstVal).S = Signless; } else { // Get the function we're calling Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal)); @@ -5971,100 +6477,102 @@ yyreduce: } // Create the call instruction - CallInst *CI = new CallInst(V, Args); + CallInst *CI = new CallInst(V, &Args[0], Args.size()); CI->setTailCall((yyvsp[-6].BoolVal)); CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal))); (yyval.InstVal).I = CI; - (yyval.InstVal).S = (yyvsp[-4].TypeVal).S; } - delete (yyvsp[-4].TypeVal).T; + delete (yyvsp[-4].TypeVal).PAT; delete (yyvsp[-1].ValueList); + lastCallingConv = OldCallingConv::C; ;} break; - case 296: -#line 3314 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 298: +#line 3818 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.InstVal) = (yyvsp[0].InstVal); ;} break; - case 297: -#line 3322 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 299: +#line 3826 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValueList) = (yyvsp[0].ValueList); ;} break; - case 298: -#line 3323 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 300: +#line 3827 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.ValueList) = new std::vector(); ;} break; - case 299: -#line 3327 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 301: +#line 3831 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = true; ;} break; - case 300: -#line 3328 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 302: +#line 3832 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { (yyval.BoolVal) = false; ;} break; - case 301: -#line 3332 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 303: +#line 3836 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-1].TypeVal).T->get(); - (yyval.InstVal).S = (yyvsp[-1].TypeVal).S; + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S); (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal)); - delete (yyvsp[-1].TypeVal).T; + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 302: -#line 3338 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 304: +#line 3842 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-4].TypeVal).T->get(); - (yyval.InstVal).S = (yyvsp[-4].TypeVal).S; + const Type *Ty = (yyvsp[-4].TypeVal).PAT->get(); + (yyvsp[-1].ValIDVal).S.makeUnsigned(); + (yyval.InstVal).S.makeComposite((yyvsp[-4].TypeVal).S); (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal)); - delete (yyvsp[-4].TypeVal).T; + delete (yyvsp[-4].TypeVal).PAT; ;} break; - case 303: -#line 3344 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 305: +#line 3849 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-1].TypeVal).T->get(); - (yyval.InstVal).S = (yyvsp[-1].TypeVal).S; + const Type *Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S); (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal)); - delete (yyvsp[-1].TypeVal).T; + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 304: -#line 3350 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 306: +#line 3855 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type *Ty = (yyvsp[-4].TypeVal).T->get(); - (yyval.InstVal).S = (yyvsp[-4].TypeVal).S; + const Type *Ty = (yyvsp[-4].TypeVal).PAT->get(); + (yyvsp[-1].ValIDVal).S.makeUnsigned(); + (yyval.InstVal).S.makeComposite((yyvsp[-2].PrimType).S); (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal)); - delete (yyvsp[-4].TypeVal).T; + delete (yyvsp[-4].TypeVal).PAT; ;} break; - case 305: -#line 3356 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 307: +#line 3862 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { const Type *PTy = (yyvsp[0].ValueVal).V->getType(); if (!isa(PTy)) error("Trying to free nonpointer type '" + PTy->getDescription() + "'"); (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V); - (yyval.InstVal).S = Signless; + (yyval.InstVal).S.makeSignless(); ;} break; - case 306: -#line 3363 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 308: +#line 3869 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type* Ty = (yyvsp[-1].TypeVal).T->get(); - (yyval.InstVal).S = (yyvsp[-1].TypeVal).S; + const Type* Ty = (yyvsp[-1].TypeVal).PAT->get(); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); if (!isa(Ty)) error("Can't load from nonpointer type: " + Ty->getDescription()); if (!cast(Ty)->getElementType()->isFirstClassType()) @@ -6072,42 +6580,57 @@ yyreduce: Ty->getDescription()); Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal)); (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal)); - delete (yyvsp[-1].TypeVal).T; + (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0)); + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 307: -#line 3375 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 309: +#line 3882 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).T->get()); + (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S); + const PointerType *PTy = dyn_cast((yyvsp[-1].TypeVal).PAT->get()); if (!PTy) error("Can't store to a nonpointer type: " + - (yyvsp[-1].TypeVal).T->get()->getDescription()); + (yyvsp[-1].TypeVal).PAT->get()->getDescription()); const Type *ElTy = PTy->getElementType(); - if (ElTy != (yyvsp[-3].ValueVal).V->getType()) - error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() + - "' into space of type '" + ElTy->getDescription() + "'"); + Value *StoreVal = (yyvsp[-3].ValueVal).V; Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal)); - (yyval.InstVal).I = new StoreInst((yyvsp[-3].ValueVal).V, tmpVal, (yyvsp[-5].BoolVal)); - (yyval.InstVal).S = Signless; - delete (yyvsp[-1].TypeVal).T; + if (ElTy != (yyvsp[-3].ValueVal).V->getType()) { + StoreVal = handleSRetFuncTypeMerge((yyvsp[-3].ValueVal).V, ElTy); + if (!StoreVal) + error("Can't store '" + (yyvsp[-3].ValueVal).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); + } + } + (yyval.InstVal).I = new StoreInst(StoreVal, tmpVal, (yyvsp[-5].BoolVal)); + (yyval.InstVal).S.makeSignless(); + delete (yyvsp[-1].TypeVal).PAT; ;} break; - case 308: -#line 3389 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" + case 310: +#line 3908 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" { - const Type* Ty = (yyvsp[-2].TypeVal).T->get(); + (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S); + const Type* Ty = (yyvsp[-2].TypeVal).PAT->get(); if (!isa(Ty)) error("getelementptr insn requires pointer operand"); std::vector VIndices; - upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices); + upgradeGEPInstIndices(Ty, (yyvsp[0].ValueList), VIndices); Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal)); - (yyval.InstVal).I = new GetElementPtrInst(tmpVal, VIndices); - (yyval.InstVal).S = Signless; - delete (yyvsp[-2].TypeVal).T; + (yyval.InstVal).I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size()); + ValueInfo VI; VI.V = tmpVal; VI.S.copy((yyvsp[-2].TypeVal).S); + (yyval.InstVal).S.copy(getElementSign(VI, VIndices)); + delete (yyvsp[-2].TypeVal).PAT; delete (yyvsp[0].ValueList); ;} break; @@ -6117,7 +6640,7 @@ yyreduce: } /* Line 1126 of yacc.c. */ -#line 6121 "UpgradeParser.tab.c" +#line 6644 "UpgradeParser.tab.c" yyvsp -= yylen; yyssp -= yylen; @@ -6385,13 +6908,13 @@ yyreturn: } -#line 3405 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" +#line 3926 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y" int yyerror(const char *ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) - + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": "; + + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; std::string errMsg = where + "error: " + std::string(ErrorMsg); if (yychar != YYEMPTY && yychar != 0) errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) + @@ -6404,7 +6927,7 @@ int yyerror(const char *ErrorMsg) { void warning(const std::string& ErrorMsg) { std::string where = std::string((CurFilename == "-") ? std::string("") : CurFilename) - + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": "; + + ":" + llvm::utostr((unsigned) Upgradelineno) + ": "; std::string errMsg = where + "warning: " + std::string(ErrorMsg); if (yychar != YYEMPTY && yychar != 0) errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +