diff options
Diffstat (limited to 'lib/AsmParser/llvmAsmParser.cpp.cvs')
| -rw-r--r-- | lib/AsmParser/llvmAsmParser.cpp.cvs | 5290 |
1 files changed, 5290 insertions, 0 deletions
diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs new file mode 100644 index 0000000..2396252 --- /dev/null +++ b/lib/AsmParser/llvmAsmParser.cpp.cvs @@ -0,0 +1,5290 @@ + +/* A Bison parser, made from /Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define yyparse llvmAsmparse +#define yylex llvmAsmlex +#define yyerror llvmAsmerror +#define yylval llvmAsmlval +#define yychar llvmAsmchar +#define yydebug llvmAsmdebug +#define yynerrs llvmAsmnerrs +#define ESINT64VAL 257 +#define EUINT64VAL 258 +#define ESAPINTVAL 259 +#define EUAPINTVAL 260 +#define LOCALVAL_ID 261 +#define GLOBALVAL_ID 262 +#define FPVAL 263 +#define VOID 264 +#define INTTYPE 265 +#define FLOAT 266 +#define DOUBLE 267 +#define LABEL 268 +#define TYPE 269 +#define LOCALVAR 270 +#define GLOBALVAR 271 +#define LABELSTR 272 +#define STRINGCONSTANT 273 +#define ATSTRINGCONSTANT 274 +#define PCTSTRINGCONSTANT 275 +#define ZEROINITIALIZER 276 +#define TRUETOK 277 +#define FALSETOK 278 +#define BEGINTOK 279 +#define ENDTOK 280 +#define DECLARE 281 +#define DEFINE 282 +#define GLOBAL 283 +#define CONSTANT 284 +#define SECTION 285 +#define ALIAS 286 +#define VOLATILE 287 +#define THREAD_LOCAL 288 +#define TO 289 +#define DOTDOTDOT 290 +#define NULL_TOK 291 +#define UNDEF 292 +#define INTERNAL 293 +#define LINKONCE 294 +#define WEAK 295 +#define APPENDING 296 +#define DLLIMPORT 297 +#define DLLEXPORT 298 +#define EXTERN_WEAK 299 +#define OPAQUE 300 +#define EXTERNAL 301 +#define TARGET 302 +#define TRIPLE 303 +#define ALIGN 304 +#define DEPLIBS 305 +#define CALL 306 +#define TAIL 307 +#define ASM_TOK 308 +#define MODULE 309 +#define SIDEEFFECT 310 +#define CC_TOK 311 +#define CCC_TOK 312 +#define FASTCC_TOK 313 +#define COLDCC_TOK 314 +#define X86_STDCALLCC_TOK 315 +#define X86_FASTCALLCC_TOK 316 +#define DATALAYOUT 317 +#define RET 318 +#define BR 319 +#define SWITCH 320 +#define INVOKE 321 +#define UNWIND 322 +#define UNREACHABLE 323 +#define ADD 324 +#define SUB 325 +#define MUL 326 +#define UDIV 327 +#define SDIV 328 +#define FDIV 329 +#define UREM 330 +#define SREM 331 +#define FREM 332 +#define AND 333 +#define OR 334 +#define XOR 335 +#define SHL 336 +#define LSHR 337 +#define ASHR 338 +#define ICMP 339 +#define FCMP 340 +#define EQ 341 +#define NE 342 +#define SLT 343 +#define SGT 344 +#define SLE 345 +#define SGE 346 +#define ULT 347 +#define UGT 348 +#define ULE 349 +#define UGE 350 +#define OEQ 351 +#define ONE 352 +#define OLT 353 +#define OGT 354 +#define OLE 355 +#define OGE 356 +#define ORD 357 +#define UNO 358 +#define UEQ 359 +#define UNE 360 +#define MALLOC 361 +#define ALLOCA 362 +#define FREE 363 +#define LOAD 364 +#define STORE 365 +#define GETELEMENTPTR 366 +#define TRUNC 367 +#define ZEXT 368 +#define SEXT 369 +#define FPTRUNC 370 +#define FPEXT 371 +#define BITCAST 372 +#define UITOFP 373 +#define SITOFP 374 +#define FPTOUI 375 +#define FPTOSI 376 +#define INTTOPTR 377 +#define PTRTOINT 378 +#define PHI_TOK 379 +#define SELECT 380 +#define VAARG 381 +#define EXTRACTELEMENT 382 +#define INSERTELEMENT 383 +#define SHUFFLEVECTOR 384 +#define NORETURN 385 +#define INREG 386 +#define SRET 387 +#define NOUNWIND 388 +#define NOALIAS 389 +#define DEFAULT 390 +#define HIDDEN 391 +#define PROTECTED 392 + +#line 14 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" + +#include "ParserInternals.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/ValueSymbolTable.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Streams.h" +#include <algorithm> +#include <list> +#include <map> +#include <utility> +#ifndef NDEBUG +#define YYDEBUG 1 +#endif + +// The following is a gross hack. In order to rid the libAsmParser library of +// exceptions, we have to have a way of getting the yyparse function to go into +// an error situation. So, whenever we want an error to occur, the GenerateError +// function (see bottom of file) sets TriggerError. Then, at the end of each +// production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR +// (a goto) to put YACC in error state. Furthermore, several calls to +// GenerateError are made from inside productions and they must simulate the +// previous exception behavior by exiting the production immediately. We have +// replaced these with the GEN_ERROR macro which calls GeneratError and then +// immediately invokes YYERROR. This would be so much cleaner if it was a +// recursive descent parser. +static bool TriggerError = false; +#define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } } +#define GEN_ERROR(msg) { GenerateError(msg); YYERROR; } + +int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit +int yylex(); // declaration" of xxx warnings. +int yyparse(); + +namespace llvm { + std::string CurFilename; +#if YYDEBUG +static cl::opt<bool> +Debug("debug-yacc", cl::desc("Print yacc debug state changes"), + cl::Hidden, cl::init(false)); +#endif +} +using namespace llvm; + +static Module *ParserResult; + +// 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) cerr << X +#else +#define UR_OUT(X) +#endif + +#define YYERROR_VERBOSE 1 + +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 + +static void +ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0); + +static struct PerModuleInfo { + Module *CurrentModule; + ValueList Values; // Module level numbered definitions + ValueList LateResolveValues; + std::vector<PATypeHolder> Types; + std::map<ValID, PATypeHolder> LateResolveTypes; + + /// PlaceHolderInfo - When temporary placeholder objects are created, remember + /// how they were referenced and on which line of the input they came from so + /// that we can resolve them later and print error messages as appropriate. + std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo; + + // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward + // references to global values. Global values may be referenced before they + // are defined, and if so, the temporary object that they represent is held + // here. This is used for forward references of GlobalValues. + // + typedef std::map<std::pair<const PointerType *, + ValID>, GlobalValue*> GlobalRefsType; + GlobalRefsType GlobalRefs; + + 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); + if (TriggerError) + return; + + // Check to make sure that all global value forward references have been + // resolved! + // + if (!GlobalRefs.empty()) { + std::string UndefinedReferences = "Unresolved global references exist:\n"; + + for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end(); + I != E; ++I) { + UndefinedReferences += " " + I->first.first->getDescription() + " " + + I->first.second.getName() + "\n"; + } + GenerateError(UndefinedReferences); + return; + } + + Values.clear(); // Clear out function local definitions + Types.clear(); + CurrentModule = 0; + } + + // GetForwardRefForGlobal - Check to see if there is a forward reference + // for this global. If so, remove it from the GlobalRefs map and return it. + // If not, just return null. + GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) { + // Check to see if there is a forward reference to this global variable... + // if there is, eliminate it and patch the reference to use the new def'n. + GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID)); + GlobalValue *Ret = 0; + if (I != GlobalRefs.end()) { + Ret = I->second; + GlobalRefs.erase(I); + } + return Ret; + } + + bool TypeIsUnresolved(PATypeHolder* PATy) { + // If it isn't abstract, its resolved + const Type* Ty = PATy->get(); + if (!Ty->isAbstract()) + return false; + // Traverse the type looking for abstract types. If it isn't abstract then + // we don't need to traverse that leg of the type. + std::vector<const Type*> WorkList, SeenList; + WorkList.push_back(Ty); + while (!WorkList.empty()) { + const Type* Ty = WorkList.back(); + SeenList.push_back(Ty); + WorkList.pop_back(); + if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) { + // Check to see if this is an unresolved type + std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin(); + std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end(); + for ( ; I != E; ++I) { + if (I->second.get() == OpTy) + return true; + } + } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) { + const Type* TheTy = SeqTy->getElementType(); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector<const Type*>::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) { + for (unsigned i = 0; i < StrTy->getNumElements(); ++i) { + const Type* TheTy = StrTy->getElementType(i); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector<const Type*>::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } + } + } + return false; + } +} CurModule; + +static struct PerFunctionInfo { + Function *CurrentFunction; // Pointer to current function being created + + ValueList Values; // Keep track of #'d definitions + unsigned NextValNum; + ValueList LateResolveValues; + bool isDeclare; // Is this function a forward declararation? + GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration. + GlobalValue::VisibilityTypes Visibility; + + /// BBForwardRefs - When we see forward references to basic blocks, keep + /// track of them here. + std::map<ValID, BasicBlock*> BBForwardRefs; + + inline PerFunctionInfo() { + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; + } + + inline void FunctionStart(Function *M) { + CurrentFunction = M; + NextValNum = 0; + } + + void FunctionDone() { + // Any forward referenced blocks left? + if (!BBForwardRefs.empty()) { + GenerateError("Undefined reference to label " + + BBForwardRefs.begin()->second->getName()); + return; + } + + // Resolve all forward references now. + ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); + + Values.clear(); // Clear out function local definitions + BBForwardRefs.clear(); + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; + } +} CurFun; // Info for the current function... + +static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } + + +//===----------------------------------------------------------------------===// +// Code to handle definitions of all the types +//===----------------------------------------------------------------------===// + +static void InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) { + // Things that have names or are void typed don't get slot numbers + if (V->hasName() || (V->getType() == Type::VoidTy)) + return; + + // In the case of function values, we have to allow for the forward reference + // of basic blocks, which are included in the numbering. Consequently, we keep + // track of the next insertion location with NextValNum. When a BB gets + // inserted, it could change the size of the CurFun.Values vector. + if (&ValueTab == &CurFun.Values) { + if (ValueTab.size() <= CurFun.NextValNum) + ValueTab.resize(CurFun.NextValNum+1); + ValueTab[CurFun.NextValNum++] = V; + return; + } + // For all other lists, its okay to just tack it on the back of the vector. + ValueTab.push_back(V); +} + +static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { + switch (D.Type) { + case ValID::LocalID: // Is it a numbered definition? + // Module constants occupy the lowest numbered slots... + if (D.Num < CurModule.Types.size()) + return CurModule.Types[D.Num]; + break; + case ValID::LocalName: // Is it a named definition? + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) { + D.destroy(); // Free old strdup'd memory... + return N; + } + break; + default: + GenerateError("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::LocalName) { + GenerateError("Reference to an undefined type: '" + D.getName() + "'"); + return 0; + } else { + GenerateError("Reference to an undefined type: #" + utostr(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; + } + +// getExistingVal - 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 *getExistingVal(const Type *Ty, const ValID &D) { + if (isa<FunctionType>(Ty)) { + GenerateError("Functions are not values and " + "must be referenced as pointers"); + return 0; + } + + switch (D.Type) { + case ValID::LocalID: { // Is it a numbered definition? + // Check that the number is within bounds. + if (D.Num >= CurFun.Values.size()) + return 0; + Value *Result = CurFun.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); + return 0; + } + return Result; + } + case ValID::GlobalID: { // Is it a numbered definition? + if (D.Num >= CurModule.Values.size()) + return 0; + Value *Result = CurModule.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); + return 0; + } + return Result; + } + + case ValID::LocalName: { // Is it a named definition? + if (!inFunctionScope()) + return 0; + ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); + Value *N = SymTab.lookup(D.getName()); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; + + D.destroy(); // Free old strdup'd memory... + return N; + } + case ValID::GlobalName: { // Is it a named definition? + ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable(); + Value *N = SymTab.lookup(D.getName()); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; + + D.destroy(); // Free old strdup'd memory... + return N; + } + + // Check to make sure that "Ty" is an integral type, and that our + // value will fit into the specified type... + case ValID::ConstSIntVal: // Is it a constant pool reference?? + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Signed integral constant '" + + itostr(D.ConstPool64) + "' is invalid for type '" + + Ty->getDescription() + "'"); + return 0; + } + return ConstantInt::get(Ty, D.ConstPool64, true); + + case ValID::ConstUIntVal: // Is it an unsigned const pool reference? + if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) { + if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Integral constant '" + utostr(D.UConstPool64) + + "' is invalid or out of range"); + return 0; + } else { // This is really a signed reference. Transmogrify. + return ConstantInt::get(Ty, D.ConstPool64, true); + } + } else { + return ConstantInt::get(Ty, D.UConstPool64); + } + + case ValID::ConstFPVal: // Is it a floating point const pool reference? + if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) { + GenerateError("FP constant invalid for type"); + return 0; + } + return ConstantFP::get(Ty, D.ConstPoolFP); + + case ValID::ConstNullVal: // Is it a null value? + if (!isa<PointerType>(Ty)) { + GenerateError("Cannot create a a non pointer null"); + return 0; + } + return ConstantPointerNull::get(cast<PointerType>(Ty)); + + case ValID::ConstUndefVal: // Is it an undef value? + return UndefValue::get(Ty); + + case ValID::ConstZeroVal: // Is it a zero value? + return Constant::getNullValue(Ty); + + case ValID::ConstantVal: // Fully resolved constant? + if (D.ConstantValue->getType() != Ty) { + GenerateError("Constant expression type different from required type"); + return 0; + } + return D.ConstantValue; + + case ValID::InlineAsmVal: { // Inline asm expression + const PointerType *PTy = dyn_cast<PointerType>(Ty); + const FunctionType *FTy = + PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; + if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) { + GenerateError("Invalid type for asm constraint string"); + return 0; + } + 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 getExistingVal, except that if a +// value is not already defined, it "improvises" by creating a placeholder var +// that looks and acts just like the requested variable. When the value is +// defined later, all uses of the placeholder variable are replaced with the +// real thing. +// +static Value *getVal(const Type *Ty, const ValID &ID) { + if (Ty == Type::LabelTy) { + GenerateError("Cannot use a basic block here"); + return 0; + } + + // See if the value has already been defined. + Value *V = getExistingVal(Ty, ID); + if (V) return V; + if (TriggerError) return 0; + + if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) { + GenerateError("Invalid use of a composite type"); + return 0; + } + + // If we reached here, we referenced either a symbol that we don't know about + // or an id number that hasn't been read yet. We may be referencing something + // forward, so just create an entry to be resolved later and get to it... + // + switch (ID.Type) { + case ValID::GlobalName: + case ValID::GlobalID: { + const PointerType *PTy = dyn_cast<PointerType>(Ty); + if (!PTy) { + GenerateError("Invalid type for reference to global" ); + return 0; + } + const Type* ElTy = PTy->getElementType(); + if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy)) + V = new Function(FTy, GlobalValue::ExternalLinkage); + else + V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage); + break; + } + default: + V = new Argument(Ty); + } + + // Remember where this forward reference came from. FIXME, shouldn't we try + // to recycle these things?? + CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, + llvmAsmlineno))); + + if (inFunctionScope()) + InsertValue(V, CurFun.LateResolveValues); + else + InsertValue(V, CurModule.LateResolveValues); + return V; +} + +/// defineBBVal - This is a definition of a new basic block with the specified +/// identifier which must be the same as CurFun.NextValNum, if its numeric. +static BasicBlock *defineBBVal(const ValID &ID) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + BasicBlock *BB = 0; + + // First, see if this was forward referenced + + std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + // 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); + + // We're about to erase the entry, save the key so we can clean it up. + ValID Tmp = BBI->first; + + // Erase the forward ref from the map as its no longer "forward" + CurFun.BBForwardRefs.erase(ID); + + // The key has been removed from the map but so we don't want to leave + // strdup'd memory around so destroy it too. + Tmp.destroy(); + + // If its a numbered definition, bump the number and set the BB value. + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); + } + + ID.destroy(); + return BB; + } + + // We haven't seen this BB before and its first mention is a definition. + // Just create it and return it. + std::string Name (ID.Type == ValID::LocalName ? ID.getName() : ""); + BB = new BasicBlock(Name, CurFun.CurrentFunction); + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); + } + + ID.destroy(); // Free strdup'd memory + return BB; +} + +/// getBBVal - get an existing BB value or create a forward reference for it. +/// +static BasicBlock *getBBVal(const ValID &ID) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + BasicBlock *BB = 0; + + std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + } if (ID.Type == ValID::LocalName) { + std::string Name = ID.getName(); + Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name); + if (N) + if (N->getType()->getTypeID() == Type::LabelTyID) + BB = cast<BasicBlock>(N); + else + GenerateError("Reference to label '" + Name + "' is actually of type '"+ + N->getType()->getDescription() + "'"); + } else if (ID.Type == ValID::LocalID) { + if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) { + if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID) + BB = cast<BasicBlock>(CurFun.Values[ID.Num]); + else + GenerateError("Reference to label '%" + utostr(ID.Num) + + "' is actually of type '"+ + CurFun.Values[ID.Num]->getType()->getDescription() + "'"); + } + } else { + GenerateError("Illegal label reference " + ID.getName()); + return 0; + } + + // If its already been defined, return it now. + if (BB) { + ID.destroy(); // Free strdup'd memory. + return BB; + } + + // Otherwise, this block has not been seen before, create it. + std::string Name; + if (ID.Type == ValID::LocalName) + Name = ID.getName(); + BB = new BasicBlock(Name, CurFun.CurrentFunction); + + // Insert it in the forward refs map. + CurFun.BBForwardRefs[ID] = BB; + + 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(ValueList &LateResolvers, ValueList *FutureLateResolvers) { + // Loop over LateResolveDefs fixing up stuff that couldn't be resolved + while (!LateResolvers.empty()) { + Value *V = LateResolvers.back(); + LateResolvers.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 = getExistingVal(V->getType(), DID); + if (TriggerError) + return; + if (TheRealValue) { + V->replaceAllUsesWith(TheRealValue); + delete V; + CurModule.PlaceHolderInfo.erase(PHI); + } else if (FutureLateResolvers) { + // Functions have their unresolved items forwarded to the module late + // resolver table + InsertValue(V, *FutureLateResolvers); + } else { + if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) { + GenerateError("Reference to an invalid definition: '" +DID.getName()+ + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } else { + GenerateError("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } + } + } + LateResolvers.clear(); +} + +// ResolveTypeTo - A brand new type was just declared. This means that (if +// name is not null) things referencing Name can be resolved. Otherwise, things +// refering to the number can be resolved. Do this now. +// +static void ResolveTypeTo(std::string *Name, const Type *ToTy) { + ValID D; + if (Name) + D = ValID::createLocalName(*Name); + else + D = ValID::createLocalID(CurModule.Types.size()); + + std::map<ValID, PATypeHolder>::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); + } +} + +// setValueName - Set the specified value to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is free'd by this function. +// +static void setValueName(Value *V, std::string *NameStr) { + if (!NameStr) return; + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string + + if (V->getType() == Type::VoidTy) { + GenerateError("Can't assign name '" + Name+"' to value with void type"); + return; + } + + assert(inFunctionScope() && "Must be in function scope!"); + ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); + if (ST.lookup(Name)) { + GenerateError("Redefinition of value '" + Name + "' of type '" + + V->getType()->getDescription() + "'"); + return; + } + + // Set the name. + V->setName(Name); +} + +/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, +/// this is a declaration, otherwise it is a definition. +static GlobalVariable * +ParseGlobalVariable(std::string *NameStr, + GlobalValue::LinkageTypes Linkage, + GlobalValue::VisibilityTypes Visibility, + bool isConstantGlobal, const Type *Ty, + Constant *Initializer, bool IsThreadLocal) { + if (isa<FunctionType>(Ty)) { + GenerateError("Cannot declare global vars of function type"); + return 0; + } + + const PointerType *PTy = PointerType::get(Ty); + + std::string Name; + if (NameStr) { + Name = *NameStr; // Copy string + delete NameStr; // Free old string + } + + // See if this global value was forward referenced. If so, recycle the + // object. + ValID ID; + if (!Name.empty()) { + ID = ValID::createGlobalName(Name); + } else { + ID = ValID::createGlobalID(CurModule.Values.size()); + } + + if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { + // Move the global to the end of the list, from whereever it was + // previously inserted. + GlobalVariable *GV = cast<GlobalVariable>(FWGV); + CurModule.CurrentModule->getGlobalList().remove(GV); + CurModule.CurrentModule->getGlobalList().push_back(GV); + GV->setInitializer(Initializer); + GV->setLinkage(Linkage); + GV->setVisibility(Visibility); + GV->setConstant(isConstantGlobal); + GV->setThreadLocal(IsThreadLocal); + InsertValue(GV, CurModule.Values); + return GV; + } + + // If this global has a name + if (!Name.empty()) { + // if the global we're parsing has an initializer (is a definition) and + // has external linkage. + if (Initializer && Linkage != GlobalValue::InternalLinkage) + // If there is already a global with external linkage with this name + if (CurModule.CurrentModule->getGlobalVariable(Name, false)) { + // If we allow this GVar to get created, it will be renamed in the + // symbol table because it conflicts with an existing GVar. We can't + // allow redefinition of GVars whose linking indicates that their name + // must stay the same. Issue the error. + GenerateError("Redefinition of global variable named '" + Name + + "' of type '" + Ty->getDescription() + "'"); + return 0; + } + } + + // Otherwise there is no existing GV to use, create one now. + GlobalVariable *GV = + new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, + CurModule.CurrentModule, IsThreadLocal); + GV->setVisibility(Visibility); + InsertValue(GV, CurModule.Values); + 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 Type *T, std::string *NameStr) { + assert(!inFunctionScope() && "Can't give types function-local names!"); + if (NameStr == 0) return false; + + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string + + // We don't allow assigning names to void type + if (T == Type::VoidTy) { + GenerateError("Can't assign name '" + Name + "' to the void type"); + return false; + } + + // Set the type name, checking for conflicts as we do so. + bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T); + + if (AlreadyExists) { // Inserting a name that is already defined??? + const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); + assert(Existing && "Conflict but no matching type?!"); + + // There is only one case where this is allowed: when we are refining an + // opaque type. In this case, Existing will be an opaque type. + if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) { + // We ARE replacing an opaque type! + const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T); + return true; + } + + // Otherwise, this is an attempt to redefine a type. That's okay if + // the redefinition is identical to the original. This will be so if + // Existing and T point to the same Type object. In this one case we + // allow the equivalent redefinition. + if (Existing == T) return true; // Yes, it's equal. + + // Any other kind of (non-equivalent) redefinition is an error. + GenerateError("Redefinition of type named '" + Name + "' of type '" + + T->getDescription() + "'"); + } + + 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) { + // If Ty isn't abstract, or if there are no up-references in it, then there is + // nothing to resolve here. + if (!ty->isAbstract() || UpRefs.empty()) return ty; + + PATypeHolder Ty(ty); + UR_OUT("Type '" << Ty->getDescription() << + "' newly formed. Resolving upreferences.\n" << + UpRefs.size() << " upreferences active!\n"); + + // If we find any resolvable upreferences (i.e., those whose NestingLevel goes + // to zero), we resolve them all together before we resolve them to Ty. At + // the end of the loop, if there is anything to resolve to Ty, it will be in + // this variable. + OpaqueType *TypeToResolve = 0; + + for (unsigned i = 0; i != UpRefs.size(); ++i) { + UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].second->getDescription() << ") = " + << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); + if (TypeContains(Ty, UpRefs[i].LastContainedTy)) { + // Decrement level of upreference + unsigned Level = --UpRefs[i].NestingLevel; + UpRefs[i].LastContainedTy = Ty; + UR_OUT(" Uplevel Ref Level = " << Level << "\n"); + if (Level == 0) { // Upreference should be resolved! + if (!TypeToResolve) { + TypeToResolve = UpRefs[i].UpRefTy; + } else { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].second->getDescription() << "\n"; + std::string OldName = UpRefs[i].UpRefTy->getDescription()); + UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); + UR_OUT(" * Type '" << OldName << "' refined upreference to: " + << (const void*)Ty << ", " << Ty->getDescription() << "\n"); + } + UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... + --i; // Do not skip the next element... + } + } + } + + if (TypeToResolve) { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].second->getDescription() << "\n"; + std::string OldName = TypeToResolve->getDescription()); + TypeToResolve->refineAbstractTypeTo(Ty); + } + + return Ty; +} + +//===----------------------------------------------------------------------===// +// RunVMAsmParser - Define an interface to this parser +//===----------------------------------------------------------------------===// +// +static Module* RunParser(Module * M); + +Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { + set_scan_file(F); + + CurFilename = Filename; + return RunParser(new Module(CurFilename)); +} + +Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { + set_scan_string(AsmString); + + CurFilename = "from_memory"; + if (M == NULL) { + return RunParser(new Module (CurFilename)); + } else { + return RunParser(M); + } +} + + +#line 957 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +typedef union { + llvm::Module *ModuleVal; + llvm::Function *FunctionVal; + llvm::BasicBlock *BasicBlockVal; + llvm::TerminatorInst *TermInstVal; + llvm::Instruction *InstVal; + llvm::Constant *ConstVal; + + const llvm::Type *PrimType; + std::list<llvm::PATypeHolder> *TypeList; + llvm::PATypeHolder *TypeVal; + llvm::Value *ValueVal; + std::vector<llvm::Value*> *ValueList; + llvm::ArgListType *ArgList; + llvm::TypeWithAttrs TypeWithAttrs; + llvm::TypeWithAttrsList *TypeWithAttrsList; + llvm::ValueRefList *ValueRefList; + + // Represent the RHS of PHI node + std::list<std::pair<llvm::Value*, + llvm::BasicBlock*> > *PHIList; + std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable; + std::vector<llvm::Constant*> *ConstVector; + + llvm::GlobalValue::LinkageTypes Linkage; + llvm::GlobalValue::VisibilityTypes Visibility; + uint16_t ParamAttrs; + llvm::APInt *APIntVal; + int64_t SInt64Val; + uint64_t UInt64Val; + int SIntVal; + unsigned UIntVal; + double FPVal; + bool BoolVal; + + std::string *StrVal; // This memory must be deleted + llvm::ValID ValIDVal; + + llvm::Instruction::BinaryOps BinaryOpVal; + llvm::Instruction::TermOps TermOpVal; + llvm::Instruction::MemoryOps MemOpVal; + llvm::Instruction::CastOps CastOpVal; + llvm::Instruction::OtherOps OtherOpVal; + llvm::ICmpInst::Predicate IPredicate; + llvm::FCmpInst::Predicate FPredicate; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 583 +#define YYFLAG -32768 +#define YYNTBASE 153 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 392 ? yytranslate[x] : 234) + +static const short yytranslate[] = { 0, + 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, 2, 2, 2, 2, 2, 143, + 144, 141, 2, 140, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 148, + 139, 149, 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, + 145, 142, 147, 2, 2, 2, 2, 2, 152, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 146, + 2, 2, 150, 2, 151, 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, 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, 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, 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, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 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, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, + 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, + 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, + 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, + 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, + 120, 121, 124, 125, 127, 129, 131, 132, 135, 137, + 139, 141, 143, 145, 147, 149, 151, 152, 154, 156, + 158, 159, 161, 163, 164, 166, 168, 170, 172, 173, + 175, 177, 178, 180, 182, 184, 186, 188, 191, 193, + 195, 197, 199, 201, 202, 205, 207, 209, 211, 212, + 215, 216, 219, 220, 224, 227, 228, 230, 231, 235, + 237, 240, 242, 244, 246, 248, 250, 252, 255, 257, + 260, 266, 272, 278, 284, 288, 291, 297, 302, 305, + 307, 309, 311, 315, 317, 321, 323, 324, 326, 330, + 335, 339, 343, 348, 353, 357, 364, 370, 373, 376, + 379, 382, 385, 388, 391, 394, 397, 400, 403, 406, + 413, 419, 428, 435, 442, 450, 458, 465, 474, 483, + 487, 489, 491, 493, 495, 496, 499, 506, 508, 509, + 511, 514, 515, 519, 520, 524, 528, 532, 536, 537, + 545, 546, 555, 556, 565, 571, 574, 578, 580, 584, + 588, 592, 596, 598, 599, 605, 609, 611, 615, 617, + 618, 628, 630, 632, 637, 639, 641, 644, 648, 649, + 651, 653, 655, 657, 659, 661, 663, 665, 667, 671, + 673, 679, 681, 683, 685, 687, 689, 691, 694, 697, + 700, 704, 707, 708, 710, 713, 716, 720, 730, 740, + 749, 764, 766, 768, 775, 781, 784, 791, 799, 803, + 809, 810, 811, 815, 818, 820, 826, 832, 839, 846, + 851, 858, 863, 868, 875, 882, 885, 894, 896, 898, + 899, 903, 910, 914, 921, 924, 930, 938 +}; + +static const short yyrhs[] = { 70, + 0, 71, 0, 72, 0, 73, 0, 74, 0, 75, + 0, 76, 0, 77, 0, 78, 0, 82, 0, 83, + 0, 84, 0, 79, 0, 80, 0, 81, 0, 113, + 0, 114, 0, 115, 0, 116, 0, 117, 0, 118, + 0, 119, 0, 120, 0, 121, 0, 122, 0, 123, + 0, 124, 0, 87, 0, 88, 0, 89, 0, 90, + 0, 91, 0, 92, 0, 93, 0, 94, 0, 95, + 0, 96, 0, 97, 0, 98, 0, 99, 0, 100, + 0, 101, 0, 102, 0, 103, 0, 104, 0, 105, + 0, 106, 0, 93, 0, 94, 0, 95, 0, 96, + 0, 23, 0, 24, 0, 11, 0, 12, 0, 13, + 0, 16, 0, 19, 0, 21, 0, 160, 0, 0, + 160, 139, 0, 0, 17, 0, 20, 0, 165, 0, + 0, 163, 139, 0, 39, 0, 41, 0, 40, 0, + 42, 0, 44, 0, 43, 0, 45, 0, 47, 0, + 0, 136, 0, 137, 0, 138, 0, 0, 43, 0, + 45, 0, 0, 39, 0, 40, 0, 41, 0, 44, + 0, 0, 41, 0, 39, 0, 0, 58, 0, 59, + 0, 60, 0, 61, 0, 62, 0, 57, 4, 0, + 114, 0, 115, 0, 132, 0, 133, 0, 135, 0, + 0, 174, 173, 0, 131, 0, 134, 0, 173, 0, + 0, 176, 175, 0, 0, 50, 4, 0, 0, 140, + 50, 4, 0, 31, 19, 0, 0, 179, 0, 0, + 140, 182, 181, 0, 179, 0, 50, 4, 0, 11, + 0, 12, 0, 13, 0, 14, 0, 46, 0, 183, + 0, 184, 141, 0, 218, 0, 142, 4, 0, 184, + 143, 188, 144, 176, 0, 10, 143, 188, 144, 176, + 0, 145, 4, 146, 184, 147, 0, 148, 4, 146, + 184, 149, 0, 150, 189, 151, 0, 150, 151, 0, + 148, 150, 189, 151, 149, 0, 148, 150, 151, 149, + 0, 184, 174, 0, 184, 0, 10, 0, 185, 0, + 187, 140, 185, 0, 187, 0, 187, 140, 36, 0, + 36, 0, 0, 184, 0, 189, 140, 184, 0, 184, + 145, 192, 147, 0, 184, 145, 147, 0, 184, 152, + 19, 0, 184, 148, 192, 149, 0, 184, 150, 192, + 151, 0, 184, 150, 151, 0, 184, 148, 150, 192, + 151, 149, 0, 184, 148, 150, 151, 149, 0, 184, + 37, 0, 184, 38, 0, 184, 218, 0, 184, 191, + 0, 184, 22, 0, 158, 3, 0, 158, 5, 0, + 158, 4, 0, 158, 6, 0, 11, 23, 0, 11, + 24, 0, 159, 9, 0, 155, 143, 190, 35, 184, + 144, 0, 112, 143, 190, 229, 144, 0, 126, 143, + 190, 140, 190, 140, 190, 144, 0, 153, 143, 190, + 140, 190, 144, 0, 154, 143, 190, 140, 190, 144, + 0, 85, 156, 143, 190, 140, 190, 144, 0, 86, + 157, 143, 190, 140, 190, 144, 0, 128, 143, 190, + 140, 190, 144, 0, 129, 143, 190, 140, 190, 140, + 190, 144, 0, 130, 143, 190, 140, 190, 140, 190, + 144, 0, 192, 140, 190, 0, 190, 0, 29, 0, + 30, 0, 34, 0, 0, 186, 218, 0, 118, 143, + 195, 35, 184, 144, 0, 197, 0, 0, 198, 0, + 197, 198, 0, 0, 28, 199, 214, 0, 0, 27, + 200, 215, 0, 55, 54, 204, 0, 162, 15, 184, + 0, 162, 15, 10, 0, 0, 164, 168, 194, 193, + 190, 201, 181, 0, 0, 164, 166, 168, 194, 193, + 190, 202, 181, 0, 0, 164, 167, 168, 194, 193, + 184, 203, 181, 0, 164, 168, 32, 171, 195, 0, + 48, 205, 0, 51, 139, 206, 0, 19, 0, 49, + 139, 19, 0, 63, 139, 19, 0, 145, 207, 147, + 0, 207, 140, 19, 0, 19, 0, 0, 208, 140, + 184, 174, 161, 0, 184, 174, 161, 0, 208, 0, + 208, 140, 36, 0, 36, 0, 0, 172, 186, 163, + 143, 209, 144, 176, 180, 177, 0, 25, 0, 150, + 0, 170, 168, 210, 211, 0, 26, 0, 151, 0, + 221, 213, 0, 169, 168, 210, 0, 0, 56, 0, + 3, 0, 4, 0, 9, 0, 23, 0, 24, 0, + 37, 0, 38, 0, 22, 0, 148, 192, 149, 0, + 191, 0, 54, 216, 19, 140, 19, 0, 7, 0, + 8, 0, 160, 0, 163, 0, 218, 0, 217, 0, + 184, 219, 0, 221, 222, 0, 212, 222, 0, 223, + 162, 224, 0, 223, 226, 0, 0, 18, 0, 64, + 220, 0, 64, 10, 0, 65, 14, 219, 0, 65, + 11, 219, 140, 14, 219, 140, 14, 219, 0, 66, + 158, 219, 140, 14, 219, 145, 225, 147, 0, 66, + 158, 219, 140, 14, 219, 145, 147, 0, 67, 172, + 186, 219, 143, 228, 144, 176, 35, 14, 219, 68, + 14, 219, 0, 68, 0, 69, 0, 225, 158, 217, + 140, 14, 219, 0, 158, 217, 140, 14, 219, 0, + 162, 231, 0, 184, 145, 219, 140, 219, 147, 0, + 227, 140, 145, 219, 140, 219, 147, 0, 184, 219, + 174, 0, 228, 140, 184, 219, 174, 0, 0, 0, + 229, 140, 220, 0, 53, 52, 0, 52, 0, 153, + 184, 219, 140, 219, 0, 154, 184, 219, 140, 219, + 0, 85, 156, 184, 219, 140, 219, 0, 86, 157, + 184, 219, 140, 219, 0, 155, 220, 35, 184, 0, + 126, 220, 140, 220, 140, 220, 0, 127, 220, 140, + 184, 0, 128, 220, 140, 220, 0, 129, 220, 140, + 220, 140, 220, 0, 130, 220, 140, 220, 140, 220, + 0, 125, 227, 0, 230, 172, 186, 219, 143, 228, + 144, 176, 0, 233, 0, 33, 0, 0, 107, 184, + 178, 0, 107, 184, 140, 11, 219, 178, 0, 108, + 184, 178, 0, 108, 184, 140, 11, 219, 178, 0, + 109, 220, 0, 232, 110, 184, 219, 178, 0, 232, + 111, 220, 140, 184, 219, 178, 0, 112, 184, 219, + 229, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1117, + 1117, 1117, 1117, 1117, 1117, 1118, 1118, 1118, 1118, 1118, + 1118, 1118, 1119, 1119, 1119, 1119, 1119, 1122, 1122, 1123, + 1123, 1124, 1124, 1125, 1125, 1126, 1126, 1130, 1130, 1131, + 1131, 1132, 1132, 1133, 1133, 1134, 1134, 1135, 1135, 1136, + 1136, 1137, 1138, 1143, 1144, 1144, 1146, 1146, 1146, 1147, + 1147, 1151, 1155, 1160, 1160, 1162, 1163, 1168, 1174, 1175, + 1176, 1177, 1178, 1182, 1183, 1184, 1188, 1189, 1190, 1191, + 1195, 1196, 1197, 1201, 1202, 1203, 1204, 1205, 1209, 1210, + 1211, 1214, 1214, 1215, 1216, 1217, 1218, 1219, 1227, 1228, + 1229, 1230, 1231, 1234, 1235, 1240, 1241, 1242, 1245, 1246, + 1253, 1253, 1260, 1260, 1269, 1277, 1277, 1283, 1283, 1285, + 1290, 1303, 1303, 1303, 1303, 1306, 1310, 1314, 1321, 1326, + 1334, 1364, 1395, 1400, 1412, 1422, 1426, 1436, 1443, 1450, + 1457, 1462, 1467, 1474, 1475, 1482, 1489, 1497, 1503, 1515, + 1543, 1559, 1586, 1614, 1640, 1660, 1686, 1706, 1718, 1725, + 1791, 1801, 1811, 1817, 1827, 1833, 1843, 1848, 1853, 1861, + 1873, 1895, 1903, 1909, 1920, 1925, 1930, 1936, 1942, 1951, + 1955, 1963, 1963, 1966, 1966, 1969, 1980, 2001, 2006, 2014, + 2015, 2019, 2019, 2023, 2023, 2026, 2029, 2053, 2064, 2071, + 2074, 2080, 2083, 2090, 2094, 2113, 2116, 2122, 2132, 2136, + 2141, 2143, 2148, 2153, 2162, 2172, 2183, 2187, 2196, 2205, + 2210, 2331, 2331, 2333, 2342, 2342, 2344, 2349, 2361, 2365, + 2370, 2374, 2378, 2382, 2386, 2390, 2394, 2398, 2402, 2427, + 2431, 2441, 2445, 2449, 2454, 2461, 2461, 2467, 2476, 2480, + 2489, 2498, 2507, 2511, 2518, 2522, 2526, 2531, 2541, 2560, + 2569, 2649, 2653, 2660, 2671, 2684, 2694, 2705, 2715, 2724, + 2733, 2736, 2737, 2744, 2748, 2753, 2774, 2791, 2805, 2819, + 2831, 2839, 2846, 2852, 2858, 2864, 2879, 2964, 2969, 2973, + 2980, 2987, 2995, 3002, 3010, 3018, 3032, 3049 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","ESINT64VAL", +"EUINT64VAL","ESAPINTVAL","EUAPINTVAL","LOCALVAL_ID","GLOBALVAL_ID","FPVAL", +"VOID","INTTYPE","FLOAT","DOUBLE","LABEL","TYPE","LOCALVAR","GLOBALVAR","LABELSTR", +"STRINGCONSTANT","ATSTRINGCONSTANT","PCTSTRINGCONSTANT","ZEROINITIALIZER","TRUETOK", +"FALSETOK","BEGINTOK","ENDTOK","DECLARE","DEFINE","GLOBAL","CONSTANT","SECTION", +"ALIAS","VOLATILE","THREAD_LOCAL","TO","DOTDOTDOT","NULL_TOK","UNDEF","INTERNAL", +"LINKONCE","WEAK","APPENDING","DLLIMPORT","DLLEXPORT","EXTERN_WEAK","OPAQUE", +"EXTERNAL","TARGET","TRIPLE","ALIGN","DEPLIBS","CALL","TAIL","ASM_TOK","MODULE", +"SIDEEFFECT","CC_TOK","CCC_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", +"SHL","LSHR","ASHR","ICMP","FCMP","EQ","NE","SLT","SGT","SLE","SGE","ULT","UGT", +"ULE","UGE","OEQ","ONE","OLT","OGT","OLE","OGE","ORD","UNO","UEQ","UNE","MALLOC", +"ALLOCA","FREE","LOAD","STORE","GETELEMENTPTR","TRUNC","ZEXT","SEXT","FPTRUNC", +"FPEXT","BITCAST","UITOFP","SITOFP","FPTOUI","FPTOSI","INTTOPTR","PTRTOINT", +"PHI_TOK","SELECT","VAARG","EXTRACTELEMENT","INSERTELEMENT","SHUFFLEVECTOR", +"NORETURN","INREG","SRET","NOUNWIND","NOALIAS","DEFAULT","HIDDEN","PROTECTED", +"'='","','","'*'","'\\\\'","'('","')'","'['","'x'","']'","'<'","'>'","'{'","'}'", +"'c'","ArithmeticOps","LogicalOps","CastOps","IPredicates","FPredicates","IntType", +"FPType","LocalName","OptLocalName","OptLocalAssign","GlobalName","OptGlobalAssign", +"GlobalAssign","GVInternalLinkage","GVExternalLinkage","GVVisibilityStyle","FunctionDeclareLinkage", +"FunctionDefineLinkage","AliasLinkage","OptCallingConv","ParamAttr","OptParamAttrs", +"FuncAttr","OptFuncAttrs","OptAlign","OptCAlign","SectionString","OptSection", +"GlobalVarAttributes","GlobalVarAttribute","PrimType","Types","ArgType","ResultTypes", +"ArgTypeList","ArgTypeListI","TypeListI","ConstVal","ConstExpr","ConstVector", +"GlobalType","ThreadLocal","AliaseeRef","Module","DefinitionList","Definition", +"@1","@2","@3","@4","@5","AsmBlock","TargetDefinition","LibrariesDefinition", +"LibList","ArgListH","ArgList","FunctionHeaderH","BEGIN","FunctionHeader","END", +"Function","FunctionProto","OptSideEffect","ConstValueRef","SymbolicValueRef", +"ValueRef","ResolvedVal","BasicBlockList","BasicBlock","InstructionList","BBTerminatorInst", +"JumpTable","Inst","PHIList","ValueRefList","IndexList","OptTailCall","InstVal", +"OptVolatile","MemoryInst", NULL +}; +#endif + +static const short yyr1[] = { 0, + 153, 153, 153, 153, 153, 153, 153, 153, 153, 154, + 154, 154, 154, 154, 154, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 155, 155, 156, 156, 156, + 156, 156, 156, 156, 156, 156, 156, 157, 157, 157, + 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, + 157, 157, 157, 158, 159, 159, 160, 160, 160, 161, + 161, 162, 162, 163, 163, 164, 164, 165, 166, 166, + 166, 166, 166, 167, 167, 167, 168, 168, 168, 168, + 169, 169, 169, 170, 170, 170, 170, 170, 171, 171, + 171, 172, 172, 172, 172, 172, 172, 172, 173, 173, + 173, 173, 173, 174, 174, 175, 175, 175, 176, 176, + 177, 177, 178, 178, 179, 180, 180, 181, 181, 182, + 182, 183, 183, 183, 183, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 185, 186, + 186, 187, 187, 188, 188, 188, 188, 189, 189, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 192, + 192, 193, 193, 194, 194, 195, 195, 196, 196, 197, + 197, 199, 198, 200, 198, 198, 198, 198, 201, 198, + 202, 198, 203, 198, 198, 198, 198, 204, 205, 205, + 206, 207, 207, 207, 208, 208, 209, 209, 209, 209, + 210, 211, 211, 212, 213, 213, 214, 215, 216, 216, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 218, 218, 218, 218, 219, 219, 220, 221, 221, + 222, 223, 223, 223, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 225, 225, 226, 227, 227, 228, 228, + 228, 229, 229, 230, 230, 231, 231, 231, 231, 231, + 231, 231, 231, 231, 231, 231, 231, 231, 232, 232, + 233, 233, 233, 233, 233, 233, 233, 233 +}; + +static const short yyr2[] = { 0, + 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, + 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, + 0, 2, 0, 1, 1, 1, 0, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, + 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, + 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, + 1, 1, 1, 0, 2, 1, 1, 1, 0, 2, + 0, 2, 0, 3, 2, 0, 1, 0, 3, 1, + 2, 1, 1, 1, 1, 1, 1, 2, 1, 2, + 5, 5, 5, 5, 3, 2, 5, 4, 2, 1, + 1, 1, 3, 1, 3, 1, 0, 1, 3, 4, + 3, 3, 4, 4, 3, 6, 5, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, + 5, 8, 6, 6, 7, 7, 6, 8, 8, 3, + 1, 1, 1, 1, 0, 2, 6, 1, 0, 1, + 2, 0, 3, 0, 3, 3, 3, 3, 0, 7, + 0, 8, 0, 8, 5, 2, 3, 1, 3, 3, + 3, 3, 1, 0, 5, 3, 1, 3, 1, 0, + 9, 1, 1, 4, 1, 1, 2, 3, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, + 5, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 3, 2, 0, 1, 2, 2, 3, 9, 9, 8, + 14, 1, 1, 6, 5, 2, 6, 7, 3, 5, + 0, 0, 3, 2, 1, 5, 5, 6, 6, 4, + 6, 4, 4, 6, 6, 2, 8, 1, 1, 0, + 3, 6, 3, 6, 2, 5, 7, 4 +}; + +static const short yydefact[] = { 67, + 57, 64, 58, 65, 59, 194, 192, 0, 0, 0, + 0, 0, 0, 77, 66, 67, 190, 81, 84, 0, + 0, 206, 0, 0, 62, 0, 68, 69, 71, 70, + 72, 74, 73, 75, 76, 78, 79, 80, 77, 77, + 185, 191, 82, 83, 77, 195, 85, 86, 87, 88, + 77, 253, 193, 253, 0, 0, 214, 207, 208, 196, + 242, 243, 198, 122, 123, 124, 125, 126, 0, 0, + 0, 0, 244, 245, 127, 197, 129, 185, 185, 89, + 184, 0, 92, 92, 254, 250, 63, 225, 226, 227, + 249, 209, 210, 213, 0, 147, 130, 0, 0, 0, + 0, 136, 148, 0, 128, 147, 0, 0, 91, 90, + 0, 182, 183, 0, 0, 93, 94, 95, 96, 97, + 0, 228, 0, 290, 252, 0, 211, 146, 104, 142, + 144, 0, 0, 0, 0, 0, 0, 135, 0, 0, + 0, 141, 0, 140, 0, 205, 122, 123, 124, 0, + 0, 0, 199, 98, 0, 222, 223, 224, 289, 275, + 0, 0, 0, 0, 92, 262, 263, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 13, 14, 15, 10, + 11, 12, 0, 0, 0, 0, 0, 0, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 251, + 92, 266, 0, 288, 212, 139, 0, 109, 0, 0, + 138, 0, 149, 109, 201, 203, 0, 186, 167, 168, + 163, 165, 164, 166, 169, 162, 158, 159, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 161, 160, 118, 0, 274, 256, 0, 255, + 0, 0, 54, 0, 0, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 0, 52, 53, 48, 49, + 50, 51, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 0, 113, 113, 295, 0, 0, 286, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 99, 100, 101, 102, 103, 105, 145, 143, 132, 133, + 134, 137, 131, 118, 118, 0, 0, 0, 0, 0, + 0, 0, 0, 151, 181, 0, 0, 0, 155, 0, + 152, 0, 0, 0, 0, 200, 220, 231, 232, 233, + 238, 234, 235, 236, 237, 229, 0, 240, 247, 246, + 248, 0, 257, 0, 0, 0, 0, 0, 291, 0, + 293, 272, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 106, 107, 108, 110, 202, + 204, 0, 0, 0, 272, 0, 0, 0, 0, 0, + 150, 136, 148, 0, 153, 154, 0, 0, 0, 0, + 0, 120, 118, 219, 104, 217, 0, 230, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 0, 0, 282, 283, 0, 0, 0, 0, 280, 0, + 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 180, 157, 0, 0, 0, 0, 115, 121, 119, 61, + 0, 109, 0, 239, 0, 0, 271, 0, 0, 113, + 114, 113, 0, 0, 0, 0, 0, 0, 276, 277, + 271, 0, 296, 0, 187, 0, 0, 171, 0, 0, + 0, 0, 156, 0, 0, 0, 60, 216, 218, 104, + 116, 0, 0, 0, 0, 0, 278, 279, 292, 294, + 273, 0, 0, 281, 284, 285, 0, 113, 0, 0, + 0, 177, 0, 0, 173, 174, 170, 61, 117, 111, + 241, 0, 0, 104, 0, 109, 267, 0, 109, 297, + 175, 176, 0, 0, 0, 215, 0, 221, 0, 260, + 0, 0, 269, 0, 0, 268, 287, 172, 178, 179, + 112, 258, 0, 259, 0, 104, 0, 0, 0, 270, + 0, 0, 0, 0, 265, 0, 0, 264, 0, 261, + 0, 0, 0 +}; + +static const short yydefgoto[] = { 250, + 251, 252, 276, 293, 150, 151, 73, 498, 12, 74, + 14, 15, 39, 40, 41, 45, 51, 111, 121, 316, + 216, 389, 319, 548, 369, 412, 530, 346, 413, 75, + 152, 130, 145, 131, 132, 104, 335, 358, 336, 114, + 82, 146, 581, 16, 17, 19, 18, 255, 324, 325, + 60, 22, 58, 95, 416, 417, 122, 158, 52, 90, + 53, 46, 419, 359, 77, 361, 260, 54, 86, 87, + 210, 552, 125, 299, 506, 429, 211, 212, 213, 214 +}; + +static const short yypact[] = { 1026, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, -3, -63, 44, + -10, 142, 62, 336,-32768, 1490,-32768, 107, 131, 74, + 127,-32768, -27, 149,-32768, 1195,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 93, 93, + 214,-32768,-32768,-32768, 93,-32768,-32768,-32768,-32768,-32768, + 93, 155,-32768, 13, 239, 253, 258,-32768,-32768,-32768, +-32768,-32768, 139,-32768,-32768,-32768,-32768,-32768, 282, 284, + 5, 128,-32768,-32768,-32768, 124,-32768, 256, 256, 230, +-32768, 34, 163, 163,-32768,-32768, 184,-32768,-32768,-32768, +-32768,-32768,-32768,-32768, -30, 956,-32768, 147, 151, 910, + 139,-32768, 124, -74,-32768, 956, 34, 34,-32768,-32768, + 987,-32768,-32768, 1210, 302,-32768,-32768,-32768,-32768,-32768, + 1247,-32768, 15, 1353,-32768, 290,-32768,-32768, 124,-32768, + 170, 173, 1262, 1262, 162, -68, 1262,-32768, 174, 1210, + 1262, 139, 177, 124, 83,-32768, 38, 312, 314, 251, + 315, 764,-32768,-32768, 126,-32768,-32768,-32768,-32768,-32768, + 273, 1308, 227, 317, 163,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 566, 613, 1262, 1262, 1262, 1262,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262, 1262,-32768, + 163,-32768, -4,-32768,-32768, -77, 1002,-32768, -59, 63, +-32768, 182, 124,-32768,-32768, 124, 987,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 566, 613, + 189, 190, 191, 193, 194, 1100, 1354, 925, 319, 196, + 197, 198,-32768,-32768, 203, 199,-32768, 139, 611,-32768, + 741, 741,-32768, 741, 1247,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 1262,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 1262, 109, 119,-32768, 611, 94, 204, 206, + 207, 208, 209, 215, 611, 611, 321, 1247, 1262, 1262, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -82,-32768, +-32768,-32768, -82, 203, 203, 323, 218, 220, 1210, 1210, + 1210, 1210, 1210,-32768,-32768, -21, 941, -92,-32768, -62, +-32768, 1210, 1210, 1210, -5,-32768, 1146,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 313, 1210,-32768,-32768,-32768, +-32768, 228,-32768, 233, 741, 611, 611, 4,-32768, 17, +-32768,-32768, 741, 225, 1262, 1262, 1262, 1262, 1262, 242, + 244, 1262, 741, 611, 245,-32768,-32768,-32768,-32768,-32768, +-32768, 1262, 1210, 1210,-32768, 246, 247, 248, 249, 1210, +-32768, 241, 764, -46,-32768,-32768, 252, 254, 358, 377, + 393,-32768, 203,-32768, 124, 259, 257,-32768, 379, -70, + 386, 388, 262, 266, 267, 741, 404, 741, 269, 271, + 741, 272, 124,-32768, 274, 276, 741, 741, 124, 270, + 283, 1262, 45, 287, 288, 70, 1210, 1210, 1210, 1210, +-32768,-32768, 275, 1210, 1210, 1262,-32768,-32768,-32768, 76, + 1164,-32768, 289,-32768, 741, 741, 1262, 741, 741, 283, +-32768, 283, 1262, 741, 294, 1262, 1262, 1262,-32768,-32768, + 1262, 372,-32768, 611,-32768, 1210, 1210,-32768, 295, 286, + 298, 299,-32768, 297, 300, 164,-32768,-32768,-32768, 124, + 84, 424, 305, 301, 611, 92,-32768,-32768,-32768,-32768, +-32768, 303, 741,-32768,-32768,-32768, 103, 283, 310, 311, + 1210,-32768, 1210, 1210,-32768,-32768,-32768, 76,-32768, 397, +-32768, 435, 6,-32768, 1262,-32768,-32768, 320,-32768,-32768, +-32768,-32768, 318, 322, 324,-32768, 455,-32768, 741,-32768, + 476, 7, -77, 611, -1,-32768, -82,-32768,-32768,-32768, +-32768,-32768, 329,-32768, 476,-32768, 447, 456, 335, -77, + 741, 741, 462, 409,-32768, 741, 464,-32768, 741,-32768, + 483, 484,-32768 +}; + +static const short yypgoto[] = { 362, + 363, 364, 250, 261, -161,-32768, 0, -38, 406, 14, +-32768,-32768,-32768,-32768, 29,-32768,-32768,-32768, -146, -294, + -407,-32768, -220,-32768, -285, 1,-32768, -289,-32768,-32768, + -25, 279, -114,-32768, 385, 403, -29, -150, -236, 167, + 202, 277,-32768,-32768, 481,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 421,-32768,-32768,-32768, +-32768,-32768,-32768, -492, -139, 98, -182,-32768, 452,-32768, +-32768,-32768,-32768,-32768, 26, 113,-32768,-32768,-32768,-32768 +}; + + +#define YYLAST 1545 + + +static const short yytable[] = { 11, + 76, 253, 264, 323, 296, 228, 155, 460, 99, 371, + 338, 340, 254, 13, 426, 11, 263, 263, 265, 300, + 301, 302, 303, 304, 388, 410, 307, 428, 388, 13, + 85, 311, 312, 567, 390, 391, 311, 312, 88, 156, + -54, -54, -54, -54, 411, 20, 103, 400, 386, 313, + 314, 387, 315, 427, 313, 314, 405, 315, 563, 21, + 229, 230, 112, 113, 308, 137, 427, 78, 79, 400, + 129, 137, 569, 83, 103, 23, 138, 400, 464, 84, + 129, 105, 222, 106, 153, 144, 11, 320, 406, 61, + 62, 1, 528, 400, 3, 144, 5, 24, 1, 2, + 404, 3, 4, 5, 453, 309, 310, 219, 220, 126, + 225, 223, 311, 312, 410, 226, 127, 57, 400, 360, + 420, 360, 360, 459, 360, 401, 553, 385, 25, 386, + 313, 314, 387, 315, 61, 62, 259, 101, 64, 65, + 66, 67, 2, 1, 2, 4, 3, 4, 5, 43, + 365, 44, 550, 564, 100, 483, 26, 360, 570, 294, + 295, 259, 297, 89, 157, 360, 360, 59, 256, 47, + 48, 49, 85, 68, 50, 298, 259, 259, 259, 259, + 259, 305, 306, 259, 509, 105, 510, 106, 485, 311, + 312, 129, 432, 383, 434, 435, 436, 311, 312, 1, + 27, 144, 3, 105, 5, 106, 388, 313, 314, 473, + 315, 321, 55, 488, 386, 313, 314, 387, 315, 115, + 116, 117, 118, 119, 120, 360, 360, 360, 36, 37, + 38, 535, 540, 360, 105, 536, 106, 261, 373, 144, + 262, 501, 535, 360, 360, 80, 539, 81, 368, 105, + 366, 106, 253, 231, 232, 233, 234, 92, 370, 105, + 388, 106, 388, 254, 105, 56, 106, 367, 109, 69, + 110, 93, 70, 140, 141, 71, 94, 72, 102, 107, + 108, 96, 144, 384, 259, 97, 360, 98, 360, 81, + 511, 360, 133, 514, 515, 516, 134, 360, 360, 395, + 396, 397, 398, 399, 105, 154, 106, 527, 215, 217, + 221, 403, 407, 408, 409, 555, 218, 224, 557, 227, + -55, 415, -56, 235, 257, 360, 360, 263, 360, 360, + 322, 329, 330, 331, 360, 332, 333, 341, 342, 343, + 344, 347, 345, 374, 360, 375, 376, 377, 378, 259, + 433, 259, 259, 259, 379, 382, 439, 392, 362, 363, + 393, 364, 394, 444, 445, 360, 443, 421, 418, 431, + 451, 551, 422, 360, 28, 29, 30, 31, 32, 33, + 34, 437, 35, 438, 442, 447, 448, 449, 450, 452, + 565, 454, 456, 455, 372, 457, 458, 463, 461, 465, + 462, 466, 380, 381, 467, 468, 469, 471, 473, 360, + 474, 476, 481, 477, 360, 478, 484, 489, 490, 491, + 492, 427, 482, 493, 494, 495, 486, 487, 502, 522, + 496, 360, 360, 513, 521, 500, 360, 523, 524, 360, + 525, 505, 531, 526, 532, 533, 547, 259, 549, 537, + 259, 259, 259, 541, 542, 505, 519, 520, 561, 497, + 571, 558, 423, 424, 425, 559, 556, 560, 568, 572, + 430, 36, 37, 38, 573, 576, 577, 579, 348, 349, + 440, 441, 582, 583, 350, 207, 208, 209, 327, 546, + 139, 543, 124, 544, 545, 318, 42, 351, 352, 353, + 328, 529, 136, 326, 123, 91, 517, 446, 0, 554, + 0, 0, 354, 355, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 470, 0, 472, 0, 497, 475, 356, + 0, 0, 0, 0, 479, 480, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 239, 240, 503, 504, 0, 507, 508, 0, 0, 0, + 0, 512, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 518, 0, 0, 0, 0, 0, 241, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 0, 242, 534, 243, 244, 245, 0, 0, 0, 0, + 538, 0, 0, 348, 349, 0, 0, 61, 62, 350, + 0, 0, 0, 357, 0, 0, 1, 2, 0, 3, + 4, 5, 351, 352, 353, 277, 278, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 562, 354, 355, 0, + 0, 566, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 0, 0, 356, 0, 0, 0, 574, 575, + 0, 0, 0, 578, 0, 0, 580, 0, 0, 0, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 239, 240, 0, 0, 0, + 0, 0, 0, 0, 0, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 0, + 0, 0, 241, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 0, 242, 0, 243, 244, + 245, 0, 0, 348, 349, 0, 0, 61, 62, 350, + 0, 105, 0, 106, 0, 0, 1, 2, 357, 3, + 4, 5, 351, 352, 353, 0, 0, 0, 0, 0, + 61, 62, 0, 0, 0, 0, 0, 354, 355, 1, + 2, 0, 3, 4, 5, 236, 0, 0, 0, 0, + 0, 0, 0, 0, 356, 0, 0, 0, 0, 0, + 237, 238, 0, 0, 0, 0, 0, 0, 0, 0, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 239, 240, 0, 0, 0, + 0, 0, 0, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 239, 240, + 0, 0, 241, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 0, 242, 0, 243, 244, + 245, 0, 0, 0, 0, 241, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 357, 242, + 0, 243, 244, 245, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 105, 0, 106, 0, 246, 0, + 0, 247, 0, 248, 0, 249, 61, 62, 0, 101, + 64, 65, 66, 67, 0, 1, 2, 0, 3, 4, + 5, 61, 62, 0, 101, 147, 148, 149, 67, 0, + 1, 2, 0, 3, 4, 5, 0, 61, 62, 0, + 101, 147, 148, 149, 67, 68, 1, 2, 0, 3, + 4, 5, 61, 62, 0, 101, 64, 65, 66, 67, + 68, 1, 2, 0, 3, 4, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, + 0, 128, 0, 61, 62, 0, 142, 64, 65, 66, + 67, 68, 1, 2, 0, 3, 4, 5, 61, 62, + 0, 101, 64, 65, 66, 67, 0, 1, 2, 0, + 3, 4, 5, 0, 0, -189, 0, 0, 0, 0, + 0, 0, 68, 0, 0, 0, 0, 317, 0, 0, + -63, 1, 2, 0, 3, 4, 5, 68, 0, 0, + 0, 69, 6, 7, 70, 0, 0, 71, 0, 72, + 135, 0, 0, 0, 0, 0, 69, 0, 0, 70, + 0, 0, 71, 8, 72, 339, 9, 0, 0, 0, + 10, 0, 69, 0, 0, 70, 0, 0, 71, 0, + 72, 402, 0, 0, 0, 0, 0, 69, 0, 0, + 70, 0, 0, 71, 143, 72, 61, 62, 0, 101, + 147, 148, 149, 67, 0, 1, 2, 0, 3, 4, + 5, 0, 0, 0, 0, 0, 0, 0, 69, 0, + 0, 70, 0, 0, 71, 0, 72, 0, 0, 0, + 0, 0, 0, 69, 0, 68, 70, 0, 0, 71, + 0, 72, 61, 62, 0, 101, 64, 65, 66, 67, + 0, 1, 2, 0, 3, 4, 5, 0, 0, 0, + 61, 62, 0, 101, 64, 65, 66, 67, 0, 1, + 2, 414, 3, 4, 5, 0, 0, 0, 0, 0, + 0, 68, 0, 0, 0, 0, 0, 0, 0, 499, + 0, 61, 62, 0, 63, 64, 65, 66, 67, 68, + 1, 2, 0, 3, 4, 5, 61, 62, 0, 101, + 147, 148, 149, 67, 0, 1, 2, 0, 3, 4, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 68, 69, 0, 0, 70, 0, 334, 71, 0, 72, + 0, 0, 0, 61, 62, 68, 142, 64, 65, 66, + 67, 0, 1, 2, 0, 3, 4, 5, 61, 62, + 0, 101, 64, 65, 66, 67, 0, 1, 2, 0, + 3, 4, 5, 0, 0, 0, 0, 69, 0, 0, + 70, 0, 68, 71, 0, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 69, 0, 68, 70, 0, + 0, 71, 0, 72, 61, 62, 0, 258, 64, 65, + 66, 67, 0, 1, 2, 0, 3, 4, 5, 0, + 0, 0, 0, 0, 0, 0, 69, 0, 0, 70, + 0, 0, 71, 0, 72, 0, 0, 0, 0, 0, + 0, 69, 0, 68, 70, 0, 0, 71, 0, 72, + 61, 62, 0, 101, 147, 148, 149, 67, 0, 1, + 2, 0, 3, 4, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 159, 0, 0, 69, 0, + 0, 70, 0, 0, 71, 0, 72, 0, 0, 68, + 0, 0, 0, 69, 160, 161, 70, 0, 0, 71, + 0, 72, 0, 0, 0, 0, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 69, + 0, 0, 70, 0, 0, 71, 0, 72, 0, 185, + 186, 187, 0, 0, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 0, 0, 0, 0, 0, 0, -188, + 0, 0, 0, 0, 0, 69, 0, 0, 70, 0, + 0, 71, 0, 337, -63, 1, 2, 0, 3, 4, + 5, 0, 0, 0, 0, 0, 6, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, + 9, 0, 0, 0, 10 +}; + +static const short yycheck[] = { 0, + 26, 152, 164, 224, 187, 145, 121, 415, 4, 295, + 247, 248, 152, 0, 11, 16, 11, 11, 165, 202, + 203, 204, 205, 206, 319, 31, 209, 11, 323, 16, + 18, 114, 115, 35, 324, 325, 114, 115, 26, 25, + 3, 4, 5, 6, 50, 49, 72, 140, 131, 132, + 133, 134, 135, 50, 132, 133, 149, 135, 551, 63, + 23, 24, 29, 30, 211, 140, 50, 39, 40, 140, + 96, 140, 565, 45, 100, 139, 151, 140, 149, 51, + 106, 141, 151, 143, 114, 111, 87, 147, 151, 7, + 8, 16, 500, 140, 19, 121, 21, 54, 16, 17, + 337, 19, 20, 21, 151, 110, 111, 133, 134, 140, + 140, 137, 114, 115, 31, 141, 147, 145, 140, 259, + 357, 261, 262, 413, 264, 147, 534, 310, 139, 131, + 132, 133, 134, 135, 7, 8, 162, 10, 11, 12, + 13, 14, 17, 16, 17, 20, 19, 20, 21, 43, + 265, 45, 147, 147, 150, 441, 15, 297, 566, 185, + 186, 187, 188, 151, 150, 305, 306, 19, 155, 39, + 40, 41, 18, 46, 44, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 470, 141, 472, 143, 144, 114, + 115, 217, 375, 308, 377, 378, 379, 114, 115, 16, + 139, 227, 19, 141, 21, 143, 501, 132, 133, 140, + 135, 149, 139, 144, 131, 132, 133, 134, 135, 57, + 58, 59, 60, 61, 62, 365, 366, 367, 136, 137, + 138, 140, 518, 373, 141, 144, 143, 11, 145, 265, + 14, 462, 140, 383, 384, 32, 144, 34, 140, 141, + 276, 143, 403, 3, 4, 5, 6, 19, 140, 141, + 555, 143, 557, 403, 141, 139, 143, 293, 39, 142, + 41, 19, 145, 107, 108, 148, 19, 150, 151, 78, + 79, 143, 308, 309, 310, 4, 426, 4, 428, 34, + 473, 431, 146, 476, 477, 478, 146, 437, 438, 329, + 330, 331, 332, 333, 141, 4, 143, 144, 19, 140, + 149, 337, 342, 343, 344, 536, 144, 144, 539, 143, + 9, 347, 9, 9, 52, 465, 466, 11, 468, 469, + 149, 143, 143, 143, 474, 143, 143, 19, 143, 143, + 143, 143, 140, 140, 484, 140, 140, 140, 140, 375, + 376, 377, 378, 379, 140, 35, 382, 35, 261, 262, + 143, 264, 143, 393, 394, 505, 392, 140, 56, 145, + 400, 533, 140, 513, 39, 40, 41, 42, 43, 44, + 45, 140, 47, 140, 140, 140, 140, 140, 140, 149, + 552, 140, 35, 140, 297, 19, 4, 19, 140, 14, + 144, 14, 305, 306, 143, 140, 140, 4, 140, 549, + 140, 140, 143, 140, 554, 140, 442, 447, 448, 449, + 450, 50, 140, 149, 454, 455, 140, 140, 140, 144, + 456, 571, 572, 140, 140, 461, 576, 140, 140, 579, + 144, 467, 19, 144, 140, 145, 50, 473, 14, 147, + 476, 477, 478, 144, 144, 481, 486, 487, 4, 460, + 14, 144, 365, 366, 367, 144, 147, 144, 140, 14, + 373, 136, 137, 138, 140, 14, 68, 14, 3, 4, + 383, 384, 0, 0, 9, 124, 124, 124, 239, 528, + 106, 521, 87, 523, 524, 217, 16, 22, 23, 24, + 240, 501, 100, 227, 84, 54, 481, 395, -1, 535, + -1, -1, 37, 38, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 426, -1, 428, -1, 528, 431, 54, + -1, -1, -1, -1, 437, 438, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 465, 466, -1, 468, 469, -1, -1, -1, + -1, 474, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 484, -1, -1, -1, -1, -1, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + -1, 126, 505, 128, 129, 130, -1, -1, -1, -1, + 513, -1, -1, 3, 4, -1, -1, 7, 8, 9, + -1, -1, -1, 148, -1, -1, 16, 17, -1, 19, + 20, 21, 22, 23, 24, 23, 24, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 549, 37, 38, -1, + -1, 554, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, -1, -1, 54, -1, -1, -1, 571, 572, + -1, -1, -1, 576, -1, -1, 579, -1, -1, -1, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, -1, -1, -1, + -1, -1, -1, -1, -1, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, + -1, -1, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, -1, 126, -1, 128, 129, + 130, -1, -1, 3, 4, -1, -1, 7, 8, 9, + -1, 141, -1, 143, -1, -1, 16, 17, 148, 19, + 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, + 7, 8, -1, -1, -1, -1, -1, 37, 38, 16, + 17, -1, 19, 20, 21, 22, -1, -1, -1, -1, + -1, -1, -1, -1, 54, -1, -1, -1, -1, -1, + 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, -1, -1, -1, + -1, -1, -1, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + -1, -1, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, -1, 126, -1, 128, 129, + 130, -1, -1, -1, -1, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 148, 126, + -1, 128, 129, 130, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 141, -1, 143, -1, 145, -1, + -1, 148, -1, 150, -1, 152, 7, 8, -1, 10, + 11, 12, 13, 14, -1, 16, 17, -1, 19, 20, + 21, 7, 8, -1, 10, 11, 12, 13, 14, -1, + 16, 17, -1, 19, 20, 21, -1, 7, 8, -1, + 10, 11, 12, 13, 14, 46, 16, 17, -1, 19, + 20, 21, 7, 8, -1, 10, 11, 12, 13, 14, + 46, 16, 17, -1, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 46, -1, -1, -1, + -1, 36, -1, 7, 8, -1, 10, 11, 12, 13, + 14, 46, 16, 17, -1, 19, 20, 21, 7, 8, + -1, 10, 11, 12, 13, 14, -1, 16, 17, -1, + 19, 20, 21, -1, -1, 0, -1, -1, -1, -1, + -1, -1, 46, -1, -1, -1, -1, 36, -1, -1, + 15, 16, 17, -1, 19, 20, 21, 46, -1, -1, + -1, 142, 27, 28, 145, -1, -1, 148, -1, 150, + 151, -1, -1, -1, -1, -1, 142, -1, -1, 145, + -1, -1, 148, 48, 150, 151, 51, -1, -1, -1, + 55, -1, 142, -1, -1, 145, -1, -1, 148, -1, + 150, 151, -1, -1, -1, -1, -1, 142, -1, -1, + 145, -1, -1, 148, 118, 150, 7, 8, -1, 10, + 11, 12, 13, 14, -1, 16, 17, -1, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, 142, -1, + -1, 145, -1, -1, 148, -1, 150, -1, -1, -1, + -1, -1, -1, 142, -1, 46, 145, -1, -1, 148, + -1, 150, 7, 8, -1, 10, 11, 12, 13, 14, + -1, 16, 17, -1, 19, 20, 21, -1, -1, -1, + 7, 8, -1, 10, 11, 12, 13, 14, -1, 16, + 17, 36, 19, 20, 21, -1, -1, -1, -1, -1, + -1, 46, -1, -1, -1, -1, -1, -1, -1, 36, + -1, 7, 8, -1, 10, 11, 12, 13, 14, 46, + 16, 17, -1, 19, 20, 21, 7, 8, -1, 10, + 11, 12, 13, 14, -1, 16, 17, -1, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 46, 142, -1, -1, 145, -1, 147, 148, -1, 150, + -1, -1, -1, 7, 8, 46, 10, 11, 12, 13, + 14, -1, 16, 17, -1, 19, 20, 21, 7, 8, + -1, 10, 11, 12, 13, 14, -1, 16, 17, -1, + 19, 20, 21, -1, -1, -1, -1, 142, -1, -1, + 145, -1, 46, 148, -1, 150, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 142, -1, 46, 145, -1, + -1, 148, -1, 150, 7, 8, -1, 10, 11, 12, + 13, 14, -1, 16, 17, -1, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, 142, -1, -1, 145, + -1, -1, 148, -1, 150, -1, -1, -1, -1, -1, + -1, 142, -1, 46, 145, -1, -1, 148, -1, 150, + 7, 8, -1, 10, 11, 12, 13, 14, -1, 16, + 17, -1, 19, 20, 21, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 33, -1, -1, 142, -1, + -1, 145, -1, -1, 148, -1, 150, -1, -1, 46, + -1, -1, -1, 142, 52, 53, 145, -1, -1, 148, + -1, 150, -1, -1, -1, -1, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 142, + -1, -1, 145, -1, -1, 148, -1, 150, -1, 107, + 108, 109, -1, -1, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, -1, -1, -1, -1, -1, -1, 0, + -1, -1, -1, -1, -1, 142, -1, -1, 145, -1, + -1, 148, -1, 150, 15, 16, 17, -1, 19, 20, + 21, -1, -1, -1, -1, -1, 27, 28, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 48, -1, -1, + 51, -1, -1, -1, 55 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 28: +#line 1122 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_EQ; ; + break;} +case 29: +#line 1122 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_NE; ; + break;} +case 30: +#line 1123 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_SLT; ; + break;} +case 31: +#line 1123 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_SGT; ; + break;} +case 32: +#line 1124 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_SLE; ; + break;} +case 33: +#line 1124 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_SGE; ; + break;} +case 34: +#line 1125 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_ULT; ; + break;} +case 35: +#line 1125 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_UGT; ; + break;} +case 36: +#line 1126 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_ULE; ; + break;} +case 37: +#line 1126 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.IPredicate = ICmpInst::ICMP_UGE; ; + break;} +case 38: +#line 1130 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_OEQ; ; + break;} +case 39: +#line 1130 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_ONE; ; + break;} +case 40: +#line 1131 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_OLT; ; + break;} +case 41: +#line 1131 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_OGT; ; + break;} +case 42: +#line 1132 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_OLE; ; + break;} +case 43: +#line 1132 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_OGE; ; + break;} +case 44: +#line 1133 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_ORD; ; + break;} +case 45: +#line 1133 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_UNO; ; + break;} +case 46: +#line 1134 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_UEQ; ; + break;} +case 47: +#line 1134 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_UNE; ; + break;} +case 48: +#line 1135 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_ULT; ; + break;} +case 49: +#line 1135 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_UGT; ; + break;} +case 50: +#line 1136 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_ULE; ; + break;} +case 51: +#line 1136 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_UGE; ; + break;} +case 52: +#line 1137 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_TRUE; ; + break;} +case 53: +#line 1138 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.FPredicate = FCmpInst::FCMP_FALSE; ; + break;} +case 61: +#line 1147 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.StrVal = 0; ; + break;} +case 62: +#line 1151 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.StrVal = yyvsp[-1].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 63: +#line 1155 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.StrVal = 0; + CHECK_FOR_ERROR + ; + break;} +case 67: +#line 1163 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.StrVal = 0; + CHECK_FOR_ERROR + ; + break;} +case 68: +#line 1168 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.StrVal = yyvsp[-1].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 69: +#line 1174 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::InternalLinkage; ; + break;} +case 70: +#line 1175 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::WeakLinkage; ; + break;} +case 71: +#line 1176 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ; + break;} +case 72: +#line 1177 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::AppendingLinkage; ; + break;} +case 73: +#line 1178 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::DLLExportLinkage; ; + break;} +case 74: +#line 1182 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::DLLImportLinkage; ; + break;} +case 75: +#line 1183 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ; + break;} +case 76: +#line 1184 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalLinkage; ; + break;} +case 77: +#line 1188 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Visibility = GlobalValue::DefaultVisibility; ; + break;} +case 78: +#line 1189 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Visibility = GlobalValue::DefaultVisibility; ; + break;} +case 79: +#line 1190 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Visibility = GlobalValue::HiddenVisibility; ; + break;} +case 80: +#line 1191 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Visibility = GlobalValue::ProtectedVisibility; ; + break;} +case 81: +#line 1195 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalLinkage; ; + break;} +case 82: +#line 1196 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::DLLImportLinkage; ; + break;} +case 83: +#line 1197 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalWeakLinkage; ; + break;} +case 84: +#line 1201 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalLinkage; ; + break;} +case 85: +#line 1202 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::InternalLinkage; ; + break;} +case 86: +#line 1203 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::LinkOnceLinkage; ; + break;} +case 87: +#line 1204 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::WeakLinkage; ; + break;} +case 88: +#line 1205 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::DLLExportLinkage; ; + break;} +case 89: +#line 1209 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::ExternalLinkage; ; + break;} +case 90: +#line 1210 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::WeakLinkage; ; + break;} +case 91: +#line 1211 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.Linkage = GlobalValue::InternalLinkage; ; + break;} +case 92: +#line 1214 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::C; ; + break;} +case 93: +#line 1215 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::C; ; + break;} +case 94: +#line 1216 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::Fast; ; + break;} +case 95: +#line 1217 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::Cold; ; + break;} +case 96: +#line 1218 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::X86_StdCall; ; + break;} +case 97: +#line 1219 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = CallingConv::X86_FastCall; ; + break;} +case 98: +#line 1220 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val) + GEN_ERROR("Calling conv too large"); + yyval.UIntVal = yyvsp[0].UInt64Val; + CHECK_FOR_ERROR + ; + break;} +case 99: +#line 1227 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::ZExt; ; + break;} +case 100: +#line 1228 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::SExt; ; + break;} +case 101: +#line 1229 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::InReg; ; + break;} +case 102: +#line 1230 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::StructRet; ; + break;} +case 103: +#line 1231 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::NoAlias; ; + break;} +case 104: +#line 1234 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::None; ; + break;} +case 105: +#line 1235 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs; + ; + break;} +case 106: +#line 1240 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::NoReturn; ; + break;} +case 107: +#line 1241 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::NoUnwind; ; + break;} +case 109: +#line 1245 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ParamAttrs = ParamAttr::None; ; + break;} +case 110: +#line 1246 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ParamAttrs = yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs; + ; + break;} +case 111: +#line 1253 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = 0; ; + break;} +case 112: +#line 1254 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.UIntVal = yyvsp[0].UInt64Val; + if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal)) + GEN_ERROR("Alignment must be a power of two"); + CHECK_FOR_ERROR +; + break;} +case 113: +#line 1260 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.UIntVal = 0; ; + break;} +case 114: +#line 1261 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.UIntVal = yyvsp[0].UInt64Val; + if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal)) + GEN_ERROR("Alignment must be a power of two"); + CHECK_FOR_ERROR +; + break;} +case 115: +#line 1269 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + for (unsigned i = 0, e = yyvsp[0].StrVal->length(); i != e; ++i) + if ((*yyvsp[0].StrVal)[i] == '"' || (*yyvsp[0].StrVal)[i] == '\\') + GEN_ERROR("Invalid character in section name"); + yyval.StrVal = yyvsp[0].StrVal; + CHECK_FOR_ERROR +; + break;} +case 116: +#line 1277 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.StrVal = 0; ; + break;} +case 117: +#line 1278 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.StrVal = yyvsp[0].StrVal; ; + break;} +case 118: +#line 1283 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{; + break;} +case 119: +#line 1284 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{; + break;} +case 120: +#line 1285 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurGV->setSection(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 121: +#line 1290 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val)) + GEN_ERROR("Alignment must be a power of two"); + CurGV->setAlignment(yyvsp[0].UInt64Val); + CHECK_FOR_ERROR + ; + break;} +case 126: +#line 1306 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeVal = new PATypeHolder(OpaqueType::get()); + CHECK_FOR_ERROR + ; + break;} +case 127: +#line 1310 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType); + CHECK_FOR_ERROR + ; + break;} +case 128: +#line 1314 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Pointer type? + if (*yyvsp[-1].TypeVal == Type::LabelTy) + GEN_ERROR("Cannot form a pointer to a basic block"); + yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal))); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 129: +#line 1321 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Named types are also simple types... + const Type* tmp = getTypeVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.TypeVal = new PATypeHolder(tmp); + ; + break;} +case 130: +#line 1326 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Type UpReference + if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_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 = new PATypeHolder(OT); + UR_OUT("New Upreference!\n"); + CHECK_FOR_ERROR + ; + break;} +case 131: +#line 1334 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + std::vector<const Type*> Params; + ParamAttrsVector Attrs; + if (yyvsp[0].ParamAttrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs; + Attrs.push_back(X); + } + unsigned index = 1; + TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end(); + for (; I != E; ++I, ++index) { + const Type *Ty = I->Ty->get(); + Params.push_back(Ty); + if (Ty != Type::VoidTy) + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; + Attrs.push_back(X); + } + } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = ParamAttrsList::get(Attrs); + FunctionType *FT = FunctionType::get(*yyvsp[-4].TypeVal, Params, isVarArg, ActualAttrs); + delete yyvsp[-2].TypeWithAttrsList; // Delete the argument list + delete yyvsp[-4].TypeVal; // Delete the return type handle + yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); + CHECK_FOR_ERROR + ; + break;} +case 132: +#line 1364 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + std::vector<const Type*> Params; + ParamAttrsVector Attrs; + if (yyvsp[0].ParamAttrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = 0; X.attrs = yyvsp[0].ParamAttrs; + Attrs.push_back(X); + } + TypeWithAttrsList::iterator I = yyvsp[-2].TypeWithAttrsList->begin(), E = yyvsp[-2].TypeWithAttrsList->end(); + unsigned index = 1; + for ( ; I != E; ++I, ++index) { + const Type* Ty = I->Ty->get(); + Params.push_back(Ty); + if (Ty != Type::VoidTy) + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs; + Attrs.push_back(X); + } + } + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + ParamAttrsList *ActualAttrs = 0; + if (!Attrs.empty()) + ActualAttrs = ParamAttrsList::get(Attrs); + + FunctionType *FT = FunctionType::get(yyvsp[-4].PrimType, Params, isVarArg, ActualAttrs); + delete yyvsp[-2].TypeWithAttrsList; // Delete the argument list + yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT)); + CHECK_FOR_ERROR + ; + break;} +case 133: +#line 1395 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Sized array type? + yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val))); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 134: +#line 1400 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Vector type? + const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get(); + if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val) + GEN_ERROR("Unsigned result not equal to signed result"); + if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger()) + GEN_ERROR("Element type of a VectorType must be primitive"); + if (!isPowerOf2_32(yyvsp[-3].UInt64Val)) + GEN_ERROR("Vector length should be a power of 2"); + yyval.TypeVal = new PATypeHolder(HandleUpRefs(VectorType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val))); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 135: +#line 1412 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Structure type? + std::vector<const Type*> Elements; + for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-1].TypeList->begin(), + E = yyvsp[-1].TypeList->end(); I != E; ++I) + Elements.push_back(*I); + + yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements))); + delete yyvsp[-1].TypeList; + CHECK_FOR_ERROR + ; + break;} +case 136: +#line 1422 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Empty structure type? + yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>())); + CHECK_FOR_ERROR + ; + break;} +case 137: +#line 1426 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + std::vector<const Type*> Elements; + for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-2].TypeList->begin(), + E = yyvsp[-2].TypeList->end(); I != E; ++I) + Elements.push_back(*I); + + yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true))); + delete yyvsp[-2].TypeList; + CHECK_FOR_ERROR + ; + break;} +case 138: +#line 1436 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Empty structure type? + yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>(), true)); + CHECK_FOR_ERROR + ; + break;} +case 139: +#line 1443 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal; + yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs; + ; + break;} +case 140: +#line 1450 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription()); + if (!(*yyvsp[0].TypeVal)->isFirstClassType()) + GEN_ERROR("LLVM functions cannot return aggregate types"); + yyval.TypeVal = yyvsp[0].TypeVal; + ; + break;} +case 141: +#line 1457 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeVal = new PATypeHolder(Type::VoidTy); + ; + break;} +case 142: +#line 1462 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeWithAttrsList = new TypeWithAttrsList(); + yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs); + CHECK_FOR_ERROR + ; + break;} +case 143: +#line 1467 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs); + CHECK_FOR_ERROR + ; + break;} +case 145: +#line 1475 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + yyval.TypeWithAttrsList->push_back(TWA); + CHECK_FOR_ERROR + ; + break;} +case 146: +#line 1482 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeWithAttrsList = new TypeWithAttrsList; + TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + yyval.TypeWithAttrsList->push_back(TWA); + CHECK_FOR_ERROR + ; + break;} +case 147: +#line 1489 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeWithAttrsList = new TypeWithAttrsList(); + CHECK_FOR_ERROR + ; + break;} +case 148: +#line 1497 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TypeList = new std::list<PATypeHolder>(); + yyval.TypeList->push_back(*yyvsp[0].TypeVal); + delete yyvsp[0].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 149: +#line 1503 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal); + delete yyvsp[0].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 150: +#line 1515 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Nonempty unsized arr + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-3].TypeVal->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*yyvsp[-3].TypeVal)->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()) + GEN_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! + for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) { + if (ETy != (*yyvsp[-1].ConstVector)[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'."); + } + + yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector); + delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector; + CHECK_FOR_ERROR + ; + break;} +case 151: +#line 1543 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*yyvsp[-2].TypeVal)->getDescription() + "'"); + + int NumElements = ATy->getNumElements(); + if (NumElements != -1 && NumElements != 0) + GEN_ERROR("Type mismatch: constant sized array initialized with 0" + " arguments, but has size of " + itostr(NumElements) +""); + yyval.ConstVal = ConstantArray::get(ATy, std::vector<Constant*>()); + delete yyvsp[-2].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 152: +#line 1559 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*yyvsp[-2].TypeVal)->getDescription() + "'"); + + int NumElements = ATy->getNumElements(); + const Type *ETy = ATy->getElementType(); + if (NumElements != -1 && NumElements != int(yyvsp[0].StrVal->length())) + GEN_ERROR("Can't build string constant of size " + + itostr((int)(yyvsp[0].StrVal->length())) + + " when array has size " + itostr(NumElements) + ""); + std::vector<Constant*> Vals; + if (ETy == Type::Int8Ty) { + for (unsigned i = 0; i < yyvsp[0].StrVal->length(); ++i) + Vals.push_back(ConstantInt::get(ETy, (*yyvsp[0].StrVal)[i])); + } else { + delete yyvsp[0].StrVal; + GEN_ERROR("Cannot build string arrays of non byte sized elements"); + } + delete yyvsp[0].StrVal; + yyval.ConstVal = ConstantArray::get(ATy, Vals); + delete yyvsp[-2].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 153: +#line 1586 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Nonempty unsized arr + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + const VectorType *PTy = dyn_cast<VectorType>(yyvsp[-3].TypeVal->get()); + if (PTy == 0) + GEN_ERROR("Cannot make packed constant with type: '" + + (*yyvsp[-3].TypeVal)->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()) + GEN_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! + for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) { + if (ETy != (*yyvsp[-1].ConstVector)[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'."); + } + + yyval.ConstVal = ConstantVector::get(PTy, *yyvsp[-1].ConstVector); + delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector; + CHECK_FOR_ERROR + ; + break;} +case 154: +#line 1614 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + const StructType *STy = dyn_cast<StructType>(yyvsp[-3].TypeVal->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*yyvsp[-3].TypeVal)->getDescription() + "'"); + + if (yyvsp[-1].ConstVector->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + for (unsigned i = 0, e = yyvsp[-1].ConstVector->size(); i != e; ++i) + if ((*yyvsp[-1].ConstVector)[i]->getType() != STy->getElementType(i)) + GEN_ERROR("Expected type '" + + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + + " of structure initializer"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); + + yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector); + delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector; + CHECK_FOR_ERROR + ; + break;} +case 155: +#line 1640 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + const StructType *STy = dyn_cast<StructType>(yyvsp[-2].TypeVal->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*yyvsp[-2].TypeVal)->getDescription() + "'"); + + if (STy->getNumContainedTypes() != 0) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); + + yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>()); + delete yyvsp[-2].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 156: +#line 1660 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + const StructType *STy = dyn_cast<StructType>(yyvsp[-5].TypeVal->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*yyvsp[-5].TypeVal)->getDescription() + "'"); + + if (yyvsp[-2].ConstVector->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + for (unsigned i = 0, e = yyvsp[-2].ConstVector->size(); i != e; ++i) + if ((*yyvsp[-2].ConstVector)[i]->getType() != STy->getElementType(i)) + GEN_ERROR("Expected type '" + + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + + " of structure initializer"); + + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); + + yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector); + delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector; + CHECK_FOR_ERROR + ; + break;} +case 157: +#line 1686 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription()); + const StructType *STy = dyn_cast<StructType>(yyvsp[-4].TypeVal->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*yyvsp[-4].TypeVal)->getDescription() + "'"); + + if (STy->getNumContainedTypes() != 0) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); + + yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>()); + delete yyvsp[-4].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 158: +#line 1706 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + const PointerType *PTy = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get()); + if (PTy == 0) + GEN_ERROR("Cannot make null pointer constant with type: '" + + (*yyvsp[-1].TypeVal)->getDescription() + "'"); + + yyval.ConstVal = ConstantPointerNull::get(PTy); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 159: +#line 1718 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get()); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 160: +#line 1725 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + const PointerType *Ty = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get()); + if (Ty == 0) + GEN_ERROR("Global const reference must be a pointer type"); + + // ConstExprs can exist in the body of a function, thus creating + // GlobalValues whenever they refer to a variable. Because we are in + // the context of a function, getExistingVal 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 + // getExistingVal that we are at global scope here. + // + Function *SavedCurFn = CurFun.CurrentFunction; + CurFun.CurrentFunction = 0; + + Value *V = getExistingVal(Ty, yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + + 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::GlobalName) + Name = yyvsp[0].ValIDVal.getName(); + else if (yyvsp[0].ValIDVal.Type != ValID::GlobalID) + GEN_ERROR("Invalid reference to global"); + + // Create the forward referenced global. + GlobalValue *GV; + if (const FunctionType *FTy = + dyn_cast<FunctionType>(PT->getElementType())) { + GV = new Function(FTy, GlobalValue::ExternalWeakLinkage, Name, + CurModule.CurrentModule); + } else { + GV = new GlobalVariable(PT->getElementType(), false, + GlobalValue::ExternalWeakLinkage, 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 = cast<GlobalValue>(V); + delete yyvsp[-1].TypeVal; // Free the type handle + CHECK_FOR_ERROR + ; + break;} +case 161: +#line 1791 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType()) + GEN_ERROR("Mismatched types for constant expression: " + + (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription()); + yyval.ConstVal = yyvsp[0].ConstVal; + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 162: +#line 1801 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + const Type *Ty = yyvsp[-1].TypeVal->get(); + if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty)) + GEN_ERROR("Cannot create a null initialized value of this type"); + yyval.ConstVal = Constant::getNullValue(Ty); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 163: +#line 1811 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // integral constants + if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val)) + GEN_ERROR("Constant value doesn't fit in type"); + yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val, true); + CHECK_FOR_ERROR + ; + break;} +case 164: +#line 1817 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // arbitrary precision integer constants + uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth(); + if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + yyvsp[0].APIntVal->sextOrTrunc(BitWidth); + yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal); + delete yyvsp[0].APIntVal; + CHECK_FOR_ERROR + ; + break;} +case 165: +#line 1827 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // integral constants + if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val)) + GEN_ERROR("Constant value doesn't fit in type"); + yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val, false); + CHECK_FOR_ERROR + ; + break;} +case 166: +#line 1833 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // arbitrary precision integer constants + uint32_t BitWidth = cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth(); + if (yyvsp[0].APIntVal->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + yyvsp[0].APIntVal->zextOrTrunc(BitWidth); + yyval.ConstVal = ConstantInt::get(*yyvsp[0].APIntVal); + delete yyvsp[0].APIntVal; + CHECK_FOR_ERROR + ; + break;} +case 167: +#line 1843 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Boolean constants + assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?"); + yyval.ConstVal = ConstantInt::getTrue(); + CHECK_FOR_ERROR + ; + break;} +case 168: +#line 1848 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Boolean constants + assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?"); + yyval.ConstVal = ConstantInt::getFalse(); + CHECK_FOR_ERROR + ; + break;} +case 169: +#line 1853 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Float & Double constants + if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal)) + GEN_ERROR("Floating point constant invalid for type"); + yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal); + CHECK_FOR_ERROR + ; + break;} +case 170: +#line 1861 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + Constant *Val = yyvsp[-3].ConstVal; + const Type *DestTy = yyvsp[-1].TypeVal->get(); + if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy); + delete yyvsp[-1].TypeVal; + ; + break;} +case 171: +#line 1873 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!isa<PointerType>(yyvsp[-2].ConstVal->getType())) + GEN_ERROR("GetElementPtr requires a pointer operand"); + + const Type *IdxTy = + GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), &(*yyvsp[-1].ValueList)[0], yyvsp[-1].ValueList->size(), + true); + if (!IdxTy) + GEN_ERROR("Index list invalid for constant getelementptr"); + + SmallVector<Constant*, 8> IdxVec; + for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i) + if (Constant *C = dyn_cast<Constant>((*yyvsp[-1].ValueList)[i])) + IdxVec.push_back(C); + else + GEN_ERROR("Indices to constant getelementptr must be constants"); + + delete yyvsp[-1].ValueList; + + yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size()); + CHECK_FOR_ERROR + ; + break;} +case 172: +#line 1895 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty) + GEN_ERROR("Select condition must be of boolean type"); + if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType()) + GEN_ERROR("Select operand types must match"); + yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 173: +#line 1903 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType()) + GEN_ERROR("Binary operator types must match"); + CHECK_FOR_ERROR; + yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + ; + break;} +case 174: +#line 1909 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType()) + GEN_ERROR("Logical operator types must match"); + if (!yyvsp[-3].ConstVal->getType()->isInteger()) { + if (Instruction::isShift(yyvsp[-5].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].ConstVal->getType()) || + !cast<VectorType>(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); + } + yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 175: +#line 1920 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType()) + GEN_ERROR("icmp operand types must match"); + yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + ; + break;} +case 176: +#line 1925 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType()) + GEN_ERROR("fcmp operand types must match"); + yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + ; + break;} +case 177: +#line 1930 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal)) + GEN_ERROR("Invalid extractelement operands"); + yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 178: +#line 1936 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal)) + GEN_ERROR("Invalid insertelement operands"); + yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 179: +#line 1942 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal)) + GEN_ERROR("Invalid shufflevector operands"); + yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 180: +#line 1951 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 181: +#line 1955 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ConstVector = new std::vector<Constant*>(); + yyval.ConstVector->push_back(yyvsp[0].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 182: +#line 1963 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.BoolVal = false; ; + break;} +case 183: +#line 1963 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.BoolVal = true; ; + break;} +case 184: +#line 1966 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.BoolVal = true; ; + break;} +case 185: +#line 1966 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.BoolVal = false; ; + break;} +case 186: +#line 1969 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + const Type* VTy = yyvsp[-1].TypeVal->get(); + Value *V = getVal(VTy, yyvsp[0].ValIDVal); + GlobalValue* Aliasee = dyn_cast<GlobalValue>(V); + if (!Aliasee) + GEN_ERROR("Aliases can be created only to global values"); + + yyval.ConstVal = Aliasee; + CHECK_FOR_ERROR + delete yyvsp[-1].TypeVal; + ; + break;} +case 187: +#line 1980 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + Constant *Val = yyvsp[-3].ConstVal; + const Type *DestTy = yyvsp[-1].TypeVal->get(); + if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + + yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy); + CHECK_FOR_ERROR + delete yyvsp[-1].TypeVal; + ; + break;} +case 188: +#line 2001 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ModuleVal = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + ; + break;} +case 189: +#line 2006 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ModuleVal = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + ; + break;} +case 192: +#line 2019 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ CurFun.isDeclare = false; ; + break;} +case 193: +#line 2019 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurFun.FunctionDone(); + CHECK_FOR_ERROR + ; + break;} +case 194: +#line 2023 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ CurFun.isDeclare = true; ; + break;} +case 195: +#line 2023 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CHECK_FOR_ERROR + ; + break;} +case 196: +#line 2026 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CHECK_FOR_ERROR + ; + break;} +case 197: +#line 2029 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription()); + // 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); + + if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) { + CHECK_FOR_ERROR + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back(*yyvsp[0].TypeVal); + } + + delete yyvsp[0].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 198: +#line 2053 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType); + + if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) { + CHECK_FOR_ERROR + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back(yyvsp[0].PrimType); + } + CHECK_FOR_ERROR + ; + break;} +case 199: +#line 2064 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + /* "Externally Visible" Linkage */ + if (yyvsp[0].ConstVal == 0) + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, GlobalValue::ExternalLinkage, + yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal); + CHECK_FOR_ERROR + ; + break;} +case 200: +#line 2071 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurGV = 0; + ; + break;} +case 201: +#line 2075 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[0].ConstVal == 0) + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal, yyvsp[-2].BoolVal); + CHECK_FOR_ERROR + ; + break;} +case 202: +#line 2080 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurGV = 0; + ; + break;} +case 203: +#line 2084 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription()); + CurGV = ParseGlobalVariable(yyvsp[-5].StrVal, yyvsp[-4].Linkage, yyvsp[-3].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0, yyvsp[-2].BoolVal); + CHECK_FOR_ERROR + delete yyvsp[0].TypeVal; + ; + break;} +case 204: +#line 2090 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurGV = 0; + CHECK_FOR_ERROR + ; + break;} +case 205: +#line 2094 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + std::string Name; + if (yyvsp[-4].StrVal) { + Name = *yyvsp[-4].StrVal; + delete yyvsp[-4].StrVal; + } + if (Name.empty()) + GEN_ERROR("Alias name cannot be empty"); + + Constant* Aliasee = yyvsp[0].ConstVal; + if (Aliasee == 0) + GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name); + + GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), yyvsp[-1].Linkage, Name, Aliasee, + CurModule.CurrentModule); + GA->setVisibility(yyvsp[-3].Visibility); + InsertValue(GA, CurModule.Values); + CHECK_FOR_ERROR + ; + break;} +case 206: +#line 2113 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CHECK_FOR_ERROR + ; + break;} +case 207: +#line 2116 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CHECK_FOR_ERROR + ; + break;} +case 208: +#line 2122 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); + if (AsmSoFar.empty()) + CurModule.CurrentModule->setModuleInlineAsm(*yyvsp[0].StrVal); + else + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR +; + break;} +case 209: +#line 2132 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurModule.CurrentModule->setTargetTriple(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + ; + break;} +case 210: +#line 2136 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurModule.CurrentModule->setDataLayout(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + ; + break;} +case 212: +#line 2143 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurModule.CurrentModule->addLibrary(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 213: +#line 2148 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurModule.CurrentModule->addLibrary(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 214: +#line 2153 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CHECK_FOR_ERROR + ; + break;} +case 215: +#line 2162 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + if (*yyvsp[-2].TypeVal == Type::VoidTy) + GEN_ERROR("void typed arguments are invalid"); + ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal; + yyval.ArgList = yyvsp[-4].ArgList; + yyvsp[-4].ArgList->push_back(E); + CHECK_FOR_ERROR + ; + break;} +case 216: +#line 2172 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + if (*yyvsp[-2].TypeVal == Type::VoidTy) + GEN_ERROR("void typed arguments are invalid"); + ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal; + yyval.ArgList = new ArgListType; + yyval.ArgList->push_back(E); + CHECK_FOR_ERROR + ; + break;} +case 217: +#line 2183 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ArgList = yyvsp[0].ArgList; + CHECK_FOR_ERROR + ; + break;} +case 218: +#line 2187 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ArgList = yyvsp[-2].ArgList; + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = ParamAttr::None; + yyval.ArgList->push_back(E); + CHECK_FOR_ERROR + ; + break;} +case 219: +#line 2196 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ArgList = new ArgListType; + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = ParamAttr::None; + yyval.ArgList->push_back(E); + CHECK_FOR_ERROR + ; + break;} +case 220: +#line 2205 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ArgList = 0; + CHECK_FOR_ERROR + ; + break;} +case 221: +#line 2211 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + std::string FunctionName(*yyvsp[-6].StrVal); + delete yyvsp[-6].StrVal; // Free strdup'd memory! + + // Check the function result for abstractness if this is a define. We should + // have no abstract types at this point + if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(yyvsp[-7].TypeVal)) + GEN_ERROR("Reference to abstract result: "+ yyvsp[-7].TypeVal->get()->getDescription()); + + std::vector<const Type*> ParamTypeList; + ParamAttrsVector Attrs; + if (yyvsp[-2].ParamAttrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = yyvsp[-2].ParamAttrs; + Attrs.push_back(PAWI); + } + if (yyvsp[-4].ArgList) { // If there are arguments... + unsigned index = 1; + for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I, ++index) { + const Type* Ty = I->Ty->get(); + if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty)) + GEN_ERROR("Reference to abstract argument: " + Ty->getDescription()); + ParamTypeList.push_back(Ty); + if (Ty != Type::VoidTy) + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } + } + } + + bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; + if (isVarArg) ParamTypeList.pop_back(); + + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + + FunctionType *FT = FunctionType::get(*yyvsp[-7].TypeVal, ParamTypeList, isVarArg, PAL); + const PointerType *PFT = PointerType::get(FT); + delete yyvsp[-7].TypeVal; + + ValID ID; + if (!FunctionName.empty()) { + ID = ValID::createGlobalName((char*)FunctionName.c_str()); + } else { + ID = ValID::createGlobalID(CurModule.Values.size()); + } + + Function *Fn = 0; + // See if this function was forward referenced. If so, recycle the object. + if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { + // Move the function to the end of the list, from whereever it was + // previously inserted. + Fn = cast<Function>(FWRef); + CurModule.CurrentModule->getFunctionList().remove(Fn); + CurModule.CurrentModule->getFunctionList().push_back(Fn); + } else if (!FunctionName.empty() && // Merge with an earlier prototype? + (Fn = CurModule.CurrentModule->getFunction(FunctionName))) { + if (Fn->getFunctionType() != FT) { + // The existing function doesn't have the same type. This is an overload + // error. + GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); + } else if (!CurFun.isDeclare && !Fn->isDeclaration()) { + // Neither the existing or the current function is a declaration and they + // have the same name and same type. Clearly this is a redefinition. + GEN_ERROR("Redefinition of function '" + FunctionName + "'"); + } if (Fn->isDeclaration()) { + // Make sure to strip off any argument names so we can't get conflicts. + for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); + AI != AE; ++AI) + AI->setName(""); + } + } else { // Not already defined? + Fn = new Function(FT, GlobalValue::ExternalWeakLinkage, FunctionName, + CurModule.CurrentModule); + + InsertValue(Fn, CurModule.Values); + } + + CurFun.FunctionStart(Fn); + + if (CurFun.isDeclare) { + // If we have declaration, always overwrite linkage. This will allow us to + // correctly handle cases, when pointer to function is passed as argument to + // another function. + Fn->setLinkage(CurFun.Linkage); + Fn->setVisibility(CurFun.Visibility); + } + Fn->setCallingConv(yyvsp[-8].UIntVal); + Fn->setAlignment(yyvsp[0].UIntVal); + if (yyvsp[-1].StrVal) { + Fn->setSection(*yyvsp[-1].StrVal); + delete yyvsp[-1].StrVal; + } + + // Add all of the arguments we parsed to the function... + if (yyvsp[-4].ArgList) { // Is null if empty... + if (isVarArg) { // Nuke the last entry + assert(yyvsp[-4].ArgList->back().Ty->get() == Type::VoidTy && yyvsp[-4].ArgList->back().Name == 0 && + "Not a varargs marker!"); + delete yyvsp[-4].ArgList->back().Ty; + yyvsp[-4].ArgList->pop_back(); // Delete the last entry + } + Function::arg_iterator ArgIt = Fn->arg_begin(); + Function::arg_iterator ArgEnd = Fn->arg_end(); + unsigned Idx = 1; + for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); + I != yyvsp[-4].ArgList->end() && ArgIt != ArgEnd; ++I, ++ArgIt) { + delete I->Ty; // Delete the typeholder... + setValueName(ArgIt, I->Name); // Insert arg into symtab... + CHECK_FOR_ERROR + InsertValue(ArgIt); + Idx++; + } + + delete yyvsp[-4].ArgList; // We're now done with the argument list + } + CHECK_FOR_ERROR +; + break;} +case 224: +#line 2333 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.FunctionVal = CurFun.CurrentFunction; + + // Make sure that we keep track of the linkage type even if there was a + // previous "declare". + yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage); + yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility); +; + break;} +case 227: +#line 2344 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.FunctionVal = yyvsp[-1].FunctionVal; + CHECK_FOR_ERROR +; + break;} +case 228: +#line 2349 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage); + CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility); + yyval.FunctionVal = CurFun.CurrentFunction; + CurFun.FunctionDone(); + CHECK_FOR_ERROR + ; + break;} +case 229: +#line 2361 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = false; + CHECK_FOR_ERROR + ; + break;} +case 230: +#line 2365 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = true; + CHECK_FOR_ERROR + ; + break;} +case 231: +#line 2370 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // A reference to a direct constant + yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val); + CHECK_FOR_ERROR + ; + break;} +case 232: +#line 2374 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val); + CHECK_FOR_ERROR + ; + break;} +case 233: +#line 2378 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Perhaps it's an FP constant? + yyval.ValIDVal = ValID::create(yyvsp[0].FPVal); + CHECK_FOR_ERROR + ; + break;} +case 234: +#line 2382 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::create(ConstantInt::getTrue()); + CHECK_FOR_ERROR + ; + break;} +case 235: +#line 2386 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::create(ConstantInt::getFalse()); + CHECK_FOR_ERROR + ; + break;} +case 236: +#line 2390 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::createNull(); + CHECK_FOR_ERROR + ; + break;} +case 237: +#line 2394 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::createUndef(); + CHECK_FOR_ERROR + ; + break;} +case 238: +#line 2398 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // A vector zero constant. + yyval.ValIDVal = ValID::createZeroInit(); + CHECK_FOR_ERROR + ; + break;} +case 239: +#line 2402 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Nonempty unsized packed vector + const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType(); + int NumElements = yyvsp[-1].ConstVector->size(); + + VectorType* pt = VectorType::get(ETy, NumElements); + PATypeHolder* PTy = new PATypeHolder( + HandleUpRefs( + VectorType::get( + ETy, + NumElements) + ) + ); + + // Verify all elements are correct type! + for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) { + if (ETy != (*yyvsp[-1].ConstVector)[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '" + + (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'."); + } + + yyval.ValIDVal = ValID::create(ConstantVector::get(pt, *yyvsp[-1].ConstVector)); + delete PTy; delete yyvsp[-1].ConstVector; + CHECK_FOR_ERROR + ; + break;} +case 240: +#line 2427 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal); + CHECK_FOR_ERROR + ; + break;} +case 241: +#line 2431 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::createInlineAsm(*yyvsp[-2].StrVal, *yyvsp[0].StrVal, yyvsp[-3].BoolVal); + delete yyvsp[-2].StrVal; + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 242: +#line 2441 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Is it an integer reference...? + yyval.ValIDVal = ValID::createLocalID(yyvsp[0].UIntVal); + CHECK_FOR_ERROR + ; + break;} +case 243: +#line 2445 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValIDVal = ValID::createGlobalID(yyvsp[0].UIntVal); + CHECK_FOR_ERROR + ; + break;} +case 244: +#line 2449 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Is it a named reference...? + yyval.ValIDVal = ValID::createLocalName(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 245: +#line 2454 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Is it a named reference...? + yyval.ValIDVal = ValID::createGlobalName(*yyvsp[0].StrVal); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + ; + break;} +case 248: +#line 2467 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 249: +#line 2476 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.FunctionVal = yyvsp[-1].FunctionVal; + CHECK_FOR_ERROR + ; + break;} +case 250: +#line 2480 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Do not allow functions with 0 basic blocks + yyval.FunctionVal = yyvsp[-1].FunctionVal; + CHECK_FOR_ERROR + ; + break;} +case 251: +#line 2489 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal); + CHECK_FOR_ERROR + InsertValue(yyvsp[0].TermInstVal); + yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal); + yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal; + CHECK_FOR_ERROR + ; + break;} +case 252: +#line 2498 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (CastInst *CI1 = dyn_cast<CastInst>(yyvsp[0].InstVal)) + if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0))) + if (CI2->getParent() == 0) + yyvsp[-1].BasicBlockVal->getInstList().push_back(CI2); + yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal); + yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal; + CHECK_FOR_ERROR + ; + break;} +case 253: +#line 2507 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Empty space between instruction lists + yyval.BasicBlockVal = defineBBVal(ValID::createLocalID(CurFun.NextValNum)); + CHECK_FOR_ERROR + ; + break;} +case 254: +#line 2511 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Labelled (named) basic block + yyval.BasicBlockVal = defineBBVal(ValID::createLocalName(*yyvsp[0].StrVal)); + delete yyvsp[0].StrVal; + CHECK_FOR_ERROR + + ; + break;} +case 255: +#line 2518 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Return with a result... + yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 256: +#line 2522 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Return with no result... + yyval.TermInstVal = new ReturnInst(); + CHECK_FOR_ERROR + ; + break;} +case 257: +#line 2526 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Unconditional Branch... + BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.TermInstVal = new BranchInst(tmpBB); + ; + break;} +case 258: +#line 2531 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + assert(cast<IntegerType>(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?"); + BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal); + CHECK_FOR_ERROR + BasicBlock* tmpBBB = getBBVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal); + CHECK_FOR_ERROR + yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal); + ; + break;} +case 259: +#line 2541 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal); + CHECK_FOR_ERROR + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, yyvsp[-1].JumpTable->size()); + yyval.TermInstVal = S; + + 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 + GEN_ERROR("Switch case is constant, but not a simple integer"); + } + delete yyvsp[-1].JumpTable; + CHECK_FOR_ERROR + ; + break;} +case 260: +#line 2560 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal); + CHECK_FOR_ERROR + SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0); + yyval.TermInstVal = S; + CHECK_FOR_ERROR + ; + break;} +case 261: +#line 2570 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; + if (!(PFTy = dyn_cast<PointerType>(yyvsp[-11].TypeVal->get())) || + !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector<const Type*> ParamTypes; + ParamAttrsVector Attrs; + if (yyvsp[-6].ParamAttrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = yyvsp[-6].ParamAttrs; + Attrs.push_back(PAWI); + } + ValueRefList::iterator I = yyvsp[-8].ValueRefList->begin(), E = yyvsp[-8].ValueRefList->end(); + unsigned index = 1; + for (; I != E; ++I, ++index) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } + } + + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + Ty = FunctionType::get(yyvsp[-11].TypeVal->get(), ParamTypes, false, PAL); + PFTy = PointerType::get(Ty); + } + + delete yyvsp[-11].TypeVal; + + Value *V = getVal(PFTy, yyvsp[-10].ValIDVal); // Get the function we're calling... + CHECK_FOR_ERROR + BasicBlock *Normal = getBBVal(yyvsp[-3].ValIDVal); + CHECK_FOR_ERROR + BasicBlock *Except = getBBVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + + // Check the arguments + ValueList Args; + if (yyvsp[-8].ValueRefList->empty()) { // Has no arguments? + // Make sure no arguments is a good thing! + if (Ty->getNumParams() != 0) + GEN_ERROR("No arguments passed to a function that " + "expects arguments"); + } 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(); + ValueRefList::iterator ArgI = yyvsp[-8].ValueRefList->begin(), ArgE = yyvsp[-8].ValueRefList->end(); + + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + } + + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI) + Args.push_back(ArgI->Val); // push the remaining varargs + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); + } + + // Create the InvokeInst + InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size()); + II->setCallingConv(yyvsp[-12].UIntVal); + yyval.TermInstVal = II; + delete yyvsp[-8].ValueRefList; + CHECK_FOR_ERROR + ; + break;} +case 262: +#line 2649 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TermInstVal = new UnwindInst(); + CHECK_FOR_ERROR + ; + break;} +case 263: +#line 2653 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.TermInstVal = new UnreachableInst(); + CHECK_FOR_ERROR + ; + break;} +case 264: +#line 2660 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.JumpTable = yyvsp[-5].JumpTable; + Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal)); + CHECK_FOR_ERROR + if (V == 0) + GEN_ERROR("May only switch on a constant pool value"); + + BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.JumpTable->push_back(std::make_pair(V, tmpBB)); + ; + break;} +case 265: +#line 2671 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.JumpTable = new std::vector<std::pair<Constant*, BasicBlock*> >(); + Constant *V = cast<Constant>(getExistingVal(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal)); + CHECK_FOR_ERROR + + if (V == 0) + GEN_ERROR("May only switch on a constant pool value"); + + BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.JumpTable->push_back(std::make_pair(V, tmpBB)); + ; + break;} +case 266: +#line 2684 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + // Is this definition named?? if so, assign the name... + setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal); + CHECK_FOR_ERROR + InsertValue(yyvsp[0].InstVal); + yyval.InstVal = yyvsp[0].InstVal; + CHECK_FOR_ERROR + ; + break;} +case 267: +#line 2694 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ // Used for PHI nodes + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription()); + yyval.PHIList = new std::list<std::pair<Value*, BasicBlock*> >(); + Value* tmpVal = getVal(*yyvsp[-5].TypeVal, yyvsp[-3].ValIDVal); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB)); + delete yyvsp[-5].TypeVal; + ; + break;} +case 268: +#line 2705 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.PHIList = yyvsp[-6].PHIList; + Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB)); + ; + break;} +case 269: +#line 2715 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + // Used for call and invoke instructions + yyval.ValueRefList = new ValueRefList(); + ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal); + yyval.ValueRefList->push_back(E); + delete yyvsp[-2].TypeVal; + ; + break;} +case 270: +#line 2724 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + yyval.ValueRefList = yyvsp[-4].ValueRefList; + ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal); + yyval.ValueRefList->push_back(E); + delete yyvsp[-2].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 271: +#line 2733 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ValueRefList = new ValueRefList(); ; + break;} +case 272: +#line 2736 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ yyval.ValueList = new std::vector<Value*>(); ; + break;} +case 273: +#line 2737 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.ValueList = yyvsp[-2].ValueList; + yyval.ValueList->push_back(yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 274: +#line 2744 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = true; + CHECK_FOR_ERROR + ; + break;} +case 275: +#line 2748 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = false; + CHECK_FOR_ERROR + ; + break;} +case 276: +#line 2753 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() && + !isa<VectorType>((*yyvsp[-3].TypeVal).get())) + GEN_ERROR( + "Arithmetic operator requires integer, FP, or packed operands"); + if (isa<VectorType>((*yyvsp[-3].TypeVal).get()) && + (yyvsp[-4].BinaryOpVal == Instruction::URem || + yyvsp[-4].BinaryOpVal == Instruction::SRem || + yyvsp[-4].BinaryOpVal == Instruction::FRem)) + GEN_ERROR("Remainder not supported on vector types"); + Value* val1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); + CHECK_FOR_ERROR + Value* val2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, val1, val2); + if (yyval.InstVal == 0) + GEN_ERROR("binary operator returned null"); + delete yyvsp[-3].TypeVal; + ; + break;} +case 277: +#line 2774 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + if (!(*yyvsp[-3].TypeVal)->isInteger()) { + if (Instruction::isShift(yyvsp[-4].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].TypeVal->get()) || + !cast<VectorType>(yyvsp[-3].TypeVal->get())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); + } + Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, tmpVal1, tmpVal2); + if (yyval.InstVal == 0) + GEN_ERROR("binary operator returned null"); + delete yyvsp[-3].TypeVal; + ; + break;} +case 278: +#line 2791 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + if (isa<VectorType>((*yyvsp[-3].TypeVal).get())) + GEN_ERROR("Vector types not supported by icmp instruction"); + Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].IPredicate, tmpVal1, tmpVal2); + if (yyval.InstVal == 0) + GEN_ERROR("icmp operator returned null"); + delete yyvsp[-3].TypeVal; + ; + break;} +case 279: +#line 2805 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription()); + if (isa<VectorType>((*yyvsp[-3].TypeVal).get())) + GEN_ERROR("Vector types not supported by fcmp instruction"); + Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].FPredicate, tmpVal1, tmpVal2); + if (yyval.InstVal == 0) + GEN_ERROR("fcmp operator returned null"); + delete yyvsp[-3].TypeVal; + ; + break;} +case 280: +#line 2819 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription()); + Value* Val = yyvsp[-2].ValueVal; + const Type* DestTy = yyvsp[0].TypeVal->get(); + if (!CastInst::castIsValid(yyvsp[-3].CastOpVal, Val, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy); + delete yyvsp[0].TypeVal; + ; + break;} +case 281: +#line 2831 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty) + GEN_ERROR("select condition must be boolean"); + if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType()) + GEN_ERROR("select value types should match"); + yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 282: +#line 2839 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription()); + yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal); + delete yyvsp[0].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 283: +#line 2846 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal)) + GEN_ERROR("Invalid extractelement operands"); + yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 284: +#line 2852 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal)) + GEN_ERROR("Invalid insertelement operands"); + yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 285: +#line 2858 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal)) + GEN_ERROR("Invalid shufflevector operands"); + yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 286: +#line 2864 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + const Type *Ty = yyvsp[0].PHIList->front().first->getType(); + if (!Ty->isFirstClassType()) + GEN_ERROR("PHI node operands must be of first class type"); + yyval.InstVal = new PHINode(Ty); + ((PHINode*)yyval.InstVal)->reserveOperandSpace(yyvsp[0].PHIList->size()); + while (yyvsp[0].PHIList->begin() != yyvsp[0].PHIList->end()) { + if (yyvsp[0].PHIList->front().first->getType() != Ty) + GEN_ERROR("All elements of a PHI node must be of the same type"); + cast<PHINode>(yyval.InstVal)->addIncoming(yyvsp[0].PHIList->front().first, yyvsp[0].PHIList->front().second); + yyvsp[0].PHIList->pop_front(); + } + delete yyvsp[0].PHIList; // Free the list... + CHECK_FOR_ERROR + ; + break;} +case 287: +#line 2880 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; + if (!(PFTy = dyn_cast<PointerType>(yyvsp[-5].TypeVal->get())) || + !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector<const Type*> ParamTypes; + ParamAttrsVector Attrs; + if (yyvsp[0].ParamAttrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = yyvsp[0].ParamAttrs; + Attrs.push_back(PAWI); + } + unsigned index = 1; + ValueRefList::iterator I = yyvsp[-2].ValueRefList->begin(), E = yyvsp[-2].ValueRefList->end(); + for (; I != E; ++I, ++index) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + if (I->Attrs != ParamAttr::None) { + ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs; + Attrs.push_back(PAWI); + } + } + + ParamAttrsList *PAL = 0; + if (!Attrs.empty()) + PAL = ParamAttrsList::get(Attrs); + + Ty = FunctionType::get(yyvsp[-5].TypeVal->get(), ParamTypes, false, PAL); + PFTy = PointerType::get(Ty); + } + + Value *V = getVal(PFTy, yyvsp[-4].ValIDVal); // Get the function we're calling... + CHECK_FOR_ERROR + + // Check for call to invalid intrinsic to avoid crashing later. + if (Function *theF = dyn_cast<Function>(V)) { + if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) && + (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) && + !theF->getIntrinsicID(true)) + GEN_ERROR("Call to invalid LLVM intrinsic function '" + + theF->getName() + "'"); + } + + // Check the arguments + ValueList Args; + if (yyvsp[-2].ValueRefList->empty()) { // Has no arguments? + // Make sure no arguments is a good thing! + if (Ty->getNumParams() != 0) + GEN_ERROR("No arguments passed to a function that " + "expects arguments"); + } 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(); + ValueRefList::iterator ArgI = yyvsp[-2].ValueRefList->begin(), ArgE = yyvsp[-2].ValueRefList->end(); + + for (; ArgI != ArgE && I != E; ++ArgI, ++I) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + } + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI) + Args.push_back(ArgI->Val); // push the remaining varargs + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); + } + // Create the call node + CallInst *CI = new CallInst(V, &Args[0], Args.size()); + CI->setTailCall(yyvsp[-7].BoolVal); + CI->setCallingConv(yyvsp[-6].UIntVal); + yyval.InstVal = CI; + delete yyvsp[-2].ValueRefList; + delete yyvsp[-5].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 288: +#line 2964 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.InstVal = yyvsp[0].InstVal; + CHECK_FOR_ERROR + ; + break;} +case 289: +#line 2969 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = true; + CHECK_FOR_ERROR + ; + break;} +case 290: +#line 2973 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + yyval.BoolVal = false; + CHECK_FOR_ERROR + ; + break;} +case 291: +#line 2980 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 292: +#line 2987 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription()); + Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal); + delete yyvsp[-4].TypeVal; + ; + break;} +case 293: +#line 2995 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription()); + yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal); + delete yyvsp[-1].TypeVal; + CHECK_FOR_ERROR + ; + break;} +case 294: +#line 3002 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription()); + Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal); + delete yyvsp[-4].TypeVal; + ; + break;} +case 295: +#line 3010 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!isa<PointerType>(yyvsp[0].ValueVal->getType())) + GEN_ERROR("Trying to free nonpointer type " + + yyvsp[0].ValueVal->getType()->getDescription() + ""); + yyval.InstVal = new FreeInst(yyvsp[0].ValueVal); + CHECK_FOR_ERROR + ; + break;} +case 296: +#line 3018 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + if (!isa<PointerType>(yyvsp[-2].TypeVal->get())) + GEN_ERROR("Can't load from nonpointer type: " + + (*yyvsp[-2].TypeVal)->getDescription()); + if (!cast<PointerType>(yyvsp[-2].TypeVal->get())->getElementType()->isFirstClassType()) + GEN_ERROR("Can't load from pointer of non-first-class type: " + + (*yyvsp[-2].TypeVal)->getDescription()); + Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-4].BoolVal, yyvsp[0].UIntVal); + delete yyvsp[-2].TypeVal; + ; + break;} +case 297: +#line 3032 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + const PointerType *PT = dyn_cast<PointerType>(yyvsp[-2].TypeVal->get()); + if (!PT) + GEN_ERROR("Can't store to a nonpointer type: " + + (*yyvsp[-2].TypeVal)->getDescription()); + const Type *ElTy = PT->getElementType(); + if (ElTy != yyvsp[-4].ValueVal->getType()) + GEN_ERROR("Can't store '" + yyvsp[-4].ValueVal->getType()->getDescription() + + "' into space of type '" + ElTy->getDescription() + "'"); + + Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = new StoreInst(yyvsp[-4].ValueVal, tmpVal, yyvsp[-6].BoolVal, yyvsp[0].UIntVal); + delete yyvsp[-2].TypeVal; + ; + break;} +case 298: +#line 3049 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +{ + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription()); + if (!isa<PointerType>(yyvsp[-2].TypeVal->get())) + GEN_ERROR("getelementptr insn requires pointer operand"); + + if (!GetElementPtrInst::getIndexedType(*yyvsp[-2].TypeVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size(), true)) + GEN_ERROR("Invalid getelementptr indices for type '" + + (*yyvsp[-2].TypeVal)->getDescription()+ "'"); + Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal); + CHECK_FOR_ERROR + yyval.InstVal = new GetElementPtrInst(tmpVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size()); + delete yyvsp[-2].TypeVal; + delete yyvsp[0].ValueList; + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 3066 "/Volumes/ProjectsDisk/cvs/llvm/lib/AsmParser/llvmAsmParser.y" + + +// common code from the two 'RunVMAsmParser' functions +static Module* RunParser(Module * M) { + + llvmAsmlineno = 1; // Reset the current line number... + CurModule.CurrentModule = M; +#if YYDEBUG + yydebug = Debug; +#endif + + // Check to make sure the parser succeeded + if (yyparse()) { + if (ParserResult) + delete ParserResult; + return 0; + } + + // 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::LocalName) { + GenerateError("Undefined type remains at eof: '"+DID.getName() + "'"); + } else { + GenerateError("Undefined type remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + + // Emit an error if there are any unresolved values left. + if (!CurModule.LateResolveValues.empty()) { + Value *V = CurModule.LateResolveValues.back(); + std::map<Value*, std::pair<ValID, int> >::iterator I = + CurModule.PlaceHolderInfo.find(V); + + if (I != CurModule.PlaceHolderInfo.end()) { + ValID &DID = I->second.first; + if (DID.Type == ValID::LocalName) { + GenerateError("Undefined value remains at eof: "+DID.getName() + "'"); + } else { + GenerateError("Undefined value remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + } + + // Check to make sure that parsing produced a result + if (!ParserResult) + return 0; + + // Reset ParserResult variable while saving its value for the result. + Module *Result = ParserResult; + ParserResult = 0; + + return Result; +} + +void llvm::GenerateError(const std::string &message, int LineNo) { + if (LineNo == -1) LineNo = llvmAsmlineno; + // TODO: column number in exception + if (TheParseError) + TheParseError->setError(CurFilename, message, LineNo); + TriggerError = 1; +} + +int yyerror(const char *ErrorMsg) { + std::string where + = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename) + + ":" + utostr((unsigned) llvmAsmlineno) + ": "; + std::string errMsg = where + "error: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) + errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+ + "'"; + GenerateError(errMsg); + return 0; +} |