BR = 328,
SWITCH = 329,
INVOKE = 330,
- UNWIND = 331,
- UNREACHABLE = 332,
- ADD = 333,
- SUB = 334,
- MUL = 335,
- UDIV = 336,
- SDIV = 337,
- FDIV = 338,
- UREM = 339,
- SREM = 340,
- FREM = 341,
- AND = 342,
- OR = 343,
- XOR = 344,
- SETLE = 345,
- SETGE = 346,
- SETLT = 347,
- SETGT = 348,
- SETEQ = 349,
- SETNE = 350,
- MALLOC = 351,
- ALLOCA = 352,
- FREE = 353,
- LOAD = 354,
- STORE = 355,
- GETELEMENTPTR = 356,
- TRUNC = 357,
- ZEXT = 358,
- SEXT = 359,
- FPTRUNC = 360,
- FPEXT = 361,
- BITCAST = 362,
- UITOFP = 363,
- SITOFP = 364,
- FPTOUI = 365,
- FPTOSI = 366,
- INTTOPTR = 367,
- PTRTOINT = 368,
- PHI_TOK = 369,
- SELECT = 370,
- SHL = 371,
- LSHR = 372,
- ASHR = 373,
- VAARG = 374,
- EXTRACTELEMENT = 375,
- INSERTELEMENT = 376,
- SHUFFLEVECTOR = 377,
- CAST = 378
+ UNREACHABLE = 331,
+ UNWIND = 332,
+ EXCEPT = 333,
+ ADD = 334,
+ SUB = 335,
+ MUL = 336,
+ DIV = 337,
+ UDIV = 338,
+ SDIV = 339,
+ FDIV = 340,
+ REM = 341,
+ UREM = 342,
+ SREM = 343,
+ FREM = 344,
+ AND = 345,
+ OR = 346,
+ XOR = 347,
+ SHL = 348,
+ SHR = 349,
+ ASHR = 350,
+ LSHR = 351,
+ SETLE = 352,
+ SETGE = 353,
+ SETLT = 354,
+ SETGT = 355,
+ SETEQ = 356,
+ SETNE = 357,
+ ICMP = 358,
+ FCMP = 359,
+ MALLOC = 360,
+ ALLOCA = 361,
+ FREE = 362,
+ LOAD = 363,
+ STORE = 364,
+ GETELEMENTPTR = 365,
+ PHI_TOK = 366,
+ SELECT = 367,
+ VAARG = 368,
+ EXTRACTELEMENT = 369,
+ INSERTELEMENT = 370,
+ SHUFFLEVECTOR = 371,
+ VAARG_old = 372,
+ VANEXT_old = 373,
+ EQ = 374,
+ NE = 375,
+ SLT = 376,
+ SGT = 377,
+ SLE = 378,
+ SGE = 379,
+ ULT = 380,
+ UGT = 381,
+ ULE = 382,
+ UGE = 383,
+ OEQ = 384,
+ ONE = 385,
+ OLT = 386,
+ OGT = 387,
+ OLE = 388,
+ OGE = 389,
+ ORD = 390,
+ UNO = 391,
+ UEQ = 392,
+ UNE = 393,
+ CAST = 394,
+ TRUNC = 395,
+ ZEXT = 396,
+ SEXT = 397,
+ FPTRUNC = 398,
+ FPEXT = 399,
+ FPTOUI = 400,
+ FPTOSI = 401,
+ UITOFP = 402,
+ SITOFP = 403,
+ PTRTOINT = 404,
+ INTTOPTR = 405,
+ BITCAST = 406
};
#endif
/* Tokens. */
#define BR 328
#define SWITCH 329
#define INVOKE 330
-#define UNWIND 331
-#define UNREACHABLE 332
-#define ADD 333
-#define SUB 334
-#define MUL 335
-#define UDIV 336
-#define SDIV 337
-#define FDIV 338
-#define UREM 339
-#define SREM 340
-#define FREM 341
-#define AND 342
-#define OR 343
-#define XOR 344
-#define SETLE 345
-#define SETGE 346
-#define SETLT 347
-#define SETGT 348
-#define SETEQ 349
-#define SETNE 350
-#define MALLOC 351
-#define ALLOCA 352
-#define FREE 353
-#define LOAD 354
-#define STORE 355
-#define GETELEMENTPTR 356
-#define TRUNC 357
-#define ZEXT 358
-#define SEXT 359
-#define FPTRUNC 360
-#define FPEXT 361
-#define BITCAST 362
-#define UITOFP 363
-#define SITOFP 364
-#define FPTOUI 365
-#define FPTOSI 366
-#define INTTOPTR 367
-#define PTRTOINT 368
-#define PHI_TOK 369
-#define SELECT 370
-#define SHL 371
-#define LSHR 372
-#define ASHR 373
-#define VAARG 374
-#define EXTRACTELEMENT 375
-#define INSERTELEMENT 376
-#define SHUFFLEVECTOR 377
-#define CAST 378
+#define UNREACHABLE 331
+#define UNWIND 332
+#define EXCEPT 333
+#define ADD 334
+#define SUB 335
+#define MUL 336
+#define DIV 337
+#define UDIV 338
+#define SDIV 339
+#define FDIV 340
+#define REM 341
+#define UREM 342
+#define SREM 343
+#define FREM 344
+#define AND 345
+#define OR 346
+#define XOR 347
+#define SHL 348
+#define SHR 349
+#define ASHR 350
+#define LSHR 351
+#define SETLE 352
+#define SETGE 353
+#define SETLT 354
+#define SETGT 355
+#define SETEQ 356
+#define SETNE 357
+#define ICMP 358
+#define FCMP 359
+#define MALLOC 360
+#define ALLOCA 361
+#define FREE 362
+#define LOAD 363
+#define STORE 364
+#define GETELEMENTPTR 365
+#define PHI_TOK 366
+#define SELECT 367
+#define VAARG 368
+#define EXTRACTELEMENT 369
+#define INSERTELEMENT 370
+#define SHUFFLEVECTOR 371
+#define VAARG_old 372
+#define VANEXT_old 373
+#define EQ 374
+#define NE 375
+#define SLT 376
+#define SGT 377
+#define SLE 378
+#define SGE 379
+#define ULT 380
+#define UGT 381
+#define ULE 382
+#define UGE 383
+#define OEQ 384
+#define ONE 385
+#define OLT 386
+#define OGT 387
+#define OLE 388
+#define OGE 389
+#define ORD 390
+#define UNO 391
+#define UEQ 392
+#define UNE 393
+#define CAST 394
+#define TRUNC 395
+#define ZEXT 396
+#define SEXT 397
+#define FPTRUNC 398
+#define FPEXT 399
+#define FPTOUI 400
+#define FPTOSI 401
+#define UITOFP 402
+#define SITOFP 403
+#define PTRTOINT 404
+#define INTTOPTR 405
+#define BITCAST 406
/* Copy the first part of user declarations. */
-#line 14 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
-
-#define YYERROR_VERBOSE 1
-#define YYSTYPE std::string*
-
-#include "ParserInternals.h"
-#include <llvm/ADT/StringExtras.h>
+#line 14 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+
+#include "UpgradeInternals.h"
+#include "llvm/CallingConv.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/ParameterAttributes.h"
+#include "llvm/ValueSymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
#include <algorithm>
+#include <iostream>
+#include <map>
#include <list>
#include <utility>
-#include <iostream>
+// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
+// relating to upreferences in the input stream.
+//
+//#define DEBUG_UPREFS 1
+#ifdef DEBUG_UPREFS
+#define UR_OUT(X) std::cerr << X
+#else
+#define UR_OUT(X)
+#endif
+
+#define YYERROR_VERBOSE 1
#define YYINCLUDED_STDLIB_H
+#define YYDEBUG 1
-int yylex(); // declaration" of xxx warnings.
+int yylex();
int yyparse();
+int yyerror(const char*);
+static void warning(const std::string& WarningMsg);
+
+namespace llvm {
+
+std::istream* LexInput;
static std::string CurFilename;
-static std::ostream *O = 0;
+// This bool controls whether attributes are ever added to function declarations
+// definitions and calls.
+static bool AddAttributes = false;
+
+static Module *ParserResult;
+static bool ObsoleteVarArgs;
+static bool NewVarArgs;
+static BasicBlock *CurBB;
+static GlobalVariable *CurGV;
+
+// This contains info used when building the body of a function. It is
+// destroyed when the function is completed.
+//
+typedef std::vector<Value *> ValueList; // Numbered defs
+
+typedef std::pair<std::string,TypeInfo> RenameMapKey;
+typedef std::map<RenameMapKey,std::string> RenameMapType;
+
+static void
+ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
+ std::map<const Type *,ValueList> *FutureLateResolvers = 0);
+
+static struct PerModuleInfo {
+ Module *CurrentModule;
+ std::map<const Type *, ValueList> Values; // Module level numbered definitions
+ std::map<const Type *,ValueList> LateResolveValues;
+ std::vector<PATypeHolder> Types;
+ std::vector<Signedness> TypeSigns;
+ std::map<std::string,Signedness> NamedTypeSigns;
+ std::map<std::string,Signedness> NamedValueSigns;
+ std::map<ValID, PATypeHolder> LateResolveTypes;
+ static Module::Endianness Endian;
+ static Module::PointerSize PointerSize;
+ RenameMapType RenameMap;
+
+ /// PlaceHolderInfo - When temporary placeholder objects are created, remember
+ /// how they were referenced and on which line of the input they came from so
+ /// that we can resolve them later and print error messages as appropriate.
+ std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
+
+ // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
+ // references to global values. Global values may be referenced before they
+ // are defined, and if so, the temporary object that they represent is held
+ // here. This is used for forward references of GlobalValues.
+ //
+ typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*>
+ GlobalRefsType;
+ GlobalRefsType GlobalRefs;
+
+ void ModuleDone() {
+ // If we could not resolve some functions at function compilation time
+ // (calls to functions before they are defined), resolve them now... Types
+ // are resolved when the constant pool has been completely parsed.
+ //
+ ResolveDefinitions(LateResolveValues);
+
+ // Check to make sure that all global value forward references have been
+ // resolved!
+ //
+ if (!GlobalRefs.empty()) {
+ std::string UndefinedReferences = "Unresolved global references exist:\n";
+
+ for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
+ I != E; ++I) {
+ UndefinedReferences += " " + I->first.first->getDescription() + " " +
+ I->first.second.getName() + "\n";
+ }
+ error(UndefinedReferences);
+ return;
+ }
+
+ if (CurrentModule->getDataLayout().empty()) {
+ std::string dataLayout;
+ if (Endian != Module::AnyEndianness)
+ dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
+ if (PointerSize != Module::AnyPointerSize) {
+ if (!dataLayout.empty())
+ dataLayout += "-";
+ dataLayout.append(PointerSize == Module::Pointer64 ?
+ "p:64:64" : "p:32:32");
+ }
+ CurrentModule->setDataLayout(dataLayout);
+ }
+
+ Values.clear(); // Clear out function local definitions
+ Types.clear();
+ TypeSigns.clear();
+ NamedTypeSigns.clear();
+ NamedValueSigns.clear();
+ CurrentModule = 0;
+ }
+
+ // GetForwardRefForGlobal - Check to see if there is a forward reference
+ // for this global. If so, remove it from the GlobalRefs map and return it.
+ // If not, just return null.
+ GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
+ // Check to see if there is a forward reference to this global variable...
+ // if there is, eliminate it and patch the reference to use the new def'n.
+ GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
+ GlobalValue *Ret = 0;
+ if (I != GlobalRefs.end()) {
+ Ret = I->second;
+ GlobalRefs.erase(I);
+ }
+ return Ret;
+ }
+ void setEndianness(Module::Endianness E) { Endian = E; }
+ void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
+} CurModule;
+
+Module::Endianness PerModuleInfo::Endian = Module::AnyEndianness;
+Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
+
+static struct PerFunctionInfo {
+ Function *CurrentFunction; // Pointer to current function being created
+
+ std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
+ std::map<const Type*, ValueList> LateResolveValues;
+ bool isDeclare; // Is this function a forward declararation?
+ GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
+
+ /// BBForwardRefs - When we see forward references to basic blocks, keep
+ /// track of them here.
+ std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
+ std::vector<BasicBlock*> NumberedBlocks;
+ RenameMapType RenameMap;
+ unsigned NextBBNum;
+
+ inline PerFunctionInfo() {
+ CurrentFunction = 0;
+ isDeclare = false;
+ Linkage = GlobalValue::ExternalLinkage;
+ }
+
+ inline void FunctionStart(Function *M) {
+ CurrentFunction = M;
+ NextBBNum = 0;
+ }
+
+ void FunctionDone() {
+ NumberedBlocks.clear();
+
+ // Any forward referenced blocks left?
+ if (!BBForwardRefs.empty()) {
+ error("Undefined reference to label " +
+ BBForwardRefs.begin()->first->getName());
+ return;
+ }
+
+ // Resolve all forward references now.
+ ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
+
+ Values.clear(); // Clear out function local definitions
+ RenameMap.clear();
+ CurrentFunction = 0;
+ isDeclare = false;
+ Linkage = GlobalValue::ExternalLinkage;
+ }
+} CurFun; // Info for the current function...
+
+static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
+
+/// This function is just a utility to make a Key value for the rename map.
+/// The Key is a combination of the name, type, Signedness of the original
+/// value (global/function). This just constructs the key and ensures that
+/// named Signedness values are resolved to the actual Signedness.
+/// @brief Make a key for the RenameMaps
+static RenameMapKey makeRenameMapKey(const std::string &Name, const Type* Ty,
+ const Signedness &Sign) {
+ TypeInfo TI;
+ TI.T = Ty;
+ if (Sign.isNamed())
+ // Don't allow Named Signedness nodes because they won't match. The actual
+ // Signedness must be looked up in the NamedTypeSigns map.
+ TI.S.copy(CurModule.NamedTypeSigns[Sign.getName()]);
+ else
+ TI.S.copy(Sign);
+ return std::make_pair(Name, TI);
+}
+
+
+//===----------------------------------------------------------------------===//
+// Code to handle definitions of all the types
+//===----------------------------------------------------------------------===//
+
+static int InsertValue(Value *V,
+ std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
+ if (V->hasName()) return -1; // Is this a numbered definition?
+
+ // Yes, insert the value into the value table...
+ ValueList &List = ValueTab[V->getType()];
+ List.push_back(V);
+ return List.size()-1;
+}
+
+static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
+ switch (D.Type) {
+ case ValID::NumberVal: // Is it a numbered definition?
+ // Module constants occupy the lowest numbered slots...
+ if ((unsigned)D.Num < CurModule.Types.size()) {
+ return CurModule.Types[(unsigned)D.Num];
+ }
+ break;
+ case ValID::NameVal: // Is it a named definition?
+ if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+ return N;
+ }
+ break;
+ default:
+ error("Internal parser error: Invalid symbol type reference");
+ return 0;
+ }
+
+ // If we reached here, we referenced either a symbol that we don't know about
+ // or an id number that hasn't been read yet. We may be referencing something
+ // forward, so just create an entry to be resolved later and get to it...
+ //
+ if (DoNotImprovise) return 0; // Do we just want a null to be returned?
+
+ if (inFunctionScope()) {
+ if (D.Type == ValID::NameVal) {
+ error("Reference to an undefined type: '" + D.getName() + "'");
+ return 0;
+ } else {
+ error("Reference to an undefined type: #" + itostr(D.Num));
+ return 0;
+ }
+ }
+
+ std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
+ if (I != CurModule.LateResolveTypes.end())
+ return I->second;
+
+ Type *Typ = OpaqueType::get();
+ CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
+ 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<std::string,Signedness>::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<Value*> &Indices) {
+ const Type *Ptr = VI.V->getType();
+ assert(isa<PointerType>(Ptr) && "Need pointer type");
+
+ unsigned CurIdx = 0;
+ Signedness S(VI.S);
+ while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
+ if (CurIdx == Indices.size())
+ break;
+
+ Value *Index = Indices[CurIdx++];
+ assert(!isa<PointerType>(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<StructType>(CT)) {
+ S = S.get(cast<ConstantInt>(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<Constant*> &Indices) {
+ ValueInfo VI;
+ VI.V = CI.C;
+ VI.S.copy(CI.S);
+ std::vector<Value*> 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;
+ ParamAttrsList PAL1;
+ if (F1->getParamAttrs())
+ PAL1 = *F1->getParamAttrs();
+ ParamAttrsList PAL2;
+ if (F2->getParamAttrs())
+ PAL2 = *F2->getParamAttrs();
+ if (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) ||
+ 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<PointerType>(Ty);
+ const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
+ if (PF1 && PF2) {
+ const FunctionType* FT1 = dyn_cast<FunctionType>(PF1->getElementType());
+ const FunctionType* FT2 = dyn_cast<FunctionType>(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<PointerType>(Ty);
+ const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
+ if (PF1 && PF2) {
+ const FunctionType *FT1 = dyn_cast<FunctionType>(PF1->getElementType());
+ const FunctionType *FT2 = dyn_cast<FunctionType>(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<Constant>(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
+// it. Otherwise return null.
+//
+static Value *getExistingValue(const Type *Ty, const ValID &D) {
+ if (isa<FunctionType>(Ty)) {
+ error("Functions are not values and must be referenced as pointers");
+ }
+
+ switch (D.Type) {
+ case ValID::NumberVal: { // Is it a numbered definition?
+ unsigned Num = (unsigned)D.Num;
+
+ // Module constants occupy the lowest numbered slots...
+ std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
+ if (VI != CurModule.Values.end()) {
+ if (Num < VI->second.size())
+ return VI->second[Num];
+ Num -= VI->second.size();
+ }
+
+ // Make sure that our type is within bounds
+ VI = CurFun.Values.find(Ty);
+ if (VI == CurFun.Values.end()) return 0;
+
+ // Check that the number is within bounds...
+ if (VI->second.size() <= Num) return 0;
+
+ return VI->second[Num];
+ }
+
+ case ValID::NameVal: { // Is it a named definition?
+ // Get the name out of the ID
+ RenameMapKey Key = makeRenameMapKey(D.Name, Ty, D.S);
+ Value *V = 0;
+ if (inFunctionScope()) {
+ // See if the name was renamed
+ RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
+ std::string LookupName;
+ if (I != CurFun.RenameMap.end())
+ LookupName = I->second;
+ else
+ LookupName = D.Name;
+ ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
+ V = SymTab.lookup(LookupName);
+ if (V && V->getType() != Ty)
+ V = handleSRetFuncTypeMerge(V, Ty);
+ assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type");
+ }
+ if (!V) {
+ RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
+ std::string LookupName;
+ if (I != CurModule.RenameMap.end())
+ LookupName = I->second;
+ else
+ LookupName = D.Name;
+ V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName);
+ if (V && V->getType() != Ty)
+ V = handleSRetFuncTypeMerge(V, Ty);
+ assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type");
+ }
+ if (!V)
+ return 0;
+
+ D.destroy(); // Free old strdup'd memory...
+ return V;
+ }
+
+ // Check to make sure that "Ty" is an integral type, and that our
+ // value will fit into the specified type...
+ case ValID::ConstSIntVal: // Is it a constant pool reference??
+ if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
+ error("Signed integral constant '" + itostr(D.ConstPool64) +
+ "' is invalid for type '" + Ty->getDescription() + "'");
+ }
+ return ConstantInt::get(Ty, D.ConstPool64);
+
+ case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
+ if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
+ if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
+ error("Integral constant '" + utostr(D.UConstPool64) +
+ "' is invalid or out of range");
+ else // This is really a signed reference. Transmogrify.
+ return ConstantInt::get(Ty, D.ConstPool64);
+ } else
+ return ConstantInt::get(Ty, D.UConstPool64);
+
+ case ValID::ConstFPVal: // Is it a floating point const pool reference?
+ if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
+ error("FP constant invalid for type");
+ return ConstantFP::get(Ty, D.ConstPoolFP);
+
+ case ValID::ConstNullVal: // Is it a null value?
+ if (!isa<PointerType>(Ty))
+ error("Cannot create a a non pointer null");
+ return ConstantPointerNull::get(cast<PointerType>(Ty));
+
+ case ValID::ConstUndefVal: // Is it an undef value?
+ return UndefValue::get(Ty);
+
+ case ValID::ConstZeroVal: // Is it a zero value?
+ return Constant::getNullValue(Ty);
+
+ case ValID::ConstantVal: // Fully resolved constant?
+ if (D.ConstantValue->getType() != Ty)
+ error("Constant expression type different from required type");
+ return D.ConstantValue;
+
+ case ValID::InlineAsmVal: { // Inline asm expression
+ const PointerType *PTy = dyn_cast<PointerType>(Ty);
+ const FunctionType *FTy =
+ PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
+ if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
+ error("Invalid type for asm constraint string");
+ InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
+ D.IAD->HasSideEffects);
+ D.destroy(); // Free InlineAsmDescriptor.
+ return IA;
+ }
+ default:
+ assert(0 && "Unhandled case");
+ return 0;
+ } // End of switch
+
+ assert(0 && "Unhandled case");
+ return 0;
+}
+
+// getVal - This function is identical to getExistingValue, except that if a
+// value is not already defined, it "improvises" by creating a placeholder var
+// that looks and acts just like the requested variable. When the value is
+// defined later, all uses of the placeholder variable are replaced with the
+// real thing.
+//
+static Value *getVal(const Type *Ty, const ValID &ID) {
+ if (Ty == Type::LabelTy)
+ error("Cannot use a basic block here");
+
+ // See if the value has already been defined.
+ Value *V = getExistingValue(Ty, ID);
+ if (V) return V;
+
+ if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
+ error("Invalid use of a composite type");
+
+ // If we reached here, we referenced either a symbol that we don't know about
+ // or an id number that hasn't been read yet. We may be referencing something
+ // forward, so just create an entry to be resolved later and get to it...
+ V = new Argument(Ty);
+
+ // Remember where this forward reference came from. FIXME, shouldn't we try
+ // to recycle these things??
+ CurModule.PlaceHolderInfo.insert(
+ std::make_pair(V, std::make_pair(ID, Upgradelineno)));
+
+ if (inFunctionScope())
+ InsertValue(V, CurFun.LateResolveValues);
+ else
+ InsertValue(V, CurModule.LateResolveValues);
+ return V;
+}
+
+/// @brief This just makes any name given to it unique, up to MAX_UINT times.
+static std::string makeNameUnique(const std::string& Name) {
+ static unsigned UniqueNameCounter = 1;
+ std::string Result(Name);
+ Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
+ return Result;
+}
+
+/// getBBVal - This is used for two purposes:
+/// * If isDefinition is true, a new basic block with the specified ID is being
+/// defined.
+/// * If isDefinition is true, this is a reference to a basic block, which may
+/// or may not be a forward reference.
+///
+static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
+ assert(inFunctionScope() && "Can't get basic block at global scope");
+
+ std::string Name;
+ BasicBlock *BB = 0;
+ switch (ID.Type) {
+ default:
+ error("Illegal label reference " + ID.getName());
+ break;
+ case ValID::NumberVal: // Is it a numbered definition?
+ if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
+ CurFun.NumberedBlocks.resize(ID.Num+1);
+ BB = CurFun.NumberedBlocks[ID.Num];
+ break;
+ case ValID::NameVal: // Is it a named definition?
+ Name = ID.Name;
+ if (Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name)) {
+ if (N->getType() != Type::LabelTy) {
+ // Register names didn't use to conflict with basic block names
+ // because of type planes. Now they all have to be unique. So, we just
+ // rename the register and treat this name as if no basic block
+ // had been found.
+ RenameMapKey Key = makeRenameMapKey(ID.Name, N->getType(), ID.S);
+ N->setName(makeNameUnique(N->getName()));
+ CurModule.RenameMap[Key] = N->getName();
+ BB = 0;
+ } else {
+ BB = cast<BasicBlock>(N);
+ }
+ }
+ break;
+ }
+
+ // See if the block has already been defined.
+ if (BB) {
+ // If this is the definition of the block, make sure the existing value was
+ // just a forward reference. If it was a forward reference, there will be
+ // an entry for it in the PlaceHolderInfo map.
+ if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
+ // The existing value was a definition, not a forward reference.
+ error("Redefinition of label " + ID.getName());
+
+ ID.destroy(); // Free strdup'd memory.
+ return BB;
+ }
+
+ // Otherwise this block has not been seen before.
+ BB = new BasicBlock("", CurFun.CurrentFunction);
+ if (ID.Type == ValID::NameVal) {
+ BB->setName(ID.Name);
+ } else {
+ CurFun.NumberedBlocks[ID.Num] = BB;
+ }
+
+ // If this is not a definition, keep track of it so we can use it as a forward
+ // reference.
+ if (!isDefinition) {
+ // Remember where this forward reference came from.
+ CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
+ } else {
+ // The forward declaration could have been inserted anywhere in the
+ // function: insert it into the correct place now.
+ CurFun.CurrentFunction->getBasicBlockList().remove(BB);
+ CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
+ }
+ ID.destroy();
+ return BB;
+}
+
+
+//===----------------------------------------------------------------------===//
+// Code to handle forward references in instructions
+//===----------------------------------------------------------------------===//
+//
+// This code handles the late binding needed with statements that reference
+// values not defined yet... for example, a forward branch, or the PHI node for
+// a loop body.
+//
+// This keeps a table (CurFun.LateResolveValues) of all such forward references
+// and back patchs after we are done.
+//
+
+// ResolveDefinitions - If we could not resolve some defs at parsing
+// time (forward branches, phi functions for loops, etc...) resolve the
+// defs now...
+//
+static void
+ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
+ std::map<const Type*,ValueList> *FutureLateResolvers) {
+
+ // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
+ for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
+ E = LateResolvers.end(); LRI != E; ++LRI) {
+ const Type* Ty = LRI->first;
+ ValueList &List = LRI->second;
+ while (!List.empty()) {
+ Value *V = List.back();
+ List.pop_back();
+
+ std::map<Value*, std::pair<ValID, int> >::iterator PHI =
+ CurModule.PlaceHolderInfo.find(V);
+ assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
+
+ ValID &DID = PHI->second.first;
+
+ Value *TheRealValue = getExistingValue(Ty, DID);
+ if (TheRealValue) {
+ V->replaceAllUsesWith(TheRealValue);
+ delete V;
+ CurModule.PlaceHolderInfo.erase(PHI);
+ } else if (FutureLateResolvers) {
+ // Functions have their unresolved items forwarded to the module late
+ // resolver table
+ InsertValue(V, *FutureLateResolvers);
+ } else {
+ if (DID.Type == ValID::NameVal) {
+ error("Reference to an invalid definition: '" + DID.getName() +
+ "' of type '" + V->getType()->getDescription() + "'",
+ PHI->second.second);
+ return;
+ } else {
+ error("Reference to an invalid definition: #" +
+ itostr(DID.Num) + " of type '" +
+ V->getType()->getDescription() + "'", PHI->second.second);
+ return;
+ }
+ }
+ }
+ }
+
+ LateResolvers.clear();
+}
+
+/// This function is used for type resolution and upref handling. When a type
+/// becomes concrete, this function is called to adjust the signedness for the
+/// concrete type.
+static void ResolveTypeSign(const Type* oldTy, const Signedness &Sign) {
+ std::string TyName = CurModule.CurrentModule->getTypeName(oldTy);
+ if (!TyName.empty())
+ CurModule.NamedTypeSigns[TyName] = Sign;
+}
+
+/// ResolveTypeTo - A brand new type was just declared. This means that (if
+/// name is not null) things referencing Name can be resolved. Otherwise,
+/// things refering to the number can be resolved. Do this now.
+static void ResolveTypeTo(char *Name, const Type *ToTy, const Signedness& Sign){
+ ValID D;
+ if (Name)
+ D = ValID::create(Name);
+ else
+ D = ValID::create((int)CurModule.Types.size());
+ D.S.copy(Sign);
+
+ if (Name)
+ CurModule.NamedTypeSigns[Name] = Sign;
+
+ std::map<ValID, PATypeHolder>::iterator I =
+ CurModule.LateResolveTypes.find(D);
+ if (I != CurModule.LateResolveTypes.end()) {
+ const Type *OldTy = I->second.get();
+ ((DerivedType*)OldTy)->refineAbstractTypeTo(ToTy);
+ CurModule.LateResolveTypes.erase(I);
+ }
+}
+
+/// This is the implementation portion of TypeHasInteger. It traverses the
+/// type given, avoiding recursive types, and returns true as soon as it finds
+/// an integer type. If no integer type is found, it returns false.
+static bool TypeHasIntegerI(const Type *Ty, std::vector<const Type*> Stack) {
+ // Handle some easy cases
+ if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID))
+ return false;
+ if (Ty->isInteger())
+ return true;
+ if (const SequentialType *STy = dyn_cast<SequentialType>(Ty))
+ return STy->getElementType()->isInteger();
+
+ // Avoid type structure recursion
+ for (std::vector<const Type*>::iterator I = Stack.begin(), E = Stack.end();
+ I != E; ++I)
+ if (Ty == *I)
+ return false;
+
+ // Push us on the type stack
+ Stack.push_back(Ty);
+
+ if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
+ if (TypeHasIntegerI(FTy->getReturnType(), Stack))
+ return true;
+ FunctionType::param_iterator I = FTy->param_begin();
+ FunctionType::param_iterator E = FTy->param_end();
+ for (; I != E; ++I)
+ if (TypeHasIntegerI(*I, Stack))
+ return true;
+ return false;
+ } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
+ StructType::element_iterator I = STy->element_begin();
+ StructType::element_iterator E = STy->element_end();
+ for (; I != E; ++I) {
+ if (TypeHasIntegerI(*I, Stack))
+ return true;
+ }
+ return false;
+ }
+ // There shouldn't be anything else, but its definitely not integer
+ assert(0 && "What type is this?");
+ return false;
+}
+
+/// This is the interface to TypeHasIntegerI. It just provides the type stack,
+/// to avoid recursion, and then calls TypeHasIntegerI.
+static inline bool TypeHasInteger(const Type *Ty) {
+ std::vector<const Type*> TyStack;
+ return TypeHasIntegerI(Ty, TyStack);
+}
+
+// setValueName - Set the specified value to the name given. The name may be
+// null potentially, in which case this is a noop. The string passed in is
+// assumed to be a malloc'd string buffer, and is free'd by this function.
+//
+static void setValueName(const ValueInfo &V, char *NameStr) {
+ if (NameStr) {
+ std::string Name(NameStr); // Copy string
+ free(NameStr); // Free old string
+
+ if (V.V->getType() == Type::VoidTy) {
+ error("Can't assign name '" + Name + "' to value with void type");
+ return;
+ }
+
+ assert(inFunctionScope() && "Must be in function scope");
+
+ // Search the function's symbol table for an existing value of this name
+ ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
+ Value* Existing = ST.lookup(Name);
+ if (Existing) {
+ // An existing value of the same name was found. This might have happened
+ // because of the integer type planes collapsing in LLVM 2.0.
+ if (Existing->getType() == V.V->getType() &&
+ !TypeHasInteger(Existing->getType())) {
+ // If the type does not contain any integers in them then this can't be
+ // a type plane collapsing issue. It truly is a redefinition and we
+ // should error out as the assembly is invalid.
+ error("Redefinition of value named '" + Name + "' of type '" +
+ V.V->getType()->getDescription() + "'");
+ return;
+ }
+ // In LLVM 2.0 we don't allow names to be re-used for any values in a
+ // function, regardless of Type. Previously re-use of names was okay as
+ // long as they were distinct types. With type planes collapsing because
+ // of the signedness change and because of PR411, this can no longer be
+ // supported. We must search the entire symbol table for a conflicting
+ // name and make the name unique. No warning is needed as this can't
+ // cause a problem.
+ std::string NewName = makeNameUnique(Name);
+ // We're changing the name but it will probably be used by other
+ // instructions as operands later on. Consequently we have to retain
+ // a mapping of the renaming that we're doing.
+ RenameMapKey Key = makeRenameMapKey(Name, V.V->getType(), V.S);
+ CurFun.RenameMap[Key] = NewName;
+ Name = NewName;
+ }
+
+ // Set the name.
+ V.V->setName(Name);
+ }
+}
+
+/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
+/// this is a declaration, otherwise it is a definition.
+static GlobalVariable *
+ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
+ bool isConstantGlobal, const Type *Ty,
+ Constant *Initializer,
+ const Signedness &Sign) {
+ if (isa<FunctionType>(Ty))
+ error("Cannot declare global vars of function type");
+
+ const PointerType *PTy = PointerType::get(Ty);
+
+ std::string Name;
+ if (NameStr) {
+ Name = NameStr; // Copy string
+ free(NameStr); // Free old string
+ }
+
+ // See if this global value was forward referenced. If so, recycle the
+ // object.
+ ValID ID;
+ if (!Name.empty()) {
+ ID = ValID::create((char*)Name.c_str());
+ } else {
+ ID = ValID::create((int)CurModule.Values[PTy].size());
+ }
+ ID.S.makeComposite(Sign);
+
+ if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
+ // Move the global to the end of the list, from whereever it was
+ // previously inserted.
+ GlobalVariable *GV = cast<GlobalVariable>(FWGV);
+ CurModule.CurrentModule->getGlobalList().remove(GV);
+ CurModule.CurrentModule->getGlobalList().push_back(GV);
+ GV->setInitializer(Initializer);
+ GV->setLinkage(Linkage);
+ GV->setConstant(isConstantGlobal);
+ InsertValue(GV, CurModule.Values);
+ return GV;
+ }
+
+ // If this global has a name, check to see if there is already a definition
+ // of this global in the module and emit warnings if there are conflicts.
+ if (!Name.empty()) {
+ // The global has a name. See if there's an existing one of the same name.
+ if (CurModule.CurrentModule->getNamedGlobal(Name) ||
+ CurModule.CurrentModule->getFunction(Name)) {
+ // We found an existing global of the same name. This isn't allowed
+ // in LLVM 2.0. Consequently, we must alter the name of the global so it
+ // can at least compile. This can happen because of type planes
+ // There is alread a global of the same name which means there is a
+ // conflict. Let's see what we can do about it.
+ std::string NewName(makeNameUnique(Name));
+ if (Linkage != GlobalValue::InternalLinkage) {
+ // The linkage of this gval is external so we can't reliably rename
+ // it because it could potentially create a linking problem.
+ // However, we can't leave the name conflict in the output either or
+ // it won't assemble with LLVM 2.0. So, all we can do is rename
+ // this one to something unique and emit a warning about the problem.
+ warning("Renaming global variable '" + Name + "' to '" + NewName +
+ "' may cause linkage errors");
+ }
+
+ // Put the renaming in the global rename map
+ RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S);
+ CurModule.RenameMap[Key] = NewName;
+
+ // Rename it
+ Name = NewName;
+ }
+ }
+
+ // Otherwise there is no existing GV to use, create one now.
+ GlobalVariable *GV =
+ new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
+ CurModule.CurrentModule);
+ InsertValue(GV, CurModule.Values);
+ // Remember the sign of this global.
+ CurModule.NamedValueSigns[Name] = ID.S;
+ return GV;
+}
+
+// setTypeName - Set the specified type to the name given. The name may be
+// null potentially, in which case this is a noop. The string passed in is
+// assumed to be a malloc'd string buffer, and is freed by this function.
+//
+// This function returns true if the type has already been defined, but is
+// allowed to be redefined in the specified context. If the name is a new name
+// for the type plane, it is inserted and false is returned.
+static bool setTypeName(const PATypeInfo& TI, char *NameStr) {
+ assert(!inFunctionScope() && "Can't give types function-local names");
+ if (NameStr == 0) return false;
+
+ std::string Name(NameStr); // Copy string
+ free(NameStr); // Free old string
+
+ const Type* Ty = TI.PAT->get();
+
+ // We don't allow assigning names to void type
+ if (Ty == Type::VoidTy) {
+ error("Can't assign name '" + Name + "' to the void type");
+ return false;
+ }
+
+ // Set the type name, checking for conflicts as we do so.
+ bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, Ty);
+
+ // Save the sign information for later use
+ CurModule.NamedTypeSigns[Name] = TI.S;
+
+ if (AlreadyExists) { // Inserting a name that is already defined???
+ const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
+ assert(Existing && "Conflict but no matching type?");
+
+ // There is only one case where this is allowed: when we are refining an
+ // opaque type. In this case, Existing will be an opaque type.
+ if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
+ // We ARE replacing an opaque type!
+ const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(Ty);
+ return true;
+ }
+
+ // Otherwise, this is an attempt to redefine a type. That's okay if
+ // the redefinition is identical to the original. This will be so if
+ // Existing and T point to the same Type object. In this one case we
+ // allow the equivalent redefinition.
+ if (Existing == Ty) return true; // Yes, it's equal.
+
+ // Any other kind of (non-equivalent) redefinition is an error.
+ error("Redefinition of type named '" + Name + "' in the '" +
+ Ty->getDescription() + "' type plane");
+ }
+
+ return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Code for handling upreferences in type names...
+//
+
+// TypeContains - Returns true if Ty directly contains E in it.
+//
+static bool TypeContains(const Type *Ty, const Type *E) {
+ return std::find(Ty->subtype_begin(), Ty->subtype_end(),
+ E) != Ty->subtype_end();
+}
+
+namespace {
+ struct UpRefRecord {
+ // NestingLevel - The number of nesting levels that need to be popped before
+ // this type is resolved.
+ unsigned NestingLevel;
+
+ // LastContainedTy - This is the type at the current binding level for the
+ // type. Every time we reduce the nesting level, this gets updated.
+ const Type *LastContainedTy;
+
+ // UpRefTy - This is the actual opaque type that the upreference is
+ // represented with.
+ OpaqueType *UpRefTy;
+
+ UpRefRecord(unsigned NL, OpaqueType *URTy)
+ : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) { }
+ };
+}
+
+// UpRefs - A list of the outstanding upreferences that need to be resolved.
+static std::vector<UpRefRecord> UpRefs;
+
+/// HandleUpRefs - Every time we finish a new layer of types, this function is
+/// called. It loops through the UpRefs vector, which is a list of the
+/// currently active types. For each type, if the up reference is contained in
+/// the newly completed type, we decrement the level count. When the level
+/// count reaches zero, the upreferenced type is the type that is passed in:
+/// thus we can complete the cycle.
+///
+static PATypeHolder HandleUpRefs(const Type *ty, const Signedness& Sign) {
+ // If Ty isn't abstract, or if there are no up-references in it, then there is
+ // nothing to resolve here.
+ if (!ty->isAbstract() || UpRefs.empty()) return ty;
+
+ PATypeHolder Ty(ty);
+ UR_OUT("Type '" << Ty->getDescription() <<
+ "' newly formed. Resolving upreferences.\n" <<
+ UpRefs.size() << " upreferences active!\n");
+
+ // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
+ // to zero), we resolve them all together before we resolve them to Ty. At
+ // the end of the loop, if there is anything to resolve to Ty, it will be in
+ // this variable.
+ OpaqueType *TypeToResolve = 0;
+
+ unsigned i = 0;
+ for (; i != UpRefs.size(); ++i) {
+ UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
+ << UpRefs[i].UpRefTy->getDescription() << ") = "
+ << (TypeContains(Ty, UpRefs[i].UpRefTy) ? "true" : "false") << "\n");
+ if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
+ // Decrement level of upreference
+ unsigned Level = --UpRefs[i].NestingLevel;
+ UpRefs[i].LastContainedTy = Ty;
+ UR_OUT(" Uplevel Ref Level = " << Level << "\n");
+ if (Level == 0) { // Upreference should be resolved!
+ if (!TypeToResolve) {
+ TypeToResolve = UpRefs[i].UpRefTy;
+ } else {
+ UR_OUT(" * Resolving upreference for "
+ << UpRefs[i].UpRefTy->getDescription() << "\n";
+ std::string OldName = UpRefs[i].UpRefTy->getDescription());
+ ResolveTypeSign(UpRefs[i].UpRefTy, Sign);
+ UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
+ UR_OUT(" * Type '" << OldName << "' refined upreference to: "
+ << (const void*)Ty << ", " << Ty->getDescription() << "\n");
+ }
+ UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
+ --i; // Do not skip the next element...
+ }
+ }
+ }
+
+ if (TypeToResolve) {
+ UR_OUT(" * Resolving upreference for "
+ << 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) {
+ default : assert(0 && "Invalid OldTermOp");
+ case RetOp : return Instruction::Ret;
+ case BrOp : return Instruction::Br;
+ case SwitchOp : return Instruction::Switch;
+ case InvokeOp : return Instruction::Invoke;
+ case UnwindOp : return Instruction::Unwind;
+ case UnreachableOp: return Instruction::Unreachable;
+ }
+}
+
+static inline Instruction::BinaryOps
+getBinaryOp(BinaryOps op, const Type *Ty, const Signedness& Sign) {
+ switch (op) {
+ default : assert(0 && "Invalid OldBinaryOps");
+ case SetEQ :
+ case SetNE :
+ case SetLE :
+ case SetGE :
+ case SetLT :
+ case SetGT : assert(0 && "Should use getCompareOp");
+ case AddOp : return Instruction::Add;
+ case SubOp : return Instruction::Sub;
+ case MulOp : return Instruction::Mul;
+ case DivOp : {
+ // This is an obsolete instruction so we must upgrade it based on the
+ // types of its operands.
+ bool isFP = Ty->isFloatingPoint();
+ if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
+ // If its a vector type we want to use the element type
+ isFP = PTy->getElementType()->isFloatingPoint();
+ if (isFP)
+ return Instruction::FDiv;
+ else if (Sign.isSigned())
+ return Instruction::SDiv;
+ return Instruction::UDiv;
+ }
+ case UDivOp : return Instruction::UDiv;
+ case SDivOp : return Instruction::SDiv;
+ case FDivOp : return Instruction::FDiv;
+ case RemOp : {
+ // This is an obsolete instruction so we must upgrade it based on the
+ // types of its operands.
+ bool isFP = Ty->isFloatingPoint();
+ if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
+ // If its a vector type we want to use the element type
+ isFP = PTy->getElementType()->isFloatingPoint();
+ // Select correct opcode
+ if (isFP)
+ return Instruction::FRem;
+ else if (Sign.isSigned())
+ return Instruction::SRem;
+ return Instruction::URem;
+ }
+ case URemOp : return Instruction::URem;
+ case SRemOp : return Instruction::SRem;
+ case FRemOp : return Instruction::FRem;
+ case LShrOp : return Instruction::LShr;
+ case AShrOp : return Instruction::AShr;
+ case ShlOp : return Instruction::Shl;
+ case ShrOp :
+ if (Sign.isSigned())
+ return Instruction::AShr;
+ return Instruction::LShr;
+ case AndOp : return Instruction::And;
+ case OrOp : return Instruction::Or;
+ case XorOp : return Instruction::Xor;
+ }
+}
+
+static inline Instruction::OtherOps
+getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
+ const Signedness &Sign) {
+ bool isSigned = Sign.isSigned();
+ bool isFP = Ty->isFloatingPoint();
+ switch (op) {
+ default : assert(0 && "Invalid OldSetCC");
+ case SetEQ :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_OEQ;
+ return Instruction::FCmp;
+ } else {
+ predicate = ICmpInst::ICMP_EQ;
+ return Instruction::ICmp;
+ }
+ case SetNE :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_UNE;
+ return Instruction::FCmp;
+ } else {
+ predicate = ICmpInst::ICMP_NE;
+ return Instruction::ICmp;
+ }
+ case SetLE :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_OLE;
+ return Instruction::FCmp;
+ } else {
+ if (isSigned)
+ predicate = ICmpInst::ICMP_SLE;
+ else
+ predicate = ICmpInst::ICMP_ULE;
+ return Instruction::ICmp;
+ }
+ case SetGE :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_OGE;
+ return Instruction::FCmp;
+ } else {
+ if (isSigned)
+ predicate = ICmpInst::ICMP_SGE;
+ else
+ predicate = ICmpInst::ICMP_UGE;
+ return Instruction::ICmp;
+ }
+ case SetLT :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_OLT;
+ return Instruction::FCmp;
+ } else {
+ if (isSigned)
+ predicate = ICmpInst::ICMP_SLT;
+ else
+ predicate = ICmpInst::ICMP_ULT;
+ return Instruction::ICmp;
+ }
+ case SetGT :
+ if (isFP) {
+ predicate = FCmpInst::FCMP_OGT;
+ return Instruction::FCmp;
+ } else {
+ if (isSigned)
+ predicate = ICmpInst::ICMP_SGT;
+ else
+ predicate = ICmpInst::ICMP_UGT;
+ return Instruction::ICmp;
+ }
+ }
+}
+
+static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
+ switch (op) {
+ default : assert(0 && "Invalid OldMemoryOps");
+ case MallocOp : return Instruction::Malloc;
+ case FreeOp : return Instruction::Free;
+ case AllocaOp : return Instruction::Alloca;
+ case LoadOp : return Instruction::Load;
+ case StoreOp : return Instruction::Store;
+ case GetElementPtrOp : return Instruction::GetElementPtr;
+ }
+}
+
+static inline Instruction::OtherOps
+getOtherOp(OtherOps op, const Signedness &Sign) {
+ switch (op) {
+ default : assert(0 && "Invalid OldOtherOps");
+ case PHIOp : return Instruction::PHI;
+ case CallOp : return Instruction::Call;
+ case SelectOp : return Instruction::Select;
+ case UserOp1 : return Instruction::UserOp1;
+ case UserOp2 : return Instruction::UserOp2;
+ case VAArg : return Instruction::VAArg;
+ case ExtractElementOp : return Instruction::ExtractElement;
+ case InsertElementOp : return Instruction::InsertElement;
+ case ShuffleVectorOp : return Instruction::ShuffleVector;
+ case ICmpOp : return Instruction::ICmp;
+ case FCmpOp : return Instruction::FCmp;
+ };
+}
+
+static inline Value*
+getCast(CastOps op, Value *Src, const Signedness &SrcSign, const Type *DstTy,
+ const Signedness &DstSign, bool ForceInstruction = false) {
+ Instruction::CastOps Opcode;
+ const Type* SrcTy = Src->getType();
+ if (op == CastOp) {
+ if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
+ // fp -> ptr cast is no longer supported but we must upgrade this
+ // by doing a double cast: fp -> int -> ptr
+ SrcTy = Type::Int64Ty;
+ Opcode = Instruction::IntToPtr;
+ if (isa<Constant>(Src)) {
+ Src = ConstantExpr::getCast(Instruction::FPToUI,
+ cast<Constant>(Src), SrcTy);
+ } else {
+ std::string NewName(makeNameUnique(Src->getName()));
+ Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
+ }
+ } else if (isa<IntegerType>(DstTy) &&
+ cast<IntegerType>(DstTy)->getBitWidth() == 1) {
+ // cast type %x to bool was previously defined as setne type %x, null
+ // The cast semantic is now to truncate, not compare so we must retain
+ // the original intent by replacing the cast with a setne
+ Constant* Null = Constant::getNullValue(SrcTy);
+ Instruction::OtherOps Opcode = Instruction::ICmp;
+ unsigned short predicate = ICmpInst::ICMP_NE;
+ if (SrcTy->isFloatingPoint()) {
+ Opcode = Instruction::FCmp;
+ predicate = FCmpInst::FCMP_ONE;
+ } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
+ error("Invalid cast to bool");
+ }
+ if (isa<Constant>(Src) && !ForceInstruction)
+ return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
+ else
+ return CmpInst::create(Opcode, predicate, Src, Null);
+ }
+ // Determine the opcode to use by calling CastInst::getCastOpcode
+ Opcode =
+ CastInst::getCastOpcode(Src, SrcSign.isSigned(), DstTy,
+ DstSign.isSigned());
+
+ } else switch (op) {
+ default: assert(0 && "Invalid cast token");
+ case TruncOp: Opcode = Instruction::Trunc; break;
+ case ZExtOp: Opcode = Instruction::ZExt; break;
+ case SExtOp: Opcode = Instruction::SExt; break;
+ case FPTruncOp: Opcode = Instruction::FPTrunc; break;
+ case FPExtOp: Opcode = Instruction::FPExt; break;
+ case FPToUIOp: Opcode = Instruction::FPToUI; break;
+ case FPToSIOp: Opcode = Instruction::FPToSI; break;
+ case UIToFPOp: Opcode = Instruction::UIToFP; break;
+ case SIToFPOp: Opcode = Instruction::SIToFP; break;
+ case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
+ case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
+ case BitCastOp: Opcode = Instruction::BitCast; break;
+ }
+
+ if (isa<Constant>(Src) && !ForceInstruction)
+ return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
+ return CastInst::create(Opcode, Src, DstTy);
+}
-std::istream* LexInput = 0;
+static Instruction *
+upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
+ std::vector<Value*>& Args) {
+
+ std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
+ 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<IntegerType>(ArgTy)->getBitWidth());
+ Function *F = cast<Function>(
+ 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<Function>(
+ 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<const Type*> 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* upgradeGEPCEIndices(const Type* PTy,
+ std::vector<ValueInfo> *Indices,
+ std::vector<Constant*> &Result) {
+ const Type *Ty = PTy;
+ Result.clear();
+ for (unsigned i = 0, e = Indices->size(); i != e ; ++i) {
+ Constant *Index = cast<Constant>((*Indices)[i].V);
+
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(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<SequentialType>(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<IntegerType>(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<ValueInfo> *Indices,
+ std::vector<Value*> &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<ConstantInt>(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<StructType>(Ty)) { // Only change struct indices
+ if (!isa<Constant>(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<IntegerType>(Index->getType())) {
+ if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) {
+ if (isa<Constant>(Index))
+ Index = ConstantExpr::getCast(Instruction::ZExt,
+ cast<Constant>(Index), Type::Int64Ty);
+ else
+ Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
+ makeNameUnique("gep"), CurBB);
+ }
+ }
+ }
+ Result.push_back(Index);
+ Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true);
+ if (!Ty)
+ error("Index list invalid for constant getelementptr");
+ }
+ return Ty;
+}
-void UpgradeAssembly(const std::string &infile, std::istream& in,
- std::ostream &out)
+unsigned upgradeCallingConv(unsigned CC) {
+ switch (CC) {
+ case OldCallingConv::C : return CallingConv::C;
+ case OldCallingConv::CSRet : return CallingConv::C;
+ case OldCallingConv::Fast : return CallingConv::Fast;
+ case OldCallingConv::Cold : return CallingConv::Cold;
+ case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
+ case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
+ default:
+ return CC;
+ }
+}
+
+Module* UpgradeAssembly(const std::string &infile, std::istream& in,
+ bool debug, bool addAttrs)
{
Upgradelineno = 1;
CurFilename = infile;
LexInput = ∈
- O = &out;
+ yydebug = debug;
+ AddAttributes = addAttrs;
+ ObsoleteVarArgs = false;
+ NewVarArgs = false;
+
+ CurModule.CurrentModule = new Module(CurFilename);
+ // Check to make sure the parser succeeded
if (yyparse()) {
- std::cerr << "Parse failed.\n";
- exit(1);
+ if (ParserResult)
+ delete ParserResult;
+ std::cerr << "llvm-upgrade: parse failed.\n";
+ return 0;
+ }
+
+ // Check to make sure that parsing produced a result
+ if (!ParserResult) {
+ std::cerr << "llvm-upgrade: no parse result.\n";
+ return 0;
+ }
+
+ // Reset ParserResult variable while saving its value for the result.
+ Module *Result = ParserResult;
+ ParserResult = 0;
+
+ //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
+ {
+ Function* F;
+ if ((F = Result->getFunction("llvm.va_start"))
+ && F->getFunctionType()->getNumParams() == 0)
+ ObsoleteVarArgs = true;
+ if((F = Result->getFunction("llvm.va_copy"))
+ && F->getFunctionType()->getNumParams() == 1)
+ ObsoleteVarArgs = true;
+ }
+
+ if (ObsoleteVarArgs && NewVarArgs) {
+ error("This file is corrupt: it uses both new and old style varargs");
+ return 0;
+ }
+
+ if(ObsoleteVarArgs) {
+ if(Function* F = Result->getFunction("llvm.va_start")) {
+ if (F->arg_size() != 0) {
+ error("Obsolete va_start takes 0 argument");
+ return 0;
+ }
+
+ //foo = va_start()
+ // ->
+ //bar = alloca typeof(foo)
+ //va_start(bar)
+ //foo = load bar
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = cast<Function>(Result->getOrInsertFunction(
+ "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
+
+ while (!F->use_empty()) {
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+ new CallInst(NF, bar, "", CI);
+ Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+ CI->replaceAllUsesWith(foo);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ Result->getFunctionList().erase(F);
+ }
+
+ if(Function* F = Result->getFunction("llvm.va_end")) {
+ if(F->arg_size() != 1) {
+ error("Obsolete va_end takes 1 argument");
+ return 0;
+ }
+
+ //vaend foo
+ // ->
+ //bar = alloca 1 of typeof(foo)
+ //vaend bar
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getParamType(0);
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = cast<Function>(Result->getOrInsertFunction(
+ "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
+
+ while (!F->use_empty()) {
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+ new StoreInst(CI->getOperand(1), bar, CI);
+ new CallInst(NF, bar, "", CI);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ Result->getFunctionList().erase(F);
+ }
+
+ if(Function* F = Result->getFunction("llvm.va_copy")) {
+ if(F->arg_size() != 1) {
+ error("Obsolete va_copy takes 1 argument");
+ return 0;
+ }
+ //foo = vacopy(bar)
+ // ->
+ //a = alloca 1 of typeof(foo)
+ //b = alloca 1 of typeof(foo)
+ //store bar -> b
+ //vacopy(a, b)
+ //foo = load a
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = cast<Function>(Result->getOrInsertFunction(
+ "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
+
+ while (!F->use_empty()) {
+ CallInst* CI = cast<CallInst>(F->use_back());
+ AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+ AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+ new StoreInst(CI->getOperand(1), b, CI);
+ new CallInst(NF, a, b, "", CI);
+ Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+ CI->replaceAllUsesWith(foo);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ Result->getFunctionList().erase(F);
+ }
}
+
+ return Result;
}
+} // end llvm namespace
+
+using namespace llvm;
+
/* Enabling traces. */
#endif
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-typedef int YYSTYPE;
+#line 1771 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+typedef union YYSTYPE {
+ llvm::Module *ModuleVal;
+ llvm::Function *FunctionVal;
+ std::pair<llvm::PATypeInfo, char*> *ArgVal;
+ llvm::BasicBlock *BasicBlockVal;
+ llvm::TermInstInfo TermInstVal;
+ llvm::InstrInfo InstVal;
+ llvm::ConstInfo ConstVal;
+ llvm::ValueInfo ValueVal;
+ llvm::PATypeInfo TypeVal;
+ llvm::TypeInfo PrimType;
+ llvm::PHIListInfo PHIList;
+ std::list<llvm::PATypeInfo> *TypeList;
+ std::vector<llvm::ValueInfo> *ValueList;
+ std::vector<llvm::ConstInfo> *ConstVector;
+
+
+ std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
+ // Represent the RHS of PHI node
+ std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
+
+ llvm::GlobalValue::LinkageTypes Linkage;
+ int64_t SInt64Val;
+ uint64_t UInt64Val;
+ int SIntVal;
+ unsigned UIntVal;
+ double FPVal;
+ bool BoolVal;
+
+ char *StrVal; // This memory is strdup'd!
+ llvm::ValID ValIDVal; // strdup'd memory maybe!
+
+ llvm::BinaryOps BinaryOpVal;
+ llvm::TermOps TermOpVal;
+ llvm::MemoryOps MemOpVal;
+ llvm::OtherOps OtherOpVal;
+ llvm::CastOps CastOpVal;
+ llvm::ICmpInst::Predicate IPred;
+ llvm::FCmpInst::Predicate FPred;
+ llvm::Module::Endianness Endianness;
+} YYSTYPE;
+/* Line 196 of yacc.c. */
+#line 2194 "UpgradeParser.tab.c"
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
/* Line 219 of yacc.c. */
-#line 388 "UpgradeParser.tab.c"
+#line 2206 "UpgradeParser.tab.c"
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 4
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 1246
+#define YYLAST 1630
/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 138
+#define YYNTOKENS 166
/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 71
+#define YYNNTS 81
/* YYNRULES -- Number of rules. */
-#define YYNRULES 251
+#define YYNRULES 310
/* YYNRULES -- Number of states. */
-#define YYNSTATES 510
+#define YYNSTATES 606
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
-#define YYMAXUTOK 378
+#define YYMAXUTOK 406
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 127, 128, 136, 2, 125, 2, 2, 2, 2, 2,
+ 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 132, 124, 133, 2, 2, 2, 2, 2, 2, 2,
+ 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 129, 126, 131, 2, 2, 2, 2, 2, 137,
+ 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 130, 2, 2, 134, 2, 135, 2, 2, 2, 2,
+ 158, 2, 2, 162, 2, 163, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
- 115, 116, 117, 118, 119, 120, 121, 122, 123
+ 115, 116, 117, 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
};
#if YYDEBUG
19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
- 79, 82, 83, 85, 87, 89, 91, 93, 95, 97,
- 98, 100, 102, 104, 106, 108, 110, 113, 114, 115,
- 118, 119, 123, 126, 127, 129, 130, 134, 136, 139,
- 141, 143, 145, 147, 149, 151, 153, 155, 157, 159,
- 161, 163, 165, 167, 169, 171, 173, 175, 177, 179,
- 181, 184, 189, 195, 201, 205, 208, 211, 213, 217,
- 219, 223, 225, 226, 231, 235, 239, 244, 249, 253,
- 256, 259, 262, 265, 268, 271, 274, 277, 280, 283,
- 290, 296, 305, 312, 319, 326, 333, 340, 349, 358,
- 362, 364, 366, 368, 370, 373, 376, 381, 384, 386,
- 391, 394, 399, 406, 413, 420, 427, 431, 436, 437,
- 439, 441, 443, 447, 451, 455, 459, 463, 467, 469,
- 470, 472, 474, 476, 477, 480, 484, 486, 488, 492,
- 494, 495, 504, 506, 508, 512, 514, 516, 520, 521,
- 523, 525, 529, 530, 532, 534, 536, 538, 540, 542,
- 544, 546, 548, 552, 554, 560, 562, 564, 566, 568,
- 571, 574, 576, 580, 583, 584, 586, 589, 592, 596,
- 606, 616, 625, 639, 641, 643, 650, 656, 659, 666,
- 674, 676, 680, 682, 683, 686, 688, 694, 700, 706,
- 709, 714, 719, 726, 731, 736, 743, 750, 753, 761,
- 763, 766, 767, 769, 770, 774, 781, 785, 792, 795,
- 800, 807
+ 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
+ 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
+ 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
+ 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
+ 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
+ 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
+ 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
+ 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
+ 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
+ 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
+ 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
+ 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
+ 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
+ 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
+ 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
+ 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, 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. */
static const short int yyrhs[] =
{
- 170, 0, -1, 5, -1, 6, -1, 3, -1, 4,
- -1, 78, -1, 79, -1, 80, -1, 81, -1, 82,
- -1, 83, -1, 84, -1, 85, -1, 86, -1, 87,
- -1, 88, -1, 89, -1, 90, -1, 91, -1, 92,
- -1, 93, -1, 94, -1, 95, -1, 123, -1, 116,
- -1, 117, -1, 118, -1, 16, -1, 14, -1, 12,
- -1, 10, -1, 17, -1, 15, -1, 13, -1, 11,
- -1, 146, -1, 147, -1, 18, -1, 19, -1, 178,
- 124, -1, -1, 41, -1, 42, -1, 43, -1, 44,
- -1, 45, -1, 46, -1, 47, -1, -1, 65, -1,
- 66, -1, 67, -1, 68, -1, 69, -1, 70, -1,
- 64, 4, -1, -1, -1, 57, 4, -1, -1, 125,
- 57, 4, -1, 34, 24, -1, -1, 155, -1, -1,
- 125, 158, 157, -1, 155, -1, 57, 4, -1, 161,
- -1, 8, -1, 163, -1, 8, -1, 163, -1, 9,
- -1, 10, -1, 11, -1, 12, -1, 13, -1, 14,
- -1, 15, -1, 16, -1, 17, -1, 18, -1, 19,
- -1, 20, -1, 21, -1, 48, -1, 162, -1, 192,
- -1, 126, 4, -1, 160, 127, 165, 128, -1, 129,
- 4, 130, 163, 131, -1, 132, 4, 130, 163, 133,
- -1, 134, 164, 135, -1, 134, 135, -1, 163, 136,
- -1, 163, -1, 164, 125, 163, -1, 164, -1, 164,
- 125, 37, -1, 37, -1, -1, 161, 129, 168, 131,
- -1, 161, 129, 131, -1, 161, 137, 24, -1, 161,
- 132, 168, 133, -1, 161, 134, 168, 135, -1, 161,
- 134, 135, -1, 161, 38, -1, 161, 39, -1, 161,
- 192, -1, 161, 167, -1, 161, 26, -1, 146, 140,
- -1, 147, 4, -1, 9, 27, -1, 9, 28, -1,
- 149, 7, -1, 144, 127, 166, 36, 161, 128, -1,
- 101, 127, 166, 206, 128, -1, 115, 127, 166, 125,
- 166, 125, 166, 128, -1, 141, 127, 166, 125, 166,
- 128, -1, 142, 127, 166, 125, 166, 128, -1, 143,
- 127, 166, 125, 166, 128, -1, 145, 127, 166, 125,
- 166, 128, -1, 120, 127, 166, 125, 166, 128, -1,
- 121, 127, 166, 125, 166, 125, 166, 128, -1, 122,
- 127, 166, 125, 166, 125, 166, 128, -1, 168, 125,
- 166, -1, 166, -1, 32, -1, 33, -1, 171, -1,
- 171, 187, -1, 171, 189, -1, 171, 62, 61, 173,
- -1, 171, 25, -1, 172, -1, 172, 150, 20, 159,
- -1, 172, 189, -1, 172, 62, 61, 173, -1, 172,
- 150, 151, 169, 166, 157, -1, 172, 150, 50, 169,
- 161, 157, -1, 172, 150, 45, 169, 161, 157, -1,
- 172, 150, 47, 169, 161, 157, -1, 172, 51, 175,
- -1, 172, 58, 124, 176, -1, -1, 24, -1, 56,
- -1, 55, -1, 53, 124, 174, -1, 54, 124, 4,
- -1, 52, 124, 24, -1, 71, 124, 24, -1, 129,
- 177, 131, -1, 177, 125, 24, -1, 24, -1, -1,
- 22, -1, 24, -1, 178, -1, -1, 161, 179, -1,
- 181, 125, 180, -1, 180, -1, 181, -1, 181, 125,
- 37, -1, 37, -1, -1, 152, 159, 178, 127, 182,
- 128, 156, 153, -1, 29, -1, 134, -1, 151, 183,
- 184, -1, 30, -1, 135, -1, 185, 195, 186, -1,
- -1, 45, -1, 47, -1, 31, 188, 183, -1, -1,
- 63, -1, 3, -1, 4, -1, 7, -1, 27, -1,
- 28, -1, 38, -1, 39, -1, 26, -1, 132, 168,
- 133, -1, 167, -1, 61, 190, 24, 125, 24, -1,
- 139, -1, 178, -1, 192, -1, 191, -1, 161, 193,
- -1, 195, 196, -1, 196, -1, 197, 150, 198, -1,
- 197, 200, -1, -1, 23, -1, 72, 194, -1, 72,
- 8, -1, 73, 21, 193, -1, 73, 9, 193, 125,
- 21, 193, 125, 21, 193, -1, 74, 148, 193, 125,
- 21, 193, 129, 199, 131, -1, 74, 148, 193, 125,
- 21, 193, 129, 131, -1, 75, 152, 159, 193, 127,
- 203, 128, 36, 21, 193, 76, 21, 193, -1, 76,
- -1, 77, -1, 199, 148, 191, 125, 21, 193, -1,
- 148, 191, 125, 21, 193, -1, 150, 205, -1, 161,
- 129, 193, 125, 193, 131, -1, 201, 125, 129, 193,
- 125, 193, 131, -1, 194, -1, 202, 125, 194, -1,
- 202, -1, -1, 60, 59, -1, 59, -1, 141, 161,
- 193, 125, 193, -1, 142, 161, 193, 125, 193, -1,
- 143, 161, 193, 125, 193, -1, 49, 194, -1, 145,
- 194, 125, 194, -1, 144, 194, 36, 161, -1, 115,
- 194, 125, 194, 125, 194, -1, 119, 194, 125, 161,
- -1, 120, 194, 125, 194, -1, 121, 194, 125, 194,
- 125, 194, -1, 122, 194, 125, 194, 125, 194, -1,
- 114, 201, -1, 204, 152, 159, 193, 127, 203, 128,
- -1, 208, -1, 125, 202, -1, -1, 35, -1, -1,
- 96, 161, 154, -1, 96, 161, 125, 15, 193, 154,
- -1, 97, 161, 154, -1, 97, 161, 125, 15, 193,
- 154, -1, 98, 194, -1, 207, 99, 161, 193, -1,
- 207, 100, 194, 125, 161, 193, -1, 101, 161, 193,
- 206, -1
+ 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
+ -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
+ -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
+ -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
+ -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
+ -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
+ -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
+ -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
+ -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
+ -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
+ -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
+ -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
+ -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
+ -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
+ -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
+ -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
+ -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
+ -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
+ -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
+ -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
+ -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
+ -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
+ -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, 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,
+ 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
+ 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
+ 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
+ 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
+ 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, 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, 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,
+ 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
+ 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
+ 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
+ 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, 222, -1, 201, 224, -1, 201, 62, 61, 207,
+ -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
+ -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,
+ 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
+ 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
+ -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
+ 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
+ -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
+ 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, -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, 84, 84, 84, 85, 85, 89, 89, 89, 89,
- 89, 89, 89, 89, 89, 90, 90, 90, 91, 91,
- 91, 91, 91, 91, 92, 93, 93, 93, 97, 97,
- 97, 97, 98, 98, 98, 98, 99, 99, 100, 100,
- 103, 107, 112, 112, 112, 112, 112, 112, 113, 114,
- 117, 117, 117, 117, 117, 118, 118, 119, 124, 125,
- 128, 129, 137, 143, 144, 147, 148, 157, 158, 171,
- 171, 172, 172, 173, 177, 177, 177, 177, 177, 177,
- 177, 178, 178, 178, 178, 178, 178, 179, 179, 179,
- 183, 187, 192, 198, 204, 209, 212, 220, 220, 227,
- 228, 233, 236, 246, 251, 254, 259, 264, 269, 272,
- 277, 282, 287, 292, 298, 303, 308, 313, 318, 325,
- 330, 332, 334, 336, 338, 340, 342, 344, 346, 351,
- 353, 358, 358, 368, 373, 376, 381, 384, 387, 391,
- 396, 401, 406, 411, 416, 421, 426, 431, 436, 441,
- 443, 443, 446, 451, 456, 461, 468, 475, 480, 481,
- 489, 489, 490, 490, 492, 498, 501, 505, 508, 512,
- 515, 519, 534, 537, 541, 550, 551, 553, 559, 560,
- 561, 565, 575, 577, 580, 580, 580, 580, 580, 581,
- 581, 581, 582, 587, 588, 597, 597, 600, 600, 606,
- 612, 614, 621, 625, 630, 633, 639, 644, 649, 654,
- 660, 666, 672, 681, 686, 692, 697, 704, 711, 716,
- 724, 725, 733, 734, 738, 743, 746, 751, 756, 761,
- 766, 771, 776, 781, 786, 791, 796, 801, 806, 815,
- 820, 824, 828, 829, 832, 839, 846, 853, 860, 865,
- 872, 879
+ 0, 1911, 1911, 1912, 1920, 1921, 1931, 1931, 1931, 1931,
+ 1931, 1931, 1931, 1931, 1931, 1931, 1931, 1935, 1935, 1935,
+ 1939, 1939, 1939, 1939, 1939, 1939, 1943, 1943, 1944, 1944,
+ 1945, 1945, 1946, 1946, 1947, 1947, 1951, 1951, 1952, 1952,
+ 1953, 1953, 1954, 1954, 1955, 1955, 1956, 1956, 1957, 1957,
+ 1958, 1959, 1962, 1962, 1962, 1962, 1966, 1966, 1966, 1966,
+ 1966, 1966, 1966, 1967, 1967, 1967, 1967, 1967, 1967, 1973,
+ 1973, 1973, 1973, 1977, 1977, 1977, 1977, 1981, 1981, 1985,
+ 1985, 1990, 1993, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2026,
+ 2027, 2035, 2036, 2044, 2053, 2054, 2061, 2062, 2066, 2070,
+ 2086, 2087, 2094, 2095, 2102, 2110, 2110, 2110, 2110, 2110,
+ 2110, 2110, 2111, 2111, 2111, 2111, 2111, 2116, 2120, 2124,
+ 2129, 2138, 2156, 2162, 2175, 2186, 2190, 2203, 2207, 2221,
+ 2225, 2232, 2233, 2239, 2246, 2258, 2288, 2301, 2324, 2352,
+ 2374, 2385, 2407, 2418, 2427, 2432, 2491, 2498, 2506, 2513,
+ 2520, 2524, 2528, 2537, 2552, 2564, 2573, 2601, 2614, 2623,
+ 2629, 2635, 2646, 2652, 2658, 2669, 2670, 2679, 2680, 2692,
+ 2701, 2702, 2703, 2704, 2705, 2721, 2741, 2743, 2745, 2745,
+ 2752, 2752, 2760, 2760, 2768, 2768, 2777, 2779, 2781, 2786,
+ 2800, 2801, 2805, 2808, 2816, 2820, 2827, 2831, 2835, 2839,
+ 2847, 2847, 2851, 2852, 2856, 2864, 2869, 2877, 2878, 2885,
+ 2892, 2896, 3083, 3083, 3087, 3087, 3097, 3097, 3101, 3106,
+ 3107, 3108, 3112, 3113, 3112, 3125, 3126, 3131, 3132, 3133,
+ 3134, 3138, 3142, 3143, 3144, 3145, 3166, 3170, 3184, 3185,
+ 3190, 3190, 3198, 3208, 3211, 3220, 3231, 3236, 3245, 3256,
+ 3256, 3259, 3263, 3267, 3272, 3282, 3300, 3309, 3379, 3383,
+ 3390, 3402, 3417, 3447, 3457, 3467, 3471, 3478, 3479, 3483,
+ 3486, 3492, 3511, 3529, 3545, 3559, 3573, 3584, 3602, 3611,
+ 3620, 3627, 3648, 3672, 3678, 3684, 3690, 3706, 3796, 3804,
+ 3805, 3809, 3810, 3814, 3820, 3827, 3833, 3840, 3847, 3860,
+ 3886
};
#endif
"BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
"SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
"COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
- "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB",
- "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR",
- "XOR", "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "MALLOC",
- "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT",
- "SEXT", "FPTRUNC", "FPEXT", "BITCAST", "UITOFP", "SITOFP", "FPTOUI",
- "FPTOSI", "INTTOPTR", "PTRTOINT", "PHI_TOK", "SELECT", "SHL", "LSHR",
- "ASHR", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
- "CAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'",
- "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL", "EINT64VAL",
- "ArithmeticOps", "LogicalOps", "SetCondOps", "CastOps", "ShiftOps",
- "SIntType", "UIntType", "IntType", "FPType", "OptAssign", "OptLinkage",
- "OptCallingConv", "OptAlign", "OptCAlign", "SectionString", "OptSection",
- "GlobalVarAttributes", "GlobalVarAttribute", "TypesV", "UpRTypesV",
- "Types", "PrimType", "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal",
- "ConstExpr", "ConstVector", "GlobalType", "Module", "DefinitionList",
- "ConstPool", "AsmBlock", "BigOrLittle", "TargetDefinition",
+ "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
+ "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
+ "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
+ "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
+ "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
+ "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
+ "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
+ "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
+ "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
+ "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
+ "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
+ "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
+ "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
+ "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
+ "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
+ "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
+ "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
+ "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
+ "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
+ "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
"LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
"ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
- "END", "Function", "FnDeclareLinkage", "FunctionProto", "OptSideEffect",
- "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal",
- "BasicBlockList", "BasicBlock", "InstructionList", "BBTerminatorInst",
- "JumpTable", "Inst", "PHIList", "ValueRefList", "ValueRefListE",
- "OptTailCall", "InstVal", "IndexList", "OptVolatile", "MemoryInst", 0
+ "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7",
+ "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
+ "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
+ "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
+ "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
+ "OptVolatile", "MemoryInst", 0
};
#endif
345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
- 375, 376, 377, 378, 61, 44, 92, 40, 41, 91,
- 120, 93, 60, 62, 123, 125, 42, 99
+ 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
+ 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
+ 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
+ 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
+ 60, 62, 123, 125, 42, 99
};
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
{
- 0, 138, 139, 139, 140, 140, 141, 141, 141, 141,
- 141, 141, 141, 141, 141, 142, 142, 142, 143, 143,
- 143, 143, 143, 143, 144, 145, 145, 145, 146, 146,
- 146, 146, 147, 147, 147, 147, 148, 148, 149, 149,
- 150, 150, 151, 151, 151, 151, 151, 151, 151, 151,
- 152, 152, 152, 152, 152, 152, 152, 152, 153, 153,
- 154, 154, 155, 156, 156, 157, 157, 158, 158, 159,
- 159, 160, 160, 161, 162, 162, 162, 162, 162, 162,
- 162, 162, 162, 162, 162, 162, 162, 163, 163, 163,
- 163, 163, 163, 163, 163, 163, 163, 164, 164, 165,
- 165, 165, 165, 166, 166, 166, 166, 166, 166, 166,
- 166, 166, 166, 166, 166, 166, 166, 166, 166, 167,
- 167, 167, 167, 167, 167, 167, 167, 167, 167, 168,
- 168, 169, 169, 170, 171, 171, 171, 171, 171, 172,
- 172, 172, 172, 172, 172, 172, 172, 172, 172, 173,
- 174, 174, 175, 175, 175, 175, 176, 177, 177, 177,
- 178, 178, 179, 179, 180, 181, 181, 182, 182, 182,
- 182, 183, 184, 184, 185, 186, 186, 187, 188, 188,
- 188, 189, 190, 190, 191, 191, 191, 191, 191, 191,
- 191, 191, 191, 191, 191, 192, 192, 193, 193, 194,
- 195, 195, 196, 197, 197, 197, 198, 198, 198, 198,
- 198, 198, 198, 198, 198, 199, 199, 200, 201, 201,
- 202, 202, 203, 203, 204, 204, 205, 205, 205, 205,
- 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
- 206, 206, 207, 207, 208, 208, 208, 208, 208, 208,
- 208, 208
+ 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
+ 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
+ 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
+ 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
+ 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
+ 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
+ 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
+ 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
+ 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
+ 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
+ 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
+ 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
+ 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
+ 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
+ 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
+ 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
+ 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, 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. */
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, 1, 1, 1, 1,
- 2, 0, 1, 1, 1, 1, 1, 1, 1, 0,
- 1, 1, 1, 1, 1, 1, 2, 0, 0, 2,
- 0, 3, 2, 0, 1, 0, 3, 1, 2, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 2, 4, 5, 5, 3, 2, 2, 1, 3, 1,
- 3, 1, 0, 4, 3, 3, 4, 4, 3, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 6,
- 5, 8, 6, 6, 6, 6, 6, 8, 8, 3,
- 1, 1, 1, 1, 2, 2, 4, 2, 1, 4,
- 2, 4, 6, 6, 6, 6, 3, 4, 0, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
+ 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
+ 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
+ 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
+ 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
+ 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
+ 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, 3, 0, 1,
- 1, 3, 0, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 3, 1, 5, 1, 1, 1, 1, 2,
- 2, 1, 3, 2, 0, 1, 2, 2, 3, 9,
- 9, 8, 13, 1, 1, 6, 5, 2, 6, 7,
- 1, 3, 1, 0, 2, 1, 5, 5, 5, 2,
- 4, 4, 6, 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
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
means the default is an error. */
-static const unsigned char yydefact[] =
+static const unsigned short int yydefact[] =
{
- 148, 0, 49, 138, 1, 137, 178, 42, 43, 44,
- 45, 46, 47, 48, 0, 57, 204, 134, 135, 160,
- 161, 0, 0, 0, 49, 0, 140, 179, 180, 57,
- 0, 0, 50, 51, 52, 53, 54, 55, 0, 0,
- 205, 204, 201, 41, 0, 0, 0, 0, 146, 0,
- 0, 0, 0, 0, 0, 0, 40, 181, 149, 136,
- 56, 2, 3, 70, 74, 75, 76, 77, 78, 79,
- 80, 81, 82, 83, 84, 85, 86, 87, 0, 0,
- 0, 0, 195, 0, 0, 69, 88, 73, 196, 89,
- 172, 173, 174, 175, 176, 177, 200, 243, 203, 0,
- 0, 0, 0, 159, 147, 141, 139, 131, 132, 0,
- 0, 0, 0, 90, 0, 0, 72, 95, 97, 0,
- 0, 102, 96, 242, 0, 225, 0, 0, 0, 0,
- 57, 213, 214, 6, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 23, 0, 0, 0, 0, 0, 0, 25, 26, 27,
- 0, 0, 0, 0, 24, 0, 0, 0, 0, 0,
- 202, 57, 217, 0, 239, 154, 151, 150, 152, 153,
- 155, 158, 0, 65, 65, 65, 74, 75, 76, 77,
- 78, 79, 80, 81, 82, 83, 84, 0, 0, 0,
- 0, 65, 0, 0, 0, 94, 170, 101, 99, 0,
- 0, 229, 224, 207, 206, 0, 0, 31, 35, 30,
- 34, 29, 33, 28, 32, 36, 37, 0, 0, 60,
- 60, 248, 0, 0, 237, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 156,
- 0, 144, 145, 143, 116, 117, 4, 5, 114, 115,
- 118, 113, 109, 110, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 112, 111,
- 142, 71, 71, 98, 169, 163, 166, 167, 0, 0,
- 91, 184, 185, 186, 191, 187, 188, 189, 190, 182,
- 0, 193, 198, 197, 199, 0, 208, 0, 0, 0,
- 244, 0, 246, 241, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
- 0, 0, 67, 65, 0, 0, 0, 0, 0, 104,
- 130, 0, 0, 108, 0, 105, 0, 0, 0, 0,
- 0, 92, 93, 162, 164, 0, 63, 100, 183, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 251, 0,
- 0, 0, 233, 234, 0, 0, 0, 0, 0, 231,
- 230, 0, 249, 0, 62, 68, 66, 241, 0, 0,
- 0, 0, 0, 103, 106, 107, 0, 0, 0, 0,
- 0, 168, 165, 64, 58, 0, 192, 0, 0, 223,
- 60, 61, 60, 220, 240, 0, 0, 0, 0, 0,
- 226, 227, 228, 223, 0, 0, 0, 0, 0, 0,
- 129, 0, 0, 0, 0, 0, 0, 171, 0, 0,
- 0, 222, 0, 0, 245, 247, 0, 0, 0, 232,
- 235, 236, 0, 250, 120, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 59, 194, 0, 0, 0, 221,
- 218, 0, 238, 0, 126, 0, 0, 122, 123, 124,
- 119, 125, 0, 211, 0, 0, 0, 219, 0, 0,
- 0, 209, 0, 210, 0, 0, 121, 127, 128, 0,
- 0, 0, 0, 0, 0, 216, 0, 0, 215, 212
+ 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, 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, 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, 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,
+ 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,
+ 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, 82, 258, 273, 274, 275, 276, 277, 197, 198,
- 227, 199, 24, 15, 38, 437, 310, 332, 404, 251,
- 333, 83, 84, 200, 86, 87, 119, 209, 340, 301,
- 341, 109, 1, 2, 3, 59, 178, 48, 104, 182,
- 88, 354, 286, 287, 288, 39, 92, 16, 95, 17,
- 29, 18, 359, 302, 89, 304, 413, 41, 42, 43,
- 170, 485, 98, 234, 441, 442, 171, 172, 368, 173,
- 174
+ -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 -451
+#define YYPACT_NINF -542
static const short int yypact[] =
{
- -451, 18, 670, 213, -451, -451, 63, -451, -451, -451,
- -451, -451, -451, -451, -39, 308, 33, -451, -451, -451,
- -451, 14, -36, 31, 150, -12, -451, -451, -451, 308,
- 96, 136, -451, -451, -451, -451, -451, -451, 971, -13,
- -451, -9, -451, 119, 10, 20, 37, 56, -451, 40,
- 96, 971, 45, 45, 45, 45, -451, -451, -451, -451,
- -451, -451, -451, 52, -451, -451, -451, -451, -451, -451,
- -451, -451, -451, -451, -451, -451, -451, -451, 177, 179,
- 180, 85, -451, 119, 58, -451, -451, -52, -451, -451,
- -451, -451, -451, -451, -451, -451, -451, 1123, -451, 163,
- 97, 185, 174, 178, -451, -451, -451, -451, -451, 1019,
- 1019, 1019, 1060, -451, 76, 82, -451, -451, -52, -85,
- 86, 786, -451, -451, 1019, -451, 157, 1101, 30, 278,
- 308, -451, -451, -451, -451, -451, -451, -451, -451, -451,
- -451, -451, -451, -451, -451, -451, -451, -451, -451, -451,
- -451, 1019, 1019, 1019, 1019, 1019, 1019, -451, -451, -451,
- 1019, 1019, 1019, 1019, -451, 1019, 1019, 1019, 1019, 1019,
- -451, 308, -451, 55, -451, -451, -451, -451, -451, -451,
- -451, -451, -49, 90, 90, 90, 130, 156, 214, 160,
- 217, 162, 218, 168, 220, 224, 225, 170, 221, 227,
- 387, 90, 1019, 1019, 1019, -451, 827, -451, 111, 122,
- 560, -451, -451, 52, -451, 560, 560, -451, -451, -451,
- -451, -451, -451, -451, -451, -451, -451, 560, 971, 123,
- 126, -451, 560, 118, 127, 128, 140, 141, 142, 143,
- 560, 560, 560, 233, 145, 971, 1019, 1019, 248, -451,
- -23, -451, -451, -451, -451, -451, -451, -451, -451, -451,
- -451, -451, -451, -451, 146, 147, 149, 169, 171, 868,
- 1060, 537, 253, 173, 181, 182, 183, 187, -451, -451,
- -451, -94, 6, -52, -451, 119, -451, 158, 188, 889,
- -451, -451, -451, -451, -451, -451, -451, -451, -451, 234,
- 1060, -451, -451, -451, -451, 190, -451, 197, 560, -5,
- -451, 8, -451, 201, 560, 199, 1019, 1019, 1019, 1019,
- 1019, 205, 207, 208, 1019, 1019, 560, 560, 209, -451,
- 282, 303, -451, 90, 1060, 1060, 1060, 1060, 1060, -451,
- -451, -44, -89, -451, -56, -451, 1060, 1060, 1060, 1060,
- 1060, -451, -451, -451, -451, 930, 304, -451, -451, 313,
- -14, 320, 323, 219, 560, 344, 560, 1019, -451, 226,
- 560, 228, -451, -451, 229, 230, 560, 560, 560, -451,
- -451, 222, -451, 1019, -451, -451, -451, 201, 231, 238,
- 239, 241, 1060, -451, -451, -451, 244, 245, 257, 348,
- 261, -451, -451, -451, 330, 263, -451, 560, 560, 1019,
- 264, -451, 264, -451, 265, 560, 266, 1019, 1019, 1019,
- -451, -451, -451, 1019, 560, 267, 1060, 1060, 1060, 1060,
- -451, 1060, 1060, 1060, 1019, 1060, 390, -451, 373, 273,
- 270, 265, 272, 345, -451, -451, 1019, 274, 560, -451,
- -451, -451, 275, -451, -451, 276, 279, 281, 285, 284,
- 286, 287, 288, 290, -451, -451, 383, 15, 384, -451,
- -451, 291, -451, 1060, -451, 1060, 1060, -451, -451, -451,
- -451, -451, 560, -451, 661, 47, 398, -451, 293, 295,
- 296, -451, 302, -451, 661, 560, -451, -451, -451, 408,
- 306, 356, 560, 412, 414, -451, 560, 560, -451, -451
+ -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[] =
{
- -451, -451, -451, 339, 341, 342, 343, 346, -128, -127,
- -450, -451, 401, 421, -97, -451, -224, 92, -451, -177,
- -451, -46, -451, -38, -451, -66, 328, -451, -108, 250,
- -251, 94, -451, -451, -451, 402, -451, -451, -451, -451,
- 0, -451, 98, -451, -451, 422, -451, -451, -451, -451,
- -451, 451, -451, -414, -65, 120, -115, -451, 415, -451,
- -451, -451, -451, -451, 88, 34, -451, -451, 71, -451,
- -451
+ -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
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
-#define YYTABLE_NINF -134
+#define YYTABLE_NINF -180
static const short int yytable[] =
{
- 85, 225, 226, 25, 201, 106, 312, 252, 253, 211,
- 364, 330, 214, 85, 40, 118, 90, 484, 4, 342,
- 344, 93, 30, 366, 280, 217, 218, 219, 220, 221,
- 222, 223, 224, 228, 331, 494, 392, 351, 231, 215,
- 204, 235, 122, 25, 394, 236, 237, 238, 239, 360,
- 205, 216, 365, 243, 244, 118, 40, 217, 218, 219,
- 220, 221, 222, 223, 224, 365, 44, 45, 46, 392,
- 492, 183, 184, 185, 245, -71, 248, 107, 108, 395,
- 500, 392, 249, 120, 122, 47, 210, 393, 49, 210,
- 61, 62, 50, 116, 64, 65, 66, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 19, 27, 20,
- 28, 392, 56, 229, 230, 210, 232, 233, 210, 406,
- 58, 91, 210, 210, 210, 210, 94, 240, 241, 242,
- 210, 210, 328, 77, 99, 279, 281, 282, 283, 352,
- 60, 19, 122, 20, 100, 303, 483, 110, 111, 112,
- 303, 303, 176, 177, 246, 247, 386, 254, 255, -31,
- -31, 101, 303, -30, -30, -29, -29, 303, 285, 103,
- 51, -28, -28, 256, 257, 303, 303, 303, 493, -72,
- 102, 113, 308, 114, 115, 121, 444, 175, 445, 179,
- 85, 7, 8, 9, 10, 52, 12, 53, 180, 326,
- 54, 371, 181, 373, 374, 375, 202, 85, 327, 210,
- 380, 78, 203, 206, 79, 250, 212, 80, -35, 81,
- 117, -34, -33, 283, -32, 259, 387, 388, 389, 390,
- 391, -38, -39, -41, 260, 19, 289, 20, 396, 397,
- 398, 399, 400, 303, 6, -41, -41, 314, 309, 303,
- 290, 311, 315, 316, -41, -41, -41, -41, -41, -41,
- -41, 303, 303, -41, 21, 317, 318, 319, 320, 324,
- 325, 22, 329, 334, 335, 23, 336, 345, 210, 372,
- 210, 210, 210, 355, 430, 353, 379, 210, 217, 218,
- 219, 220, 221, 222, 223, 224, 337, 358, 338, 303,
- 346, 303, 449, 450, 451, 303, 384, 385, 347, 348,
- 349, 303, 303, 303, 350, 361, 356, 285, 455, 456,
- 457, 458, 362, 459, 460, 461, 367, 463, 370, 210,
- 376, 469, 377, 378, 383, 305, 306, 405, 330, 225,
- 226, 407, 303, 303, 408, 424, 409, 307, 411, 423,
- 303, 415, 313, 417, 418, 419, 426, 225, 226, 303,
- 321, 322, 323, 427, 428, 488, 429, 489, 490, 431,
- 432, 210, 31, 32, 33, 34, 35, 36, 37, 210,
- 210, 210, 433, 303, 434, 210, 435, 436, 438, 443,
- 446, 448, 61, 62, 464, 454, 462, 465, 466, 467,
- 468, 473, 365, 472, 482, 470, 475, 474, 210, 19,
- 476, 20, 477, 261, 478, 479, 480, 303, 481, 495,
- 486, 496, 487, 497, 498, 262, 263, 499, 363, 502,
- 303, 503, 504, 506, 369, 507, 165, 303, 166, 167,
- 168, 303, 303, 169, 97, 55, 381, 382, 403, 208,
- 278, 57, 105, 402, 26, 414, 96, 452, 425, 0,
- 0, 0, 0, 0, 0, 133, 134, 135, 136, 137,
- 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
- 148, 149, 150, 0, 410, 0, 412, 0, 264, 0,
- 416, 0, 0, 0, 0, 0, 420, 421, 422, 0,
- 0, 0, 265, 157, 158, 159, 0, 266, 267, 268,
- 164, 0, 0, 0, 0, 0, 269, 0, 0, 270,
- 0, 271, 0, 0, 272, 0, 0, 439, 440, 0,
- 0, 0, 0, 0, 0, 447, 0, 0, 0, 0,
- 0, 0, 61, 62, 453, 116, 186, 187, 188, 189,
- 190, 191, 192, 193, 194, 195, 196, 75, 76, 19,
- 0, 20, 0, 291, 292, 61, 62, 293, 471, 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, 19, 0, 20, 77, 294, 295, 296, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 297, 298,
- 0, 0, 491, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 501, 0, 0, 0, 0,
- 0, 299, 505, 0, 0, 0, 508, 509, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 133, 134,
- 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
- 145, 146, 147, 148, 149, 150, 0, 0, 0, 0,
- 0, 264, 0, 78, 291, 292, 79, 0, 293, 80,
- -133, 81, 343, 0, 0, 265, 157, 158, 159, 0,
- 266, 267, 268, 164, 0, 0, 0, 294, 295, 296,
- 0, 0, 300, 0, 0, 5, 0, 0, 0, 297,
- 298, 6, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 7, 8, 9, 10, 11, 12, 13, 0, 0,
- 0, 0, 299, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 14, 0, 0, 0, 0, 0, 0, 133,
- 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
- 144, 145, 146, 147, 148, 149, 150, 0, 0, 0,
- 0, 0, 264, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 265, 157, 158, 159,
- 0, 266, 267, 268, 164, 0, 0, 0, 0, 0,
- 0, 61, 62, 300, 116, 64, 65, 66, 67, 68,
- 69, 70, 71, 72, 73, 74, 75, 76, 19, 0,
- 20, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 207, 0, 0, 0, 0, 0, 0,
- 0, 0, 61, 62, 77, 116, 64, 65, 66, 67,
- 68, 69, 70, 71, 72, 73, 74, 75, 76, 19,
- 0, 20, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 284, 0, 0, 0, 0, 0,
- 0, 0, 0, 61, 62, 77, 116, 186, 187, 188,
- 189, 190, 191, 192, 193, 194, 195, 196, 75, 76,
- 19, 0, 20, 0, 61, 62, 0, 116, 64, 65,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 19, 78, 20, 0, 79, 77, 0, 80, 0,
- 81, 0, 0, 0, 0, 0, 357, 0, 0, 0,
- 0, 0, 0, 0, 0, 61, 62, 77, 116, 64,
- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 19, 78, 20, 0, 79, 0, 0, 80,
- 0, 81, 0, 0, 0, 0, 0, 401, 0, 0,
- 0, 0, 0, 0, 0, 0, 61, 62, 77, 63,
- 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 19, 78, 20, 0, 79, 0, 339,
- 80, 0, 81, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 78, 0, 0, 79, 77,
- 0, 80, 0, 81, 61, 62, 0, 116, 64, 65,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 19, 0, 20, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 78, 0, 0, 79,
- 0, 0, 80, 0, 81, 61, 62, 77, 116, 186,
- 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
- 75, 76, 19, 0, 20, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 78, 0, 0,
- 79, 0, 0, 80, 0, 81, 61, 62, 77, 213,
- 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 19, 0, 20, 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, 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, 346, 0, 0, 0, 0, 0,
+ 0, 0, 0, 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, 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, 0, 0, 0, 0, 78, 0, 0, 79, 77,
- 0, 80, 0, 81, 0, 0, 0, 0, 123, 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, 124, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 125, 126, 0, 0, 78, 0, 0, 79,
- 0, 0, 80, 0, 81, 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, 0, 0, 78, 0, 0,
- 79, 0, 0, 80, 0, 81, 0, 155, 156, 157,
- 158, 159, 160, 161, 162, 163, 164
+ 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,
+ 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,
+ 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
+ 0, 0, 0, 0, 0, 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, 0, 163, 164,
+ 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
+ 175
};
static const short int yycheck[] =
{
- 38, 129, 129, 3, 112, 51, 230, 184, 185, 124,
- 15, 34, 127, 51, 23, 81, 29, 467, 0, 270,
- 271, 30, 61, 15, 201, 10, 11, 12, 13, 14,
- 15, 16, 17, 130, 57, 485, 125, 131, 153, 9,
- 125, 156, 136, 43, 133, 160, 161, 162, 163, 300,
- 135, 21, 57, 168, 169, 121, 23, 10, 11, 12,
- 13, 14, 15, 16, 17, 57, 52, 53, 54, 125,
- 484, 109, 110, 111, 171, 127, 125, 32, 33, 135,
- 494, 125, 131, 83, 136, 71, 124, 131, 124, 127,
- 5, 6, 61, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 45, 24,
- 47, 125, 124, 151, 152, 153, 154, 155, 156, 133,
- 24, 134, 160, 161, 162, 163, 135, 165, 166, 167,
- 168, 169, 247, 48, 124, 200, 202, 203, 204, 133,
- 4, 22, 136, 24, 124, 210, 131, 53, 54, 55,
- 215, 216, 55, 56, 99, 100, 333, 27, 28, 3,
- 4, 124, 227, 3, 4, 3, 4, 232, 206, 129,
- 20, 3, 4, 3, 4, 240, 241, 242, 131, 127,
- 124, 4, 228, 4, 4, 127, 410, 24, 412, 4,
- 228, 41, 42, 43, 44, 45, 46, 47, 24, 245,
- 50, 316, 24, 318, 319, 320, 130, 245, 246, 247,
- 325, 126, 130, 127, 129, 125, 59, 132, 4, 134,
- 135, 4, 4, 289, 4, 4, 334, 335, 336, 337,
- 338, 7, 7, 20, 7, 22, 125, 24, 346, 347,
- 348, 349, 350, 308, 31, 32, 33, 129, 125, 314,
- 128, 125, 125, 125, 41, 42, 43, 44, 45, 46,
- 47, 326, 327, 50, 51, 125, 125, 125, 125, 36,
- 125, 58, 24, 127, 127, 62, 127, 24, 316, 317,
- 318, 319, 320, 125, 392, 285, 324, 325, 10, 11,
- 12, 13, 14, 15, 16, 17, 127, 63, 127, 364,
- 127, 366, 417, 418, 419, 370, 24, 4, 127, 127,
- 127, 376, 377, 378, 127, 125, 128, 355, 426, 427,
- 428, 429, 125, 431, 432, 433, 125, 435, 129, 367,
- 125, 446, 125, 125, 125, 215, 216, 24, 34, 467,
- 467, 21, 407, 408, 21, 383, 127, 227, 4, 127,
- 415, 125, 232, 125, 125, 125, 125, 485, 485, 424,
- 240, 241, 242, 125, 125, 473, 125, 475, 476, 125,
- 125, 409, 64, 65, 66, 67, 68, 69, 70, 417,
- 418, 419, 125, 448, 36, 423, 125, 57, 125, 125,
- 125, 125, 5, 6, 4, 128, 434, 24, 125, 129,
- 128, 125, 57, 128, 21, 131, 125, 128, 446, 22,
- 125, 24, 128, 26, 128, 128, 128, 482, 128, 21,
- 36, 128, 131, 128, 128, 38, 39, 125, 308, 21,
- 495, 125, 76, 21, 314, 21, 97, 502, 97, 97,
- 97, 506, 507, 97, 43, 24, 326, 327, 356, 121,
- 200, 29, 50, 355, 3, 367, 41, 423, 387, -1,
- -1, -1, -1, -1, -1, 78, 79, 80, 81, 82,
- 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
- 93, 94, 95, -1, 364, -1, 366, -1, 101, -1,
- 370, -1, -1, -1, -1, -1, 376, 377, 378, -1,
- -1, -1, 115, 116, 117, 118, -1, 120, 121, 122,
- 123, -1, -1, -1, -1, -1, 129, -1, -1, 132,
- -1, 134, -1, -1, 137, -1, -1, 407, 408, -1,
- -1, -1, -1, -1, -1, 415, -1, -1, -1, -1,
- -1, -1, 5, 6, 424, 8, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- -1, 24, -1, 3, 4, 5, 6, 7, 448, -1,
+ 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, 22, -1, 24, 48, 26, 27, 28, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 38, 39,
- -1, -1, 482, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 495, -1, -1, -1, -1,
- -1, 61, 502, -1, -1, -1, 506, 507, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
- 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
- 90, 91, 92, 93, 94, 95, -1, -1, -1, -1,
- -1, 101, -1, 126, 3, 4, 129, -1, 7, 132,
- 0, 134, 135, -1, -1, 115, 116, 117, 118, -1,
- 120, 121, 122, 123, -1, -1, -1, 26, 27, 28,
- -1, -1, 132, -1, -1, 25, -1, -1, -1, 38,
- 39, 31, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 41, 42, 43, 44, 45, 46, 47, -1, -1,
- -1, -1, 61, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 62, -1, -1, -1, -1, -1, -1, 78,
- 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
- 89, 90, 91, 92, 93, 94, 95, -1, -1, -1,
- -1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 115, 116, 117, 118,
- -1, 120, 121, 122, 123, -1, -1, -1, -1, -1,
- -1, 5, 6, 132, 8, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, -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, 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, -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, 20, 21, 22,
- -1, 24, -1, -1, -1, -1, -1, -1, -1, -1,
+ 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, 15, 16, 17, 18, 19, 20, 21,
- 22, -1, 24, -1, 5, 6, -1, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 126, 24, -1, 129, 48, -1, 132, -1,
- 134, -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,
- 20, 21, 22, 126, 24, -1, 129, -1, -1, 132,
- -1, 134, -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, 20, 21, 22, 126, 24, -1, 129, -1, 131,
- 132, -1, 134, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 126, -1, -1, 129, 48,
- -1, 132, -1, 134, 5, 6, -1, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, -1, 24, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 126, -1, -1, 129,
- -1, -1, 132, -1, 134, 5, 6, 48, 8, 9,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, -1, 24, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 126, -1, -1,
- 129, -1, -1, 132, -1, 134, 5, 6, 48, 8,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, -1, 24, -1, -1, -1, -1,
+ 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,
- -1, -1, -1, -1, -1, 126, -1, -1, 129, 48,
- -1, 132, -1, 134, -1, -1, -1, -1, 35, -1,
+ -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, 49, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 59, 60, -1, -1, 126, -1, -1, 129,
- -1, -1, 132, -1, 134, 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, -1, -1, 101, -1, -1, 126, -1, -1,
- 129, -1, -1, 132, -1, 134, -1, 114, 115, 116,
- 117, 118, 119, 120, 121, 122, 123
+ -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,
+ 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, -1, -1, -1,
+ -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
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
{
- 0, 170, 171, 172, 0, 25, 31, 41, 42, 43,
- 44, 45, 46, 47, 62, 151, 185, 187, 189, 22,
- 24, 51, 58, 62, 150, 178, 189, 45, 47, 188,
- 61, 64, 65, 66, 67, 68, 69, 70, 152, 183,
- 23, 195, 196, 197, 52, 53, 54, 71, 175, 124,
- 61, 20, 45, 47, 50, 151, 124, 183, 24, 173,
- 4, 5, 6, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 48, 126, 129,
- 132, 134, 139, 159, 160, 161, 162, 163, 178, 192,
- 29, 134, 184, 30, 135, 186, 196, 150, 200, 124,
- 124, 124, 124, 129, 176, 173, 159, 32, 33, 169,
- 169, 169, 169, 4, 4, 4, 8, 135, 163, 164,
- 178, 127, 136, 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, 101, 114, 115, 116, 117, 118,
- 119, 120, 121, 122, 123, 141, 142, 143, 144, 145,
- 198, 204, 205, 207, 208, 24, 55, 56, 174, 4,
- 24, 24, 177, 161, 161, 161, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 146, 147, 149,
- 161, 166, 130, 130, 125, 135, 127, 37, 164, 165,
- 161, 194, 59, 8, 194, 9, 21, 10, 11, 12,
- 13, 14, 15, 16, 17, 146, 147, 148, 152, 161,
- 161, 194, 161, 161, 201, 194, 194, 194, 194, 194,
- 161, 161, 161, 194, 194, 152, 99, 100, 125, 131,
- 125, 157, 157, 157, 27, 28, 3, 4, 140, 4,
- 7, 26, 38, 39, 101, 115, 120, 121, 122, 129,
- 132, 134, 137, 141, 142, 143, 144, 145, 167, 192,
- 157, 163, 163, 163, 37, 161, 180, 181, 182, 125,
- 128, 3, 4, 7, 26, 27, 28, 38, 39, 61,
- 132, 167, 191, 192, 193, 193, 193, 193, 159, 125,
- 154, 125, 154, 193, 129, 125, 125, 125, 125, 125,
- 125, 193, 193, 193, 36, 125, 159, 161, 194, 24,
- 34, 57, 155, 158, 127, 127, 127, 127, 127, 131,
- 166, 168, 168, 135, 168, 24, 127, 127, 127, 127,
- 127, 131, 133, 178, 179, 125, 128, 37, 63, 190,
- 168, 125, 125, 193, 15, 57, 15, 125, 206, 193,
- 129, 194, 161, 194, 194, 194, 125, 125, 125, 161,
- 194, 193, 193, 125, 24, 4, 157, 166, 166, 166,
- 166, 166, 125, 131, 133, 135, 166, 166, 166, 166,
- 166, 37, 180, 155, 156, 24, 133, 21, 21, 127,
- 193, 4, 193, 194, 202, 125, 193, 125, 125, 125,
- 193, 193, 193, 127, 161, 206, 125, 125, 125, 125,
- 166, 125, 125, 125, 36, 125, 57, 153, 125, 193,
- 193, 202, 203, 125, 154, 154, 125, 193, 125, 194,
- 194, 194, 203, 193, 128, 166, 166, 166, 166, 166,
- 166, 166, 161, 166, 4, 24, 125, 129, 128, 194,
- 131, 193, 128, 125, 128, 125, 125, 128, 128, 128,
- 128, 128, 21, 131, 148, 199, 36, 131, 166, 166,
- 166, 193, 191, 131, 148, 21, 128, 128, 128, 125,
- 191, 193, 21, 125, 76, 193, 21, 21, 193, 193
+ 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
+ 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, 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, 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)
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
- /* If the proper action on seeing token YYTOKEN is to reduce or to
- detect an error, take that action. */
- yyn += yytoken;
- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
- goto yydefault;
- yyn = yytable[yyn];
- if (yyn <= 0)
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yyn == 0 || yyn == YYTABLE_NINF)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the look-ahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ `$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 3:
+#line 1912 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
+ error("Value too large for type");
+ (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
+ ;}
+ break;
+
+ case 5:
+#line 1921 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
+ error("Value too large for type");
+ (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
+ ;}
+ break;
+
+ case 26:
+#line 1943 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
+ break;
+
+ case 27:
+#line 1943 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
+ break;
+
+ case 28:
+#line 1944 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
+ break;
+
+ case 29:
+#line 1944 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
+ break;
+
+ case 30:
+#line 1945 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
+ break;
+
+ case 31:
+#line 1945 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
+ break;
+
+ case 32:
+#line 1946 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
+ break;
+
+ case 33:
+#line 1946 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
+ break;
+
+ case 34:
+#line 1947 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
+ break;
+
+ case 35:
+#line 1947 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
+ break;
+
+ case 36:
+#line 1951 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
+ break;
+
+ case 37:
+#line 1951 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
+ break;
+
+ case 38:
+#line 1952 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
+ break;
+
+ case 39:
+#line 1952 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
+ break;
+
+ case 40:
+#line 1953 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
+ break;
+
+ case 41:
+#line 1953 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
+ break;
+
+ case 42:
+#line 1954 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
+ break;
+
+ case 43:
+#line 1954 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
+ break;
+
+ case 44:
+#line 1955 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
+ break;
+
+ case 45:
+#line 1955 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
+ break;
+
+ case 46:
+#line 1956 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
+ break;
+
+ case 47:
+#line 1956 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
+ break;
+
+ case 48:
+#line 1957 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
+ break;
+
+ case 49:
+#line 1957 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
+ break;
+
+ case 50:
+#line 1958 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
+ break;
+
+ case 51:
+#line 1959 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
+ break;
+
+ case 81:
+#line 1990 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.StrVal) = (yyvsp[-1].StrVal);
+ ;}
+ break;
+
+ case 82:
+#line 1993 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- if (yyn == 0 || yyn == YYTABLE_NINF)
- goto yyerrlab;
- yyn = -yyn;
- goto yyreduce;
- }
+ (yyval.StrVal) = 0;
+ ;}
+ break;
- if (yyn == YYFINAL)
- YYACCEPT;
+ case 83:
+#line 1998 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
+ break;
- /* Shift the look-ahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+ case 84:
+#line 1999 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
+ break;
- /* Discard the token being shifted unless it is eof. */
- if (yychar != YYEOF)
- yychar = YYEMPTY;
+ case 85:
+#line 2000 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
+ break;
- *++yyvsp = yylval;
+ case 86:
+#line 2001 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
+ break;
+ case 87:
+#line 2002 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
+ break;
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
+ case 88:
+#line 2003 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
+ break;
- yystate = yyn;
- goto yynewstate;
+ case 89:
+#line 2004 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
+ break;
+ case 90:
+#line 2005 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
+ break;
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state. |
-`-----------------------------------------------------------*/
-yydefault:
- yyn = yydefact[yystate];
- if (yyn == 0)
- goto yyerrlab;
- goto yyreduce;
+ case 91:
+#line 2009 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::C; ;}
+ break;
+ case 92:
+#line 2010 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::C; ;}
+ break;
-/*-----------------------------.
-| yyreduce -- Do a reduction. |
-`-----------------------------*/
-yyreduce:
- /* yyn is the number of a rule to reduce with. */
- yylen = yyr2[yyn];
+ case 93:
+#line 2011 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::CSRet; ;}
+ break;
- /* If YYLEN is nonzero, implement the default value of the action:
- `$$ = $1'.
+ case 94:
+#line 2012 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::Fast; ;}
+ break;
- Otherwise, the following line sets YYVAL to garbage.
- This behavior is undocumented and Bison
- users should not rely upon it. Assigning to YYVAL
- unconditionally makes the parser a bit smaller, and it avoids a
- GCC warning that YYVAL may be used uninitialized. */
- yyval = yyvsp[1-yylen];
+ case 95:
+#line 2013 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::Cold; ;}
+ break;
+ case 96:
+#line 2014 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
+ break;
- YY_REDUCE_PRINT (yyn);
- switch (yyn)
+ case 97:
+#line 2015 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
+ break;
+
+ case 98:
+#line 2016 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
+ error("Calling conv too large");
+ (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+ ;}
+ break;
+
+ case 99:
+#line 2026 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = 0; ;}
+ break;
+
+ case 100:
+#line 2027 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- case 40:
-#line 103 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+ if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+ error("Alignment must be a power of two");
+ ;}
+ break;
+
+ case 101:
+#line 2035 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.UIntVal) = 0; ;}
+ break;
+
+ case 102:
+#line 2036 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyvsp[-1])->append(" = ");
- (yyval) = (yyvsp[-1]);
+ (yyval.UIntVal) = (yyvsp[0].UInt64Val);
+ if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
+ error("Alignment must be a power of two");
;}
break;
- case 41:
-#line 107 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 103:
+#line 2044 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string("");
+ for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
+ if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
+ error("Invalid character in section name");
+ (yyval.StrVal) = (yyvsp[0].StrVal);
;}
break;
- case 49:
-#line 114 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(""); ;}
+ case 104:
+#line 2053 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.StrVal) = 0; ;}
+ break;
+
+ case 105:
+#line 2054 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
break;
- case 57:
-#line 119 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(""); ;}
+ case 106:
+#line 2061 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {;}
break;
- case 58:
-#line 124 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 107:
+#line 2062 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {;}
break;
- case 59:
-#line 125 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { *(yyvsp[-1]) += " " + *(yyvsp[0]); delete (yyvsp[0]); (yyval) = (yyvsp[-1]); ;}
+ case 108:
+#line 2066 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ CurGV->setSection((yyvsp[0].StrVal));
+ free((yyvsp[0].StrVal));
+ ;}
break;
- case 60:
-#line 128 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 109:
+#line 2070 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
+ error("Alignment must be a power of two");
+ CurGV->setAlignment((yyvsp[0].UInt64Val));
+
+ ;}
break;
- case 61:
-#line 129 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 111:
+#line 2087 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyvsp[-1])->insert(0, ", ");
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
+ (yyval.TypeVal).S.makeSignless();
;}
break;
- case 62:
-#line 137 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 113:
+#line 2095 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
+ (yyval.TypeVal).S.makeSignless();
;}
break;
- case 63:
-#line 143 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 114:
+#line 2102 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ if (!UpRefs.empty())
+ error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription());
+ (yyval.TypeVal) = (yyvsp[0].TypeVal);
+ ;}
break;
- case 65:
-#line 147 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 127:
+#line 2116 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
+ (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S);
+ ;}
break;
- case 66:
-#line 148 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 128:
+#line 2120 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyvsp[-1])->insert(0, ", ");
- if (!(yyvsp[0])->empty())
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
- ;}
+ (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get());
+ (yyval.TypeVal).S.makeSignless();
+ ;}
break;
- case 68:
-#line 158 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
- ;}
+ case 129:
+#line 2124 "/proj/llvm/llvm-2/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).PAT = new PATypeHolder(tmp);
+ ;}
break;
- case 90:
-#line 183 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 130:
+#line 2129 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Type UpReference
- (yyvsp[0])->insert(0, "\\");
- (yyval) = (yyvsp[0]);
+ 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).PAT = new PATypeHolder(OT);
+ (yyval.TypeVal).S.makeSignless();
+ UR_OUT("New Upreference!\n");
;}
break;
- case 91:
-#line 187 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 131:
+#line 2138 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Function derived type?
- *(yyvsp[-3]) += "( " + *(yyvsp[-1]) + " )";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S);
+ std::vector<const Type*> Params;
+ for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
+ E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
+ 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();
+
+ const FunctionType *FTy =
+ FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg, 0);
+
+ (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 92:
-#line 192 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 132:
+#line 2156 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Sized array type?
- (yyvsp[-3])->insert(0,"[ ");
- *(yyvsp[-3]) += " x " + *(yyvsp[-1]) + " ]";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ (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 93:
-#line 198 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { // Packed array type?
- (yyvsp[-3])->insert(0,"< ");
- *(yyvsp[-3]) += " x " + *(yyvsp[-1]) + " >";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ case 133:
+#line 2162 "/proj/llvm/llvm-2/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 94:
-#line 204 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 134:
+#line 2175 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Structure type?
- (yyvsp[-1])->insert(0, "{ ");
- *(yyvsp[-1]) += " }";
- (yyval) = (yyvsp[-1]);
+ std::vector<const Type*> Elements;
+ (yyval.TypeVal).S.makeComposite();
+ for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
+ 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 95:
-#line 209 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 135:
+#line 2186 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Empty structure type?
- (yyval) = new std::string("{ }");
+ (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>()));
+ (yyval.TypeVal).S.makeComposite();
;}
break;
- case 96:
-#line 212 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 136:
+#line 2190 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Packed Structure type?
+ (yyval.TypeVal).S.makeComposite();
+ std::vector<const Type*> Elements;
+ for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
+ E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
+ Elements.push_back(I->PAT->get());
+ (yyval.TypeVal).S.add(I->S);
+ delete I->PAT;
+ }
+ (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true),
+ (yyval.TypeVal).S));
+ delete (yyvsp[-2].TypeList);
+ ;}
+ break;
+
+ case 137:
+#line 2203 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Empty packed structure type?
+ (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
+ (yyval.TypeVal).S.makeComposite();
+ ;}
+ break;
+
+ case 138:
+#line 2207 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Pointer type?
- *(yyvsp[-1]) += '*';
- (yyval) = (yyvsp[-1]);
+ if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy)
+ error("Cannot form a pointer to a basic block");
+ (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 98:
-#line 220 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 139:
+#line 2221 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += ", " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ (yyval.TypeList) = new std::list<PATypeInfo>();
+ (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
;}
break;
- case 100:
-#line 228 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 140:
+#line 2225 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += ", ...";
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
;}
break;
- case 101:
-#line 233 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 142:
+#line 2233 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = (yyvsp[0]);
+ PATypeInfo VoidTI;
+ VoidTI.PAT = new PATypeHolder(Type::VoidTy);
+ VoidTI.S.makeSignless();
+ ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
;}
break;
- case 102:
-#line 236 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 143:
+#line 2239 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string();
+ (yyval.TypeList) = new std::list<PATypeInfo>();
+ PATypeInfo VoidTI;
+ VoidTI.PAT = new PATypeHolder(Type::VoidTy);
+ VoidTI.S.makeSignless();
+ (yyval.TypeList)->push_back(VoidTI);
;}
break;
- case 103:
-#line 246 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 144:
+#line 2246 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.TypeList) = new std::list<PATypeInfo>();
+ ;}
+ break;
+
+ case 145:
+#line 2258 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Nonempty unsized arr
- *(yyvsp[-3]) += " [ " + *(yyvsp[-1]) + " ]";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).PAT->get());
+ if (ATy == 0)
+ error("Cannot make array constant with type: '" +
+ (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
+ const Type *ETy = ATy->getElementType();
+ int NumElements = ATy->getNumElements();
+
+ // Verify that we have the correct size...
+ if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
+ error("Type mismatch: constant sized array initialized with " +
+ utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
+ itostr(NumElements) + "");
+
+ // Verify all elements are correct type!
+ std::vector<Constant*> Elems;
+ for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+ Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+ const Type* ValTy = C->getType();
+ if (ETy != ValTy)
+ error("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '"+
+ ValTy->getDescription() + "'");
+ Elems.push_back(C);
+ }
+ (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
+ (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
+ delete (yyvsp[-3].TypeVal).PAT;
+ delete (yyvsp[-1].ConstVector);
;}
break;
- case 104:
-#line 251 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 146:
+#line 2288 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string("[ ]");
+ const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
+ if (ATy == 0)
+ error("Cannot make array constant with type: '" +
+ (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<Constant*>());
+ (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
+ delete (yyvsp[-2].TypeVal).PAT;
;}
break;
- case 105:
-#line 254 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 147:
+#line 2301 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " c" + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
+ if (ATy == 0)
+ error("Cannot make array constant with type: '" +
+ (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
+ int NumElements = ATy->getNumElements();
+ const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
+ if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
+ error("String arrays require type i8, not '" + ETy->getDescription() +
+ "'");
+ char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+ if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
+ error("Can't build string constant of size " +
+ itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
+ itostr(NumElements) + "");
+ std::vector<Constant*> Vals;
+ for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
+ Vals.push_back(ConstantInt::get(ETy, *C));
+ free((yyvsp[0].StrVal));
+ (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
+ (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
+ delete (yyvsp[-2].TypeVal).PAT;
;}
break;
- case 106:
-#line 259 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 148:
+#line 2324 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Nonempty unsized arr
- *(yyvsp[-3]) += " < " + *(yyvsp[-1]) + " >";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ const VectorType *PTy = dyn_cast<VectorType>((yyvsp[-3].TypeVal).PAT->get());
+ if (PTy == 0)
+ error("Cannot make packed constant with type: '" +
+ (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
+ const Type *ETy = PTy->getElementType();
+ int NumElements = PTy->getNumElements();
+ // Verify that we have the correct size...
+ if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
+ error("Type mismatch: constant sized packed initialized with " +
+ utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
+ itostr(NumElements) + "");
+ // Verify all elements are correct type!
+ std::vector<Constant*> Elems;
+ for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+ Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+ const Type* ValTy = C->getType();
+ if (ETy != ValTy)
+ error("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '"+
+ ValTy->getDescription() + "'");
+ Elems.push_back(C);
+ }
+ (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 107:
-#line 264 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 149:
+#line 2352 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += " { " + *(yyvsp[-1]) + " }";
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-3]);
+ const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).PAT->get());
+ if (STy == 0)
+ error("Cannot make struct constant with type: '" +
+ (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
+ if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
+ error("Illegal number of initializers for structure type");
+
+ // Check to ensure that constants are compatible with the type initializer!
+ std::vector<Constant*> Fields;
+ for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
+ Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+ if (C->getType() != STy->getElementType(i))
+ error("Expected type '" + STy->getElementType(i)->getDescription() +
+ "' for element #" + utostr(i) + " of structure initializer");
+ Fields.push_back(C);
+ }
+ (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
+ (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
+ delete (yyvsp[-3].TypeVal).PAT;
+ delete (yyvsp[-1].ConstVector);
;}
break;
- case 108:
-#line 269 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 150:
+#line 2374 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string("[ ]");
+ const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).PAT->get());
+ if (STy == 0)
+ error("Cannot make struct constant with type: '" +
+ (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<Constant*>());
+ (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
+ delete (yyvsp[-2].TypeVal).PAT;
;}
break;
- case 109:
-#line 272 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 151:
+#line 2385 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).PAT->get());
+ if (STy == 0)
+ error("Cannot make packed struct constant with type: '" +
+ (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'");
+ if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
+ error("Illegal number of initializers for packed structure type");
+
+ // Check to ensure that constants are compatible with the type initializer!
+ std::vector<Constant*> Fields;
+ for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
+ Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
+ if (C->getType() != STy->getElementType(i))
+ error("Expected type '" + STy->getElementType(i)->getDescription() +
+ "' for element #" + utostr(i) + " of packed struct initializer");
+ Fields.push_back(C);
+ }
+ (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
+ (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S);
+ delete (yyvsp[-5].TypeVal).PAT;
+ delete (yyvsp[-2].ConstVector);
+ ;}
+ break;
+
+ case 152:
+#line 2407 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).PAT->get());
+ if (STy == 0)
+ error("Cannot make packed struct constant with type: '" +
+ (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<Constant*>());
+ (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S);
+ delete (yyvsp[-4].TypeVal).PAT;
;}
break;
- case 110:
-#line 277 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 153:
+#line 2418 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
+ if (PTy == 0)
+ error("Cannot make null pointer constant with type: '" +
+ (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'");
+ (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
+ (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
+ delete (yyvsp[-1].TypeVal).PAT;
;}
break;
- case 111:
-#line 282 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 154:
+#line 2427 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (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 112:
-#line 287 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 155:
+#line 2432 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
+ if (Ty == 0)
+ error("Global const reference must be a pointer type, not" +
+ (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
+ // the context of a function, getExistingValue will search the functions
+ // symbol table instead of the module symbol table for the global symbol,
+ // which throws things all off. To get around this, we just tell
+ // getExistingValue that we are at global scope here.
+ //
+ Function *SavedCurFn = CurFun.CurrentFunction;
+ CurFun.CurrentFunction = 0;
+ (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
+ Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
+ CurFun.CurrentFunction = SavedCurFn;
+
+ // If this is an initializer for a constant pointer, which is referencing a
+ // (currently) undefined variable, create a stub now that shall be replaced
+ // in the future with the right type of variable.
+ //
+ if (V == 0) {
+ assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
+ const PointerType *PT = cast<PointerType>(Ty);
+
+ // First check to see if the forward references value is already created!
+ PerModuleInfo::GlobalRefsType::iterator I =
+ CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
+
+ if (I != CurModule.GlobalRefs.end()) {
+ V = I->second; // Placeholder already exists, use it...
+ (yyvsp[0].ValIDVal).destroy();
+ } else {
+ std::string Name;
+ if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
+
+ // Create the forward referenced global.
+ GlobalValue *GV;
+ if (const FunctionType *FTy =
+ dyn_cast<FunctionType>(PT->getElementType())) {
+ GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
+ CurModule.CurrentModule);
+ } else {
+ GV = new GlobalVariable(PT->getElementType(), false,
+ GlobalValue::ExternalLinkage, 0,
+ Name, CurModule.CurrentModule);
+ }
+
+ // Keep track of the fact that we have a forward ref to recycle it
+ CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
+ V = GV;
+ }
+ }
+ (yyval.ConstVal).C = cast<GlobalValue>(V);
+ (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
+ delete (yyvsp[-1].TypeVal).PAT; // Free the type handle
;}
break;
- case 113:
-#line 292 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 156:
+#line 2491 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ 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.copy((yyvsp[-1].TypeVal).S);
+ delete (yyvsp[-1].TypeVal).PAT;
;}
break;
- case 114:
-#line 298 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 157:
+#line 2498 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
+ if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
+ error("Cannot create a null initialized value of this type");
+ (yyval.ConstVal).C = Constant::getNullValue(Ty);
+ (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
+ delete (yyvsp[-1].TypeVal).PAT;
+ ;}
+ break;
+
+ case 158:
+#line 2506 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // integral constants
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ 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.makeSigned();
;}
break;
- case 115:
-#line 303 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 159:
+#line 2513 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // integral constants
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ 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.makeUnsigned();
;}
break;
- case 116:
-#line 308 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 160:
+#line 2520 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Boolean constants
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
+ (yyval.ConstVal).S.makeUnsigned();
;}
break;
- case 117:
-#line 313 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 161:
+#line 2524 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Boolean constants
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
+ (yyval.ConstVal).S.makeUnsigned();
;}
break;
- case 118:
-#line 318 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 162:
+#line 2528 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Float & Double constants
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ 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.makeSignless();
;}
break;
- case 119:
-#line 325 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 163:
+#line 2537 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " (" + *(yyvsp[-3]) + " " + *(yyvsp[-2]) + " " + *(yyvsp[-1]) + ")";
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]);
- (yyval) = (yyvsp[-5]);
+ const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
+ 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() + "'");
+ if (!DstTy->isFirstClassType())
+ error("cast constant expression to a non-primitive type: '" +
+ DstTy->getDescription() + "'");
+ (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
+ (yyval.ConstVal).S.copy(DstSign);
+ delete (yyvsp[-1].TypeVal).PAT;
;}
break;
- case 120:
-#line 330 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 164:
+#line 2552 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
+ if (!isa<PointerType>(Ty))
+ error("GetElementPtr requires a pointer operand");
+
+ std::vector<Constant*> 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[0], CIndices.size());
+ (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices));
;}
break;
- case 121:
-#line 332 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 165:
+#line 2564 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
+ cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
+ error("Select condition must be bool type");
+ 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.copy((yyvsp[-3].ConstVal).S);
;}
break;
- case 122:
-#line 334 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 166:
+#line 2573 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
+ if (Ty != (yyvsp[-1].ConstVal).C->getType())
+ error("Binary operator types must match");
+ // First, make sure we're dealing with the right opcode by upgrading from
+ // obsolete versions.
+ Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
+
+ // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
+ // To retain backward compatibility with these early compilers, we emit a
+ // cast to the appropriate integer type automatically if we are in the
+ // broken case. See PR424 for more information.
+ if (!isa<PointerType>(Ty)) {
+ (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
+ } else {
+ const Type *IntPtrTy = 0;
+ switch (CurModule.CurrentModule->getPointerSize()) {
+ case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
+ case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
+ default: error("invalid pointer binary constant expr");
+ }
+ (yyval.ConstVal).C = ConstantExpr::get(Opcode,
+ ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
+ ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
+ (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
+ }
+ (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
;}
break;
- case 123:
-#line 336 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 167:
+#line 2601 "/proj/llvm/llvm-2/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<VectorType>(Ty) ||
+ !cast<VectorType>(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.copy((yyvsp[-3].ConstVal).S);
;}
break;
- case 124:
-#line 338 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 168:
+#line 2614 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
+ if (Ty != (yyvsp[-1].ConstVal).C->getType())
+ error("setcc operand types must match");
+ 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.makeUnsigned();
;}
break;
- case 125:
-#line 340 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 169:
+#line 2623 "/proj/llvm/llvm-2/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.makeUnsigned();
;}
break;
- case 126:
-#line 342 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 170:
+#line 2629 "/proj/llvm/llvm-2/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.makeUnsigned();
;}
break;
- case 127:
-#line 344 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 171:
+#line 2635 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
+ cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
+ error("Shift count for shift constant must be unsigned byte");
+ const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
+ if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
+ 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.copy((yyvsp[-3].ConstVal).S);
;}
break;
- case 128:
-#line 346 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 172:
+#line 2646 "/proj/llvm/llvm-2/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.copy((yyvsp[-3].ConstVal).S.get(0));
;}
break;
- case 129:
-#line 351 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 173:
+#line 2652 "/proj/llvm/llvm-2/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.copy((yyvsp[-5].ConstVal).S);
;}
break;
- case 130:
-#line 353 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 174:
+#line 2658 "/proj/llvm/llvm-2/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.copy((yyvsp[-5].ConstVal).S);
;}
break;
- case 131:
-#line 358 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { ;}
+ case 175:
+#line 2669 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
break;
- case 132:
-#line 358 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { ;}
+ case 176:
+#line 2670 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.ConstVector) = new std::vector<ConstInfo>();
+ (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
+ ;}
break;
- case 133:
-#line 368 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
-;}
+ case 177:
+#line 2679 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = false; ;}
break;
- case 134:
-#line 373 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 178:
+#line 2680 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = true; ;}
+ break;
+
+ case 179:
+#line 2692 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = 0;
+ (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
+ CurModule.ModuleDone();
;}
break;
- case 135:
-#line 376 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 180:
+#line 2701 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
+ break;
+
+ case 181:
+#line 2702 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
+ break;
+
+ case 182:
+#line 2703 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
+ break;
+
+ case 183:
+#line 2704 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
+ break;
+
+ case 184:
+#line 2705 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.ModuleVal) = CurModule.CurrentModule;
+ // Emit an error if there are any unresolved types left.
+ if (!CurModule.LateResolveTypes.empty()) {
+ const ValID &DID = CurModule.LateResolveTypes.begin()->first;
+ if (DID.Type == ValID::NameVal) {
+ error("Reference to an undefined type: '"+DID.getName() + "'");
+ } else {
+ error("Reference to an undefined type: #" + itostr(DID.Num));
+ }
+ }
;}
break;
- case 136:
-#line 381 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 185:
+#line 2721 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << "module asm " << " " << *(yyvsp[0]) << "\n";
+ // Eagerly resolve types. This is not an optimization, this is a
+ // requirement that is due to the fact that we could have this:
+ //
+ // %list = type { %list * }
+ // %list = type { %list * } ; repeated type decl
+ //
+ // If types are not resolved eagerly, then the two types will not be
+ // determined to be the same type!
+ //
+ ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S);
+
+ 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).PAT;
;}
break;
- case 137:
-#line 384 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- *O << "implementation\n";
+ case 186:
+#line 2741 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Function prototypes can be in const pool
+ ;}
+ break;
+
+ case 187:
+#line 2743 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Asm blocks can be in the const pool
;}
break;
- case 138:
-#line 387 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 188:
+#line 2745 "/proj/llvm/llvm-2/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, (yyvsp[0].ConstVal).S);
;}
break;
- case 139:
-#line 391 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 189:
+#line 2749 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ CurGV = 0;
;}
break;
- case 140:
-#line 396 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { // Function prototypes can be in const pool
- *O << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ case 190:
+#line 2752 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ 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 141:
-#line 401 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { // Asm blocks can be in the const pool
- *O << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ case 191:
+#line 2757 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ CurGV = 0;
;}
break;
- case 142:
-#line 406 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 192:
+#line 2760 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-4]) << " " << *(yyvsp[-3]) << " " << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ 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 143:
-#line 411 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 193:
+#line 2765 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-4]) << " " << *(yyvsp[-3]) << " " << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ CurGV = 0;
;}
break;
- case 144:
-#line 416 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 194:
+#line 2768 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-4]) << " " << *(yyvsp[-3]) << " " << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
+ CurGV =
+ ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0,
+ (yyvsp[0].TypeVal).S);
+ delete (yyvsp[0].TypeVal).PAT;
;}
break;
- case 145:
-#line 421 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 195:
+#line 2774 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-4]) << " " << *(yyvsp[-3]) << " " << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ CurGV = 0;
;}
break;
- case 146:
-#line 426 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 196:
+#line 2777 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
;}
break;
- case 147:
-#line 431 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 197:
+#line 2779 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-2]) << " = " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = 0;
;}
break;
- case 148:
-#line 436 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 198:
+#line 2781 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = 0;
;}
break;
- case 152:
-#line 446 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 199:
+#line 2786 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " = " + *(yyvsp[-1]);
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-2]);
+ const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
+ char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
+ std::string NewAsm((yyvsp[0].StrVal), EndStr);
+ free((yyvsp[0].StrVal));
+
+ if (AsmSoFar.empty())
+ CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+ else
+ CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
;}
break;
- case 153:
-#line 451 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 200:
+#line 2800 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Endianness) = Module::BigEndian; ;}
+ break;
+
+ case 201:
+#line 2801 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Endianness) = Module::LittleEndian; ;}
+ break;
+
+ case 202:
+#line 2805 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " = " + *(yyvsp[-1]);
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-2]);
+ CurModule.setEndianness((yyvsp[0].Endianness));
;}
break;
- case 154:
-#line 456 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 203:
+#line 2808 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " = " + *(yyvsp[-1]);
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-2]);
+ if ((yyvsp[0].UInt64Val) == 32)
+ CurModule.setPointerSize(Module::Pointer32);
+ else if ((yyvsp[0].UInt64Val) == 64)
+ CurModule.setPointerSize(Module::Pointer64);
+ else
+ error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
;}
break;
- case 155:
-#line 461 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 204:
+#line 2816 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " = " + *(yyvsp[-1]);
- delete (yyvsp[-1]);
- (yyval) = (yyvsp[-2]);
+ CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
+ free((yyvsp[0].StrVal));
;}
break;
- case 156:
-#line 468 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 205:
+#line 2820 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyvsp[-1])->insert(0, "[ ");
- *(yyvsp[-1]) += " ]";
- (yyval) = (yyvsp[-1]);
+ CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
+ free((yyvsp[0].StrVal));
;}
break;
- case 157:
-#line 475 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 207:
+#line 2831 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += ", " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+ free((yyvsp[0].StrVal));
;}
break;
- case 159:
-#line 481 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 208:
+#line 2835 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string();
+ CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
+ free((yyvsp[0].StrVal));
;}
break;
- case 163:
-#line 490 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 209:
+#line 2839 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { ;}
break;
- case 164:
-#line 492 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- (yyval) = (yyvsp[-1]);
- if (!(yyvsp[0])->empty())
- *(yyval) += " " + *(yyvsp[0]);
-;}
+ case 213:
+#line 2852 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.StrVal) = 0; ;}
break;
- case 165:
-#line 498 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 214:
+#line 2856 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += ", " + *(yyvsp[0]);
+ if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy)
+ error("void typed arguments are invalid");
+ (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
;}
break;
- case 166:
-#line 501 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 215:
+#line 2864 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = (yyvsp[0]);
+ (yyval.ArgList) = (yyvsp[-2].ArgList);
+ (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
+ delete (yyvsp[0].ArgVal);
;}
break;
- case 167:
-#line 505 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 216:
+#line 2869 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = (yyvsp[0]);
+ (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
+ (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
+ delete (yyvsp[0].ArgVal);
;}
break;
- case 168:
-#line 508 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- *(yyvsp[-2]) += ", ...";
- (yyval) = (yyvsp[-2]);
- ;}
+ case 217:
+#line 2877 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
break;
- case 169:
-#line 512 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 218:
+#line 2878 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = (yyvsp[0]);
+ (yyval.ArgList) = (yyvsp[-2].ArgList);
+ PATypeInfo VoidTI;
+ VoidTI.PAT = new PATypeHolder(Type::VoidTy);
+ VoidTI.S.makeSignless();
+ (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
;}
break;
- case 170:
-#line 515 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 219:
+#line 2885 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string();
+ (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
+ PATypeInfo VoidTI;
+ VoidTI.PAT = new PATypeHolder(Type::VoidTy);
+ VoidTI.S.makeSignless();
+ (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
;}
break;
- case 171:
-#line 520 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 220:
+#line 2892 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ArgList) = 0; ;}
+ break;
+
+ case 221:
+#line 2896 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- if (!(yyvsp[-7])->empty()) {
- (yyvsp[-6])->insert(0, *(yyvsp[-7]) + " ");
+ UnEscapeLexed((yyvsp[-5].StrVal));
+ std::string FunctionName((yyvsp[-5].StrVal));
+ free((yyvsp[-5].StrVal)); // Free strdup'd memory!
+
+ const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get();
+
+ if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+ error("LLVM functions cannot return aggregate types");
+
+ Signedness FTySign;
+ FTySign.makeComposite((yyvsp[-6].TypeVal).S);
+ std::vector<const Type*> ParamTyList;
+
+ // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
+ // i8*. We check here for those names and override the parameter list
+ // types to ensure the prototype is correct.
+ if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
+ ParamTyList.push_back(PointerType::get(Type::Int8Ty));
+ } else if (FunctionName == "llvm.va_copy") {
+ ParamTyList.push_back(PointerType::get(Type::Int8Ty));
+ ParamTyList.push_back(PointerType::get(Type::Int8Ty));
+ } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
+ for (std::vector<std::pair<PATypeInfo,char*> >::iterator
+ I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
+ const Type *Ty = I->first.PAT->get();
+ ParamTyList.push_back(Ty);
+ FTySign.add(I->first.S);
+ }
+ }
+
+ bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy;
+ if (isVarArg)
+ ParamTyList.pop_back();
+
+ // Convert the CSRet calling convention into the corresponding parameter
+ // attribute.
+ ParamAttrsList *ParamAttrs = 0;
+ if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
+ ParamAttrs = new ParamAttrsList();
+ ParamAttrs->addAttributes(0, ParamAttr::None); // result
+ ParamAttrs->addAttributes(1, ParamAttr::StructRet); // first arg
+ }
+
+ const FunctionType *FT =
+ FunctionType::get(RetTy, ParamTyList, isVarArg, ParamAttrs);
+ const PointerType *PFT = PointerType::get(FT);
+ delete (yyvsp[-6].TypeVal).PAT;
+
+ ValID ID;
+ if (!FunctionName.empty()) {
+ ID = ValID::create((char*)FunctionName.c_str());
+ } else {
+ ID = ValID::create((int)CurModule.Values[PFT].size());
+ }
+ ID.S.makeComposite(FTySign);
+
+ Function *Fn = 0;
+ Module* M = CurModule.CurrentModule;
+
+ // See if this function was forward referenced. If so, recycle the object.
+ if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
+ // Move the function to the end of the list, from whereever it was
+ // previously inserted.
+ Fn = cast<Function>(FWRef);
+ M->getFunctionList().remove(Fn);
+ M->getFunctionList().push_back(Fn);
+ } else if (!FunctionName.empty()) {
+ GlobalValue *Conflict = M->getFunction(FunctionName);
+ if (!Conflict)
+ Conflict = M->getNamedGlobal(FunctionName);
+ if (Conflict && PFT == Conflict->getType()) {
+ if (!CurFun.isDeclare && !Conflict->isDeclaration()) {
+ // We have two function definitions that conflict, same type, same
+ // name. We should really check to make sure that this is the result
+ // of integer type planes collapsing and generate an error if it is
+ // not, but we'll just rename on the assumption that it is. However,
+ // let's do it intelligently and rename the internal linkage one
+ // if there is one.
+ std::string NewName(makeNameUnique(FunctionName));
+ if (Conflict->hasInternalLinkage()) {
+ Conflict->setName(NewName);
+ RenameMapKey Key =
+ makeRenameMapKey(FunctionName, Conflict->getType(), ID.S);
+ CurModule.RenameMap[Key] = NewName;
+ Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
+ InsertValue(Fn, CurModule.Values);
+ } else {
+ Fn = new Function(FT, CurFun.Linkage, NewName, M);
+ InsertValue(Fn, CurModule.Values);
+ RenameMapKey Key =
+ makeRenameMapKey(FunctionName, PFT, ID.S);
+ CurModule.RenameMap[Key] = NewName;
+ }
+ } else {
+ // If they are not both definitions, then just use the function we
+ // found since the types are the same.
+ Fn = cast<Function>(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) {
+ // If we have declaration, always overwrite linkage. This will allow us
+ // to correctly handle cases, when pointer to function is passed as
+ // argument to another function.
+ Fn->setLinkage(CurFun.Linkage);
}
- *(yyvsp[-6]) += " " + *(yyvsp[-5]) + "( " + *(yyvsp[-3]) + " )";
- if (!(yyvsp[-1])->empty()) {
- *(yyvsp[-6]) += " " + *(yyvsp[-1]);
+ Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
+ Fn->setAlignment((yyvsp[0].UIntVal));
+ if ((yyvsp[-1].StrVal)) {
+ Fn->setSection((yyvsp[-1].StrVal));
+ free((yyvsp[-1].StrVal));
}
- if (!(yyvsp[0])->empty()) {
- *(yyvsp[-6]) += " " + *(yyvsp[0]);
+
+ // 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.PAT->get() == Type::VoidTy &&
+ (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
+ delete (yyvsp[-3].ArgList)->back().first.PAT;
+ (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
+ }
+ Function::arg_iterator ArgIt = Fn->arg_begin();
+ Function::arg_iterator ArgEnd = Fn->arg_end();
+ std::vector<std::pair<PATypeInfo,char*> >::iterator I = (yyvsp[-3].ArgList)->begin();
+ std::vector<std::pair<PATypeInfo,char*> >::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
}
- (yyval) = (yyvsp[-6]);
;}
break;
- case 172:
-#line 534 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 224:
+#line 3087 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { CurFun.Linkage = (yyvsp[0].Linkage); ;}
+ break;
+
+ case 225:
+#line 3087 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = new std::string("begin");
+ (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[-3].Linkage));
;}
break;
- case 173:
-#line 537 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- (yyval) = new std::string ("{");
+ case 228:
+#line 3101 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
;}
break;
- case 174:
-#line 541 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- if (!(yyvsp[-2])->empty()) {
- *O << *(yyvsp[-2]) << " ";
- }
- *O << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
-;}
+ case 229:
+#line 3106 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
break;
- case 175:
-#line 550 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string("end"); ;}
+ case 230:
+#line 3107 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
break;
- case 176:
-#line 551 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string("}"); ;}
+ case 231:
+#line 3108 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
break;
- case 177:
-#line 553 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- if ((yyvsp[-1]))
- *O << *(yyvsp[-1]);
- *O << '\n' << *(yyvsp[0]) << "\n";
-;}
+ case 232:
+#line 3112 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { CurFun.isDeclare = true; ;}
break;
- case 181:
-#line 565 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- *(yyvsp[-2]) += " " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
- ;}
+ case 233:
+#line 3113 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { CurFun.Linkage = (yyvsp[0].Linkage); ;}
break;
- case 182:
-#line 575 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 234:
+#line 3113 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ (yyval.FunctionVal) = CurFun.CurrentFunction;
+ CurFun.FunctionDone();
+
;}
break;
- case 183:
-#line 577 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
+ case 235:
+#line 3125 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = false; ;}
+ break;
+
+ case 236:
+#line 3126 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = true; ;}
+ break;
+
+ case 237:
+#line 3131 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
+ break;
+
+ case 238:
+#line 3132 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
+ break;
+
+ case 239:
+#line 3133 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
+ break;
+
+ case 240:
+#line 3134 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true));
+ (yyval.ValIDVal).S.makeUnsigned();
;}
break;
- case 192:
-#line 582 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 241:
+#line 3138 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyvsp[-1])->insert(0, "<");
- *(yyvsp[-1]) += ">";
- (yyval) = (yyvsp[-1]);
+ (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false));
+ (yyval.ValIDVal).S.makeUnsigned();
;}
break;
- case 194:
-#line 588 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- if (!(yyvsp[-3])->empty()) {
- *(yyvsp[-4]) += " " + *(yyvsp[-3]);
+ case 242:
+#line 3142 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::createNull(); ;}
+ break;
+
+ case 243:
+#line 3143 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::createUndef(); ;}
+ break;
+
+ case 244:
+#line 3144 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
+ break;
+
+ case 245:
+#line 3145 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Nonempty unsized packed vector
+ const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
+ int NumElements = (yyvsp[-1].ConstVector)->size();
+ 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<Constant*> Elems;
+ for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
+ Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
+ const Type *CTy = C->getType();
+ if (ETy != CTy)
+ error("Element #" + utostr(i) + " is not of type '" +
+ ETy->getDescription() +"' as required!\nIt is of type '" +
+ CTy->getDescription() + "'");
+ Elems.push_back(C);
}
- *(yyvsp[-4]) += " " + *(yyvsp[-2]) + ", " + *(yyvsp[-1]);
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]);
- (yyval) = (yyvsp[-4]);
+ (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems));
+ delete PTy; delete (yyvsp[-1].ConstVector);
;}
break;
- case 199:
-#line 606 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 246:
+#line 3166 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
+ (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S);
;}
break;
- case 200:
-#line 612 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 247:
+#line 3170 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
+ char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
+ std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
+ End = UnEscapeLexed((yyvsp[0].StrVal), true);
+ std::string Constraints = std::string((yyvsp[0].StrVal), End);
+ (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
+ free((yyvsp[-2].StrVal));
+ free((yyvsp[0].StrVal));
;}
break;
- case 201:
-#line 614 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 248:
+#line 3184 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;}
+ break;
+
+ case 249:
+#line 3185 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;}
+ break;
+
+ case 252:
+#line 3198 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ 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));
+ (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S);
+ delete (yyvsp[-1].TypeVal).PAT;
+ ;}
+ break;
+
+ case 253:
+#line 3208 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
+ ;}
+ break;
+
+ case 254:
+#line 3211 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Do not allow functions with 0 basic blocks
+ (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
;}
break;
- case 202:
-#line 621 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 255:
+#line 3220 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[-1]) ;
+ 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 203:
-#line 625 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 256:
+#line 3231 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ if ((yyvsp[0].InstVal).I)
+ (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
+ (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
;}
break;
- case 204:
-#line 630 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 257:
+#line 3236 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- (yyval) = 0;
+ (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.
+ Function::BasicBlockListType &BBL =
+ CurFun.CurrentFunction->getBasicBlockList();
+ BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
;}
break;
- case 205:
-#line 633 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 258:
+#line 3245 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
+ // Make sure to move the basic block to the correct location in the
+ // function, instead of leaving it inserted wherever it was first
+ // referenced.
+ Function::BasicBlockListType &BBL =
+ CurFun.CurrentFunction->getBasicBlockList();
+ BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
;}
break;
- case 206:
-#line 639 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 261:
+#line 3259 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Return with a result...
- *O << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V);
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 207:
-#line 644 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 262:
+#line 3263 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Return with no result...
- *O << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.TermInstVal).TI = new ReturnInst();
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 208:
-#line 649 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 263:
+#line 3267 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Unconditional Branch...
- *O << " " << *(yyvsp[-2]) << " " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
+ (yyval.TermInstVal).TI = new BranchInst(tmpBB);
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 209:
-#line 654 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 264:
+#line 3272 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[-8]) << " " << *(yyvsp[-7]) << " " << *(yyvsp[-6]) << ", " << *(yyvsp[-4]) << " "
- << *(yyvsp[-3]) << ", " << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-8]); delete (yyvsp[-7]); delete (yyvsp[-6]); delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ (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).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal);
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 210:
-#line 660 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 265:
+#line 3282 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[-8]) << " " << *(yyvsp[-7]) << " " << *(yyvsp[-6]) << ", " << *(yyvsp[-4]) << " "
- << *(yyvsp[-3]) << " [" << *(yyvsp[-1]) << " ]\n";
- delete (yyvsp[-8]); delete (yyvsp[-7]); delete (yyvsp[-6]); delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-1]);
- (yyval) = 0;
+ (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).TI = S;
+ (yyval.TermInstVal).S.makeSignless();
+ std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
+ E = (yyvsp[-1].JumpTable)->end();
+ for (; I != E; ++I) {
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
+ S->addCase(CI, I->second);
+ else
+ error("Switch case is constant, but not a simple integer");
+ }
+ delete (yyvsp[-1].JumpTable);
;}
break;
- case 211:
-#line 666 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 266:
+#line 3300 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[-7]) << " " << *(yyvsp[-6]) << " " << *(yyvsp[-5]) << ", " << *(yyvsp[-3]) << " "
- << *(yyvsp[-2]) << "[]\n";
- delete (yyvsp[-7]); delete (yyvsp[-6]); delete (yyvsp[-5]); delete (yyvsp[-3]); delete (yyvsp[-2]);
- (yyval) = 0;
+ (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).TI = S;
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 212:
-#line 673 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 267:
+#line 3310 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[-12]) << " " << *(yyvsp[-11]) << " " << *(yyvsp[-10]) << " " << *(yyvsp[-9]) << " ("
- << *(yyvsp[-7]) << ") " << *(yyvsp[-5]) << " " << *(yyvsp[-4]) << " " << *(yyvsp[-3]) << " " << *(yyvsp[-2]) << " "
- << *(yyvsp[-1]) << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[-12]); delete (yyvsp[-11]); delete (yyvsp[-10]); delete (yyvsp[-9]); delete (yyvsp[-7]); delete (yyvsp[-5]); delete (yyvsp[-4]);
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = 0;
+ const PointerType *PFTy;
+ const FunctionType *Ty;
+ Signedness FTySign;
+
+ if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).PAT->get())) ||
+ !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+ // Pull out the types of all of the arguments...
+ std::vector<const Type*> ParamTypes;
+ FTySign.makeComposite((yyvsp[-10].TypeVal).S);
+ if ((yyvsp[-7].ValueList)) {
+ for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
+ I != E; ++I) {
+ ParamTypes.push_back((*I).V->getType());
+ FTySign.add(I->S);
+ }
+ }
+ ParamAttrsList *ParamAttrs = 0;
+ if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
+ ParamAttrs = new ParamAttrsList();
+ ParamAttrs->addAttributes(0, ParamAttr::None); // Function result
+ ParamAttrs->addAttributes(1, ParamAttr::StructRet); // first param
+ }
+ bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+ if (isVarArg) ParamTypes.pop_back();
+ Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, ParamAttrs);
+ 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).TI = new InvokeInst(V, Normal, Except, 0, 0);
+ } else { // Has arguments?
+ // Loop through FunctionType's arguments and ensure they are specified
+ // correctly!
+ //
+ FunctionType::param_iterator I = Ty->param_begin();
+ FunctionType::param_iterator E = Ty->param_end();
+ std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
+
+ std::vector<Value*> Args;
+ for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
+ if ((*ArgI).V->getType() != *I)
+ error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+ (*I)->getDescription() + "'");
+ Args.push_back((*ArgI).V);
+ }
+
+ if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
+ error("Invalid number of parameters detected");
+
+ (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
+ }
+ cast<InvokeInst>((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
+ delete (yyvsp[-10].TypeVal).PAT;
+ delete (yyvsp[-7].ValueList);
;}
break;
- case 213:
-#line 681 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 268:
+#line 3379 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.TermInstVal).TI = new UnwindInst();
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 214:
-#line 686 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 269:
+#line 3383 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *O << " " << *(yyvsp[0]) << "\n";
- delete (yyvsp[0]);
- (yyval) = 0;
+ (yyval.TermInstVal).TI = new UnreachableInst();
+ (yyval.TermInstVal).S.makeSignless();
;}
break;
- case 215:
-#line 692 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 270:
+#line 3390 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += *(yyvsp[-4]) + " " + *(yyvsp[-3]) + ", " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ (yyval.JumpTable) = (yyvsp[-5].JumpTable);
+ (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
+ Constant *V = cast<Constant>(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 216:
-#line 697 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 271:
+#line 3402 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-4]) += *(yyvsp[-3]) + ", " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-3]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-4]);
+ (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
+ (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
+ Constant *V = cast<Constant>(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 217:
-#line 704 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 272:
+#line 3417 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ bool omit = false;
+ if ((yyvsp[-1].StrVal))
+ if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
+ if (BCI->getSrcTy() == BCI->getDestTy() &&
+ BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
+ // This is a useless bit cast causing a name redefinition. It is
+ // a bit cast from a type to the same type of an operand with the
+ // same name as the name we would give this instruction. Since this
+ // instruction results in no code generation, it is safe to omit
+ // the instruction. This situation can occur because of collapsed
+ // type planes. For example:
+ // %X = add int %Y, %Z
+ // %X = cast int %Y to uint
+ // After upgrade, this looks like:
+ // %X = add i32 %Y, %Z
+ // %X = bitcast i32 to i32
+ // The bitcast is clearly useless so we omit it.
+ omit = true;
+ if (omit) {
+ (yyval.InstVal).I = 0;
+ (yyval.InstVal).S.makeSignless();
+ } else {
+ 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 218:
-#line 711 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 273:
+#line 3447 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{ // Used for PHI nodes
- *(yyvsp[-5]) += " [" + *(yyvsp[-3]) + "," + *(yyvsp[-1]) + "]";
- delete (yyvsp[-3]); delete (yyvsp[-1]);
- (yyval) = (yyvsp[-5]);
+ (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
+ (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).PAT;
;}
break;
- case 219:
-#line 716 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 274:
+#line 3457 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-6]) += ", [" + *(yyvsp[-3]) + "," + *(yyvsp[-1]) + "]";
- delete (yyvsp[-3]); delete (yyvsp[-1]);
- (yyval) = (yyvsp[-6]);
+ (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 221:
-#line 725 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 275:
+#line 3467 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { // Used for call statements, and memory insts...
+ (yyval.ValueList) = new std::vector<ValueInfo>();
+ (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
+ ;}
+ break;
+
+ case 276:
+#line 3471 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += ", " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ (yyval.ValueList) = (yyvsp[-2].ValueList);
+ (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
;}
break;
- case 223:
-#line 734 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 278:
+#line 3479 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValueList) = 0; ;}
break;
- case 224:
-#line 738 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 279:
+#line 3483 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (yyval.BoolVal) = true;
;}
break;
- case 226:
-#line 746 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 280:
+#line 3486 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-4]) += " " + *(yyvsp[-3]) + " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-4]);
+ (yyval.BoolVal) = false;
;}
break;
- case 227:
-#line 751 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 281:
+#line 3492 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-4]) += " " + *(yyvsp[-3]) + " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-4]);
+ (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<VectorType>(Ty))
+ error("Arithmetic operator requires integer, FP, or packed operands");
+ if (isa<VectorType>(Ty) &&
+ ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
+ 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));
+ Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
+ (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
+ if ((yyval.InstVal).I == 0)
+ error("binary operator returned null");
+ (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
+ delete (yyvsp[-3].TypeVal).PAT;
;}
break;
- case 228:
-#line 756 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 282:
+#line 3511 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-4]) += " " + *(yyvsp[-3]) + " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-3]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-4]);
+ (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<VectorType>(Ty) ||
+ !cast<VectorType>(Ty)->getElementType()->isInteger())
+ error("Logical operator requires integral operands");
+ }
+ Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
+ Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
+ Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+ (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
+ if ((yyval.InstVal).I == 0)
+ error("binary operator returned null");
+ (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
+ delete (yyvsp[-3].TypeVal).PAT;
;}
break;
- case 229:
-#line 761 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 283:
+#line 3529 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ (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<VectorType>(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));
+ Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
+ (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
+ if ((yyval.InstVal).I == 0)
+ error("binary operator returned null");
+ (yyval.InstVal).S.makeUnsigned();
+ delete (yyvsp[-3].TypeVal).PAT;
;}
break;
- case 230:
-#line 766 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 284:
+#line 3545 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ (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<VectorType>(Ty))
+ error("VectorTypes currently not supported in icmp instructions");
+ else if (!Ty->isInteger() && !isa<PointerType>(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.makeUnsigned();
+ delete (yyvsp[-3].TypeVal).PAT;
;}
break;
- case 231:
-#line 771 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 285:
+#line 3559 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += " " + *(yyvsp[-2]) + " " + *(yyvsp[-1]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ (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<VectorType>(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.makeUnsigned();
+ delete (yyvsp[-3].TypeVal).PAT;
;}
break;
- case 232:
-#line 776 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 286:
+#line 3573 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " " + *(yyvsp[-4]) + ", " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ warning("Use of obsolete 'not' instruction: Replacing with 'xor");
+ const Type *Ty = (yyvsp[0].ValueVal).V->getType();
+ Value *Ones = ConstantInt::getAllOnesValue(Ty);
+ if (Ones == 0)
+ error("Expected integral type for not instruction");
+ (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.copy((yyvsp[0].ValueVal).S);
;}
break;
- case 233:
-#line 781 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 287:
+#line 3584 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
+ cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
+ error("Shift amount must be int8");
+ const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
+ if (!Ty->isInteger())
+ error("Shift constant expression requires integer operand");
+ Value* ShiftAmt = 0;
+ if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
+ if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
+ ShiftAmt = ConstantExpr::getZExt(C, Ty);
+ else
+ ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
+ 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.copy((yyvsp[-2].ValueVal).S);
;}
break;
- case 234:
-#line 786 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 288:
+#line 3602 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += " " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ 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<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
+ (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
+ delete (yyvsp[0].TypeVal).PAT;
;}
break;
- case 235:
-#line 791 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 289:
+#line 3611 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " " + *(yyvsp[-4]) + ", " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
+ cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
+ error("select condition must be bool");
+ 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.copy((yyvsp[-2].ValueVal).S);
;}
break;
- case 236:
-#line 796 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 290:
+#line 3620 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " " + *(yyvsp[-4]) + ", " + *(yyvsp[-2]) + ", " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-2]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
+ NewVarArgs = true;
+ (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
+ (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
+ delete (yyvsp[0].TypeVal).PAT;
;}
break;
- case 237:
-#line 801 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 291:
+#line 3627 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
+ const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
+ ObsoleteVarArgs = true;
+ Function* NF = cast<Function>(CurModule.CurrentModule->
+ getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+ //b = vaarg a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //b = vaarg foo, t
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+ CurBB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
+ CurBB->getInstList().push_back(bar);
+ CurBB->getInstList().push_back(new StoreInst(bar, foo));
+ (yyval.InstVal).I = new VAArgInst(foo, DstTy);
+ (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
+ delete (yyvsp[0].TypeVal).PAT;
;}
break;
- case 238:
-#line 806 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 292:
+#line 3648 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- if (!(yyvsp[-5])->empty())
- *(yyvsp[-6]) += " " + *(yyvsp[-5]);
- if (!(yyvsp[-6])->empty())
- *(yyvsp[-6]) += " ";
- *(yyvsp[-6]) += *(yyvsp[-4]) += " " + *(yyvsp[-3]) + "(" + *(yyvsp[-2]) + ")";
- delete (yyvsp[-5]); delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-1]);
- (yyval) = (yyvsp[-6]);
+ const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
+ const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
+ ObsoleteVarArgs = true;
+ Function* NF = cast<Function>(CurModule.CurrentModule->
+ getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
+
+ //b = vanext a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //tmp = vaarg foo, t
+ //b = load foo
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+ CurBB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
+ CurBB->getInstList().push_back(bar);
+ CurBB->getInstList().push_back(new StoreInst(bar, foo));
+ Instruction* tmp = new VAArgInst(foo, DstTy);
+ CurBB->getInstList().push_back(tmp);
+ (yyval.InstVal).I = new LoadInst(foo);
+ (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
+ delete (yyvsp[0].TypeVal).PAT;
;}
break;
- case 240:
-#line 820 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- {
- (yyvsp[0])->insert(0, ", ");
- (yyval) = (yyvsp[0]);
+ case 293:
+#line 3672 "/proj/llvm/llvm-2/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.copy((yyvsp[-2].ValueVal).S.get(0));
;}
break;
- case 241:
-#line 824 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 294:
+#line 3678 "/proj/llvm/llvm-2/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.copy((yyvsp[-4].ValueVal).S);
+ ;}
break;
- case 243:
-#line 829 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
- { (yyval) = new std::string(); ;}
+ case 295:
+#line 3684 "/proj/llvm/llvm-2/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.copy((yyvsp[-4].ValueVal).S);
+ ;}
break;
- case 244:
-#line 832 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 296:
+#line 3690 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " " + *(yyvsp[-1]);
- if (!(yyvsp[0])->empty())
- *(yyvsp[-2]) += " " + *(yyvsp[0]);
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
+ if (!Ty->isFirstClassType())
+ error("PHI node operands must be of first class type");
+ PHINode *PHI = new PHINode(Ty);
+ PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
+ while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
+ if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
+ error("All elements of a PHI node must be of the same type");
+ PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
+ (yyvsp[0].PHIList).P->pop_front();
+ }
+ (yyval.InstVal).I = PHI;
+ (yyval.InstVal).S.copy((yyvsp[0].PHIList).S);
+ delete (yyvsp[0].PHIList).P; // Free the list...
;}
break;
- case 245:
-#line 839 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 297:
+#line 3706 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " " + *(yyvsp[-4]) + ", " + *(yyvsp[-2]) + " " + *(yyvsp[-1]);
- if (!(yyvsp[0])->empty())
- *(yyvsp[-5]) += " " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ // Handle the short call syntax
+ const PointerType *PFTy;
+ const FunctionType *FTy;
+ Signedness FTySign;
+ if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).PAT->get())) ||
+ !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
+ // Pull out the types of all of the arguments...
+ std::vector<const Type*> ParamTypes;
+ FTySign.makeComposite((yyvsp[-4].TypeVal).S);
+ if ((yyvsp[-1].ValueList)) {
+ for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
+ I != E; ++I) {
+ ParamTypes.push_back((*I).V->getType());
+ FTySign.add(I->S);
+ }
+ }
+
+ bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
+ if (isVarArg) ParamTypes.pop_back();
+
+ const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get();
+ if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
+ error("Functions cannot return aggregate types");
+
+ // Deal with CSRetCC
+ ParamAttrsList *ParamAttrs = 0;
+ if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
+ ParamAttrs = new ParamAttrsList();
+ ParamAttrs->addAttributes(0, ParamAttr::None); // function result
+ ParamAttrs->addAttributes(1, ParamAttr::StructRet); // first parameter
+ }
+
+ FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
+ 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<Value*> 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->getReturnType(), (yyvsp[-3].ValIDVal), Args);
+
+ // If we got an upgraded intrinsic
+ if (Inst) {
+ (yyval.InstVal).I = Inst;
+ } else {
+ // Get the function we're calling
+ Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
+
+ // Check the argument values match
+ if (!(yyvsp[-1].ValueList)) { // Has no arguments?
+ // Make sure no arguments is a good thing!
+ if (FTy->getNumParams() != 0)
+ error("No arguments passed to a function that expects arguments");
+ } else { // Has arguments?
+ // Loop through FunctionType's arguments and ensure they are specified
+ // correctly!
+ //
+ FunctionType::param_iterator I = FTy->param_begin();
+ FunctionType::param_iterator E = FTy->param_end();
+ std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
+
+ for (; ArgI != ArgE && I != E; ++ArgI, ++I)
+ if ((*ArgI).V->getType() != *I)
+ error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
+ (*I)->getDescription() + "'");
+
+ if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
+ error("Invalid number of parameters detected");
+ }
+
+ // Create the call instruction
+ CallInst *CI = new CallInst(V, &Args[0], Args.size());
+ CI->setTailCall((yyvsp[-6].BoolVal));
+ CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
+ (yyval.InstVal).I = CI;
+ }
+ delete (yyvsp[-4].TypeVal).PAT;
+ delete (yyvsp[-1].ValueList);
;}
break;
- case 246:
-#line 846 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 298:
+#line 3796 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-2]) += " " + *(yyvsp[-1]);
- if (!(yyvsp[0])->empty())
- *(yyvsp[-2]) += " " + *(yyvsp[0]);
- delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-2]);
+ (yyval.InstVal) = (yyvsp[0].InstVal);
;}
break;
- case 247:
-#line 853 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 299:
+#line 3804 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
+ break;
+
+ case 300:
+#line 3805 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
+ break;
+
+ case 301:
+#line 3809 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = true; ;}
+ break;
+
+ case 302:
+#line 3810 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ { (yyval.BoolVal) = false; ;}
+ break;
+
+ case 303:
+#line 3814 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-5]) += " " + *(yyvsp[-4]) + ", " + *(yyvsp[-2]) + " " + *(yyvsp[-1]);
- if (!(yyvsp[0])->empty())
- *(yyvsp[-5]) += " " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ 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).PAT;
;}
break;
- case 248:
-#line 860 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 304:
+#line 3820 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-1]) += " " + *(yyvsp[0]);
- delete (yyvsp[0]);
- (yyval) = (yyvsp[-1]);
+ 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).PAT;
;}
break;
- case 249:
-#line 865 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 305:
+#line 3827 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ 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).PAT;
+ ;}
+ break;
+
+ case 306:
+#line 3833 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ 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).PAT;
+ ;}
+ break;
+
+ case 307:
+#line 3840 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
+ {
+ const Type *PTy = (yyvsp[0].ValueVal).V->getType();
+ if (!isa<PointerType>(PTy))
+ error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
+ (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
+ (yyval.InstVal).S.makeSignless();
+ ;}
+ break;
+
+ case 308:
+#line 3847 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- if (!(yyvsp[-3])->empty())
- *(yyvsp[-3]) += " ";
- *(yyvsp[-3]) += *(yyvsp[-2]) + " " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ const Type* Ty = (yyvsp[-1].TypeVal).PAT->get();
+ (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
+ if (!isa<PointerType>(Ty))
+ error("Can't load from nonpointer type: " + Ty->getDescription());
+ if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
+ error("Can't load from pointer of non-first-class type: " +
+ Ty->getDescription());
+ Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
+ (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
+ (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0));
+ delete (yyvsp[-1].TypeVal).PAT;
;}
break;
- case 250:
-#line 872 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 309:
+#line 3860 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- if (!(yyvsp[-5])->empty())
- *(yyvsp[-5]) += " ";
- *(yyvsp[-5]) += *(yyvsp[-4]) + " " + *(yyvsp[-3]) + ", " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-4]); delete (yyvsp[-3]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-5]);
+ (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
+ const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
+ if (!PTy)
+ error("Can't store to a nonpointer type: " +
+ (yyvsp[-1].TypeVal).PAT->get()->getDescription());
+ const Type *ElTy = PTy->getElementType();
+ Value *StoreVal = (yyvsp[-3].ValueVal).V;
+ Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
+ 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<Constant>(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 251:
-#line 879 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+ case 310:
+#line 3886 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
{
- *(yyvsp[-3]) += *(yyvsp[-2]) + " " + *(yyvsp[-1]) + " " + *(yyvsp[0]);
- delete (yyvsp[-2]); delete (yyvsp[-1]); delete (yyvsp[0]);
- (yyval) = (yyvsp[-3]);
+ (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S);
+ const Type* Ty = (yyvsp[-2].TypeVal).PAT->get();
+ if (!isa<PointerType>(Ty))
+ error("getelementptr insn requires pointer operand");
+
+ std::vector<Value*> VIndices;
+ upgradeGEPInstIndices(Ty, (yyvsp[0].ValueList), VIndices);
+
+ Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
+ (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;
}
/* Line 1126 of yacc.c. */
-#line 3202 "UpgradeParser.tab.c"
+#line 6622 "UpgradeParser.tab.c"
\f
yyvsp -= yylen;
yyssp -= yylen;
}
-#line 885 "/proj/llvm/llvm-4/tools/llvm-upgrade/UpgradeParser.y"
+#line 3904 "/proj/llvm/llvm-2/tools/llvm-upgrade/UpgradeParser.y"
int yyerror(const char *ErrorMsg) {
std::string where
= std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
+ ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
- std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
- if (yychar == YYEMPTY || yychar == 0)
- errMsg += "end-of-file.";
- else
- errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
- std::cerr << errMsg << '\n';
+ std::string errMsg = where + "error: " + std::string(ErrorMsg);
+ if (yychar != YYEMPTY && yychar != 0)
+ errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
+ "'.";
+ std::cerr << "llvm-upgrade: " << errMsg << '\n';
+ std::cout << "llvm-upgrade: parse failed.\n";
exit(1);
}
+void warning(const std::string& ErrorMsg) {
+ std::string where
+ = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
+ + ":" + 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) +
+ "'.";
+ std::cerr << "llvm-upgrade: " << errMsg << '\n';
+}
+
+void error(const std::string& ErrorMsg, int LineNo) {
+ if (LineNo == -1) LineNo = Upgradelineno;
+ Upgradelineno = LineNo;
+ yyerror(ErrorMsg.c_str());
+}
+
+
projects / oota-llvm.git / blobdiff