1 /* A Bison parser, made by GNU Bison 2.1. */
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
36 /* Identify Bison output. */
40 #define YYBISON_VERSION "2.1"
43 #define YYSKELETON_NAME "yacc.c"
48 /* Using locations. */
49 #define YYLSP_NEEDED 0
51 /* Substitute the variable and function names. */
52 #define yyparse llvmAsmparse
53 #define yylex llvmAsmlex
54 #define yyerror llvmAsmerror
55 #define yylval llvmAsmlval
56 #define yychar llvmAsmchar
57 #define yydebug llvmAsmdebug
58 #define yynerrs llvmAsmnerrs
64 /* Put the tokens into the symbol table, so that GDB and other debuggers
84 ATSTRINGCONSTANT = 275,
85 PCTSTRINGCONSTANT = 276,
86 ZEROINITIALIZER = 277,
125 X86_STDCALLCC_TOK = 316,
126 X86_FASTCALLCC_TOK = 317,
192 EXTRACTELEMENT = 383,
205 #define ESINT64VAL 258
206 #define EUINT64VAL 259
207 #define ESAPINTVAL 260
208 #define EUAPINTVAL 261
209 #define LOCALVAL_ID 262
210 #define GLOBALVAL_ID 263
219 #define GLOBALVAR 272
221 #define STRINGCONSTANT 274
222 #define ATSTRINGCONSTANT 275
223 #define PCTSTRINGCONSTANT 276
224 #define ZEROINITIALIZER 277
236 #define THREAD_LOCAL 289
238 #define DOTDOTDOT 291
244 #define APPENDING 297
245 #define DLLIMPORT 298
246 #define DLLEXPORT 299
247 #define EXTERN_WEAK 300
258 #define SIDEEFFECT 311
261 #define FASTCC_TOK 314
262 #define COLDCC_TOK 315
263 #define X86_STDCALLCC_TOK 316
264 #define X86_FASTCALLCC_TOK 317
265 #define DATALAYOUT 318
271 #define UNREACHABLE 324
314 #define GETELEMENTPTR 367
330 #define EXTRACTELEMENT 383
331 #define INSERTELEMENT 384
332 #define SHUFFLEVECTOR 385
339 #define PROTECTED 392
344 /* Copy the first part of user declarations. */
345 #line 14 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
347 #include "ParserInternals.h"
348 #include "llvm/CallingConv.h"
349 #include "llvm/InlineAsm.h"
350 #include "llvm/Instructions.h"
351 #include "llvm/Module.h"
352 #include "llvm/ValueSymbolTable.h"
353 #include "llvm/Support/GetElementPtrTypeIterator.h"
354 #include "llvm/Support/CommandLine.h"
355 #include "llvm/ADT/SmallVector.h"
356 #include "llvm/ADT/STLExtras.h"
357 #include "llvm/Support/MathExtras.h"
358 #include "llvm/Support/Streams.h"
367 // The following is a gross hack. In order to rid the libAsmParser library of
368 // exceptions, we have to have a way of getting the yyparse function to go into
369 // an error situation. So, whenever we want an error to occur, the GenerateError
370 // function (see bottom of file) sets TriggerError. Then, at the end of each
371 // production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR
372 // (a goto) to put YACC in error state. Furthermore, several calls to
373 // GenerateError are made from inside productions and they must simulate the
374 // previous exception behavior by exiting the production immediately. We have
375 // replaced these with the GEN_ERROR macro which calls GeneratError and then
376 // immediately invokes YYERROR. This would be so much cleaner if it was a
377 // recursive descent parser.
378 static bool TriggerError = false;
379 #define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
380 #define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
382 int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
383 int yylex(); // declaration" of xxx warnings.
387 std::string CurFilename;
390 Debug("debug-yacc", cl::desc("Print yacc debug state changes"),
391 cl::Hidden, cl::init(false));
394 using namespace llvm;
396 static Module *ParserResult;
398 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
399 // relating to upreferences in the input stream.
401 //#define DEBUG_UPREFS 1
403 #define UR_OUT(X) cerr << X
408 #define YYERROR_VERBOSE 1
410 static GlobalVariable *CurGV;
413 // This contains info used when building the body of a function. It is
414 // destroyed when the function is completed.
416 typedef std::vector<Value *> ValueList; // Numbered defs
419 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0);
421 static struct PerModuleInfo {
422 Module *CurrentModule;
423 ValueList Values; // Module level numbered definitions
424 ValueList LateResolveValues;
425 std::vector<PATypeHolder> Types;
426 std::map<ValID, PATypeHolder> LateResolveTypes;
428 /// PlaceHolderInfo - When temporary placeholder objects are created, remember
429 /// how they were referenced and on which line of the input they came from so
430 /// that we can resolve them later and print error messages as appropriate.
431 std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
433 // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
434 // references to global values. Global values may be referenced before they
435 // are defined, and if so, the temporary object that they represent is held
436 // here. This is used for forward references of GlobalValues.
438 typedef std::map<std::pair<const PointerType *,
439 ValID>, GlobalValue*> GlobalRefsType;
440 GlobalRefsType GlobalRefs;
443 // If we could not resolve some functions at function compilation time
444 // (calls to functions before they are defined), resolve them now... Types
445 // are resolved when the constant pool has been completely parsed.
447 ResolveDefinitions(LateResolveValues);
451 // Check to make sure that all global value forward references have been
454 if (!GlobalRefs.empty()) {
455 std::string UndefinedReferences = "Unresolved global references exist:\n";
457 for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
459 UndefinedReferences += " " + I->first.first->getDescription() + " " +
460 I->first.second.getName() + "\n";
462 GenerateError(UndefinedReferences);
466 Values.clear(); // Clear out function local definitions
471 // GetForwardRefForGlobal - Check to see if there is a forward reference
472 // for this global. If so, remove it from the GlobalRefs map and return it.
473 // If not, just return null.
474 GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
475 // Check to see if there is a forward reference to this global variable...
476 // if there is, eliminate it and patch the reference to use the new def'n.
477 GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
478 GlobalValue *Ret = 0;
479 if (I != GlobalRefs.end()) {
486 bool TypeIsUnresolved(PATypeHolder* PATy) {
487 // If it isn't abstract, its resolved
488 const Type* Ty = PATy->get();
489 if (!Ty->isAbstract())
491 // Traverse the type looking for abstract types. If it isn't abstract then
492 // we don't need to traverse that leg of the type.
493 std::vector<const Type*> WorkList, SeenList;
494 WorkList.push_back(Ty);
495 while (!WorkList.empty()) {
496 const Type* Ty = WorkList.back();
497 SeenList.push_back(Ty);
499 if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
500 // Check to see if this is an unresolved type
501 std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
502 std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
503 for ( ; I != E; ++I) {
504 if (I->second.get() == OpTy)
507 } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
508 const Type* TheTy = SeqTy->getElementType();
509 if (TheTy->isAbstract() && TheTy != Ty) {
510 std::vector<const Type*>::iterator I = SeenList.begin(),
516 WorkList.push_back(TheTy);
518 } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
519 for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
520 const Type* TheTy = StrTy->getElementType(i);
521 if (TheTy->isAbstract() && TheTy != Ty) {
522 std::vector<const Type*>::iterator I = SeenList.begin(),
528 WorkList.push_back(TheTy);
537 static struct PerFunctionInfo {
538 Function *CurrentFunction; // Pointer to current function being created
540 ValueList Values; // Keep track of #'d definitions
542 ValueList LateResolveValues;
543 bool isDeclare; // Is this function a forward declararation?
544 GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
545 GlobalValue::VisibilityTypes Visibility;
547 /// BBForwardRefs - When we see forward references to basic blocks, keep
548 /// track of them here.
549 std::map<ValID, BasicBlock*> BBForwardRefs;
551 inline PerFunctionInfo() {
554 Linkage = GlobalValue::ExternalLinkage;
555 Visibility = GlobalValue::DefaultVisibility;
558 inline void FunctionStart(Function *M) {
563 void FunctionDone() {
564 // Any forward referenced blocks left?
565 if (!BBForwardRefs.empty()) {
566 GenerateError("Undefined reference to label " +
567 BBForwardRefs.begin()->second->getName());
571 // Resolve all forward references now.
572 ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
574 Values.clear(); // Clear out function local definitions
575 BBForwardRefs.clear();
578 Linkage = GlobalValue::ExternalLinkage;
579 Visibility = GlobalValue::DefaultVisibility;
581 } CurFun; // Info for the current function...
583 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
586 //===----------------------------------------------------------------------===//
587 // Code to handle definitions of all the types
588 //===----------------------------------------------------------------------===//
590 static void InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
591 // Things that have names or are void typed don't get slot numbers
592 if (V->hasName() || (V->getType() == Type::VoidTy))
595 // In the case of function values, we have to allow for the forward reference
596 // of basic blocks, which are included in the numbering. Consequently, we keep
597 // track of the next insertion location with NextValNum. When a BB gets
598 // inserted, it could change the size of the CurFun.Values vector.
599 if (&ValueTab == &CurFun.Values) {
600 if (ValueTab.size() <= CurFun.NextValNum)
601 ValueTab.resize(CurFun.NextValNum+1);
602 ValueTab[CurFun.NextValNum++] = V;
605 // For all other lists, its okay to just tack it on the back of the vector.
606 ValueTab.push_back(V);
609 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
611 case ValID::LocalID: // Is it a numbered definition?
612 // Module constants occupy the lowest numbered slots...
613 if (D.Num < CurModule.Types.size())
614 return CurModule.Types[D.Num];
616 case ValID::LocalName: // Is it a named definition?
617 if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) {
618 D.destroy(); // Free old strdup'd memory...
623 GenerateError("Internal parser error: Invalid symbol type reference");
627 // If we reached here, we referenced either a symbol that we don't know about
628 // or an id number that hasn't been read yet. We may be referencing something
629 // forward, so just create an entry to be resolved later and get to it...
631 if (DoNotImprovise) return 0; // Do we just want a null to be returned?
634 if (inFunctionScope()) {
635 if (D.Type == ValID::LocalName) {
636 GenerateError("Reference to an undefined type: '" + D.getName() + "'");
639 GenerateError("Reference to an undefined type: #" + utostr(D.Num));
644 std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
645 if (I != CurModule.LateResolveTypes.end())
648 Type *Typ = OpaqueType::get();
649 CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
653 // getExistingVal - Look up the value specified by the provided type and
654 // the provided ValID. If the value exists and has already been defined, return
655 // it. Otherwise return null.
657 static Value *getExistingVal(const Type *Ty, const ValID &D) {
658 if (isa<FunctionType>(Ty)) {
659 GenerateError("Functions are not values and "
660 "must be referenced as pointers");
665 case ValID::LocalID: { // Is it a numbered definition?
666 // Check that the number is within bounds.
667 if (D.Num >= CurFun.Values.size())
669 Value *Result = CurFun.Values[D.Num];
670 if (Ty != Result->getType()) {
671 GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" +
672 Result->getType()->getDescription() + "' does not match "
673 "expected type, '" + Ty->getDescription() + "'");
678 case ValID::GlobalID: { // Is it a numbered definition?
679 if (D.Num >= CurModule.Values.size())
681 Value *Result = CurModule.Values[D.Num];
682 if (Ty != Result->getType()) {
683 GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" +
684 Result->getType()->getDescription() + "' does not match "
685 "expected type, '" + Ty->getDescription() + "'");
691 case ValID::LocalName: { // Is it a named definition?
692 if (!inFunctionScope())
694 ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
695 Value *N = SymTab.lookup(D.getName());
698 if (N->getType() != Ty)
701 D.destroy(); // Free old strdup'd memory...
704 case ValID::GlobalName: { // Is it a named definition?
705 ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
706 Value *N = SymTab.lookup(D.getName());
709 if (N->getType() != Ty)
712 D.destroy(); // Free old strdup'd memory...
716 // Check to make sure that "Ty" is an integral type, and that our
717 // value will fit into the specified type...
718 case ValID::ConstSIntVal: // Is it a constant pool reference??
719 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
720 GenerateError("Signed integral constant '" +
721 itostr(D.ConstPool64) + "' is invalid for type '" +
722 Ty->getDescription() + "'");
725 return ConstantInt::get(Ty, D.ConstPool64, true);
727 case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
728 if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
729 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
730 GenerateError("Integral constant '" + utostr(D.UConstPool64) +
731 "' is invalid or out of range");
733 } else { // This is really a signed reference. Transmogrify.
734 return ConstantInt::get(Ty, D.ConstPool64, true);
737 return ConstantInt::get(Ty, D.UConstPool64);
740 case ValID::ConstFPVal: // Is it a floating point const pool reference?
741 if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) {
742 GenerateError("FP constant invalid for type");
745 return ConstantFP::get(Ty, D.ConstPoolFP);
747 case ValID::ConstNullVal: // Is it a null value?
748 if (!isa<PointerType>(Ty)) {
749 GenerateError("Cannot create a a non pointer null");
752 return ConstantPointerNull::get(cast<PointerType>(Ty));
754 case ValID::ConstUndefVal: // Is it an undef value?
755 return UndefValue::get(Ty);
757 case ValID::ConstZeroVal: // Is it a zero value?
758 return Constant::getNullValue(Ty);
760 case ValID::ConstantVal: // Fully resolved constant?
761 if (D.ConstantValue->getType() != Ty) {
762 GenerateError("Constant expression type different from required type");
765 return D.ConstantValue;
767 case ValID::InlineAsmVal: { // Inline asm expression
768 const PointerType *PTy = dyn_cast<PointerType>(Ty);
769 const FunctionType *FTy =
770 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
771 if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
772 GenerateError("Invalid type for asm constraint string");
775 InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
776 D.IAD->HasSideEffects);
777 D.destroy(); // Free InlineAsmDescriptor.
781 assert(0 && "Unhandled case!");
785 assert(0 && "Unhandled case!");
789 // getVal - This function is identical to getExistingVal, except that if a
790 // value is not already defined, it "improvises" by creating a placeholder var
791 // that looks and acts just like the requested variable. When the value is
792 // defined later, all uses of the placeholder variable are replaced with the
795 static Value *getVal(const Type *Ty, const ValID &ID) {
796 if (Ty == Type::LabelTy) {
797 GenerateError("Cannot use a basic block here");
801 // See if the value has already been defined.
802 Value *V = getExistingVal(Ty, ID);
804 if (TriggerError) return 0;
806 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
807 GenerateError("Invalid use of a composite type");
811 // If we reached here, we referenced either a symbol that we don't know about
812 // or an id number that hasn't been read yet. We may be referencing something
813 // forward, so just create an entry to be resolved later and get to it...
816 case ValID::GlobalName:
817 case ValID::GlobalID: {
818 const PointerType *PTy = dyn_cast<PointerType>(Ty);
820 GenerateError("Invalid type for reference to global" );
823 const Type* ElTy = PTy->getElementType();
824 if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
825 V = new Function(FTy, GlobalValue::ExternalLinkage);
827 V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage);
831 V = new Argument(Ty);
834 // Remember where this forward reference came from. FIXME, shouldn't we try
835 // to recycle these things??
836 CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
839 if (inFunctionScope())
840 InsertValue(V, CurFun.LateResolveValues);
842 InsertValue(V, CurModule.LateResolveValues);
846 /// defineBBVal - This is a definition of a new basic block with the specified
847 /// identifier which must be the same as CurFun.NextValNum, if its numeric.
848 static BasicBlock *defineBBVal(const ValID &ID) {
849 assert(inFunctionScope() && "Can't get basic block at global scope!");
853 // First, see if this was forward referenced
855 std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
856 if (BBI != CurFun.BBForwardRefs.end()) {
858 // The forward declaration could have been inserted anywhere in the
859 // function: insert it into the correct place now.
860 CurFun.CurrentFunction->getBasicBlockList().remove(BB);
861 CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
863 // We're about to erase the entry, save the key so we can clean it up.
864 ValID Tmp = BBI->first;
866 // Erase the forward ref from the map as its no longer "forward"
867 CurFun.BBForwardRefs.erase(ID);
869 // The key has been removed from the map but so we don't want to leave
870 // strdup'd memory around so destroy it too.
873 // If its a numbered definition, bump the number and set the BB value.
874 if (ID.Type == ValID::LocalID) {
875 assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
883 // We haven't seen this BB before and its first mention is a definition.
884 // Just create it and return it.
885 std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
886 BB = new BasicBlock(Name, CurFun.CurrentFunction);
887 if (ID.Type == ValID::LocalID) {
888 assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
892 ID.destroy(); // Free strdup'd memory
896 /// getBBVal - get an existing BB value or create a forward reference for it.
898 static BasicBlock *getBBVal(const ValID &ID) {
899 assert(inFunctionScope() && "Can't get basic block at global scope!");
903 std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
904 if (BBI != CurFun.BBForwardRefs.end()) {
906 } if (ID.Type == ValID::LocalName) {
907 std::string Name = ID.getName();
908 Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
910 if (N->getType()->getTypeID() == Type::LabelTyID)
911 BB = cast<BasicBlock>(N);
913 GenerateError("Reference to label '" + Name + "' is actually of type '"+
914 N->getType()->getDescription() + "'");
915 } else if (ID.Type == ValID::LocalID) {
916 if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) {
917 if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID)
918 BB = cast<BasicBlock>(CurFun.Values[ID.Num]);
920 GenerateError("Reference to label '%" + utostr(ID.Num) +
921 "' is actually of type '"+
922 CurFun.Values[ID.Num]->getType()->getDescription() + "'");
925 GenerateError("Illegal label reference " + ID.getName());
929 // If its already been defined, return it now.
931 ID.destroy(); // Free strdup'd memory.
935 // Otherwise, this block has not been seen before, create it.
937 if (ID.Type == ValID::LocalName)
939 BB = new BasicBlock(Name, CurFun.CurrentFunction);
941 // Insert it in the forward refs map.
942 CurFun.BBForwardRefs[ID] = BB;
948 //===----------------------------------------------------------------------===//
949 // Code to handle forward references in instructions
950 //===----------------------------------------------------------------------===//
952 // This code handles the late binding needed with statements that reference
953 // values not defined yet... for example, a forward branch, or the PHI node for
956 // This keeps a table (CurFun.LateResolveValues) of all such forward references
957 // and back patchs after we are done.
960 // ResolveDefinitions - If we could not resolve some defs at parsing
961 // time (forward branches, phi functions for loops, etc...) resolve the
965 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) {
966 // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
967 while (!LateResolvers.empty()) {
968 Value *V = LateResolvers.back();
969 LateResolvers.pop_back();
971 std::map<Value*, std::pair<ValID, int> >::iterator PHI =
972 CurModule.PlaceHolderInfo.find(V);
973 assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
975 ValID &DID = PHI->second.first;
977 Value *TheRealValue = getExistingVal(V->getType(), DID);
981 V->replaceAllUsesWith(TheRealValue);
983 CurModule.PlaceHolderInfo.erase(PHI);
984 } else if (FutureLateResolvers) {
985 // Functions have their unresolved items forwarded to the module late
987 InsertValue(V, *FutureLateResolvers);
989 if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
990 GenerateError("Reference to an invalid definition: '" +DID.getName()+
991 "' of type '" + V->getType()->getDescription() + "'",
995 GenerateError("Reference to an invalid definition: #" +
996 itostr(DID.Num) + " of type '" +
997 V->getType()->getDescription() + "'",
1003 LateResolvers.clear();
1006 // ResolveTypeTo - A brand new type was just declared. This means that (if
1007 // name is not null) things referencing Name can be resolved. Otherwise, things
1008 // refering to the number can be resolved. Do this now.
1010 static void ResolveTypeTo(std::string *Name, const Type *ToTy) {
1013 D = ValID::createLocalName(*Name);
1015 D = ValID::createLocalID(CurModule.Types.size());
1017 std::map<ValID, PATypeHolder>::iterator I =
1018 CurModule.LateResolveTypes.find(D);
1019 if (I != CurModule.LateResolveTypes.end()) {
1020 ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
1021 CurModule.LateResolveTypes.erase(I);
1025 // setValueName - Set the specified value to the name given. The name may be
1026 // null potentially, in which case this is a noop. The string passed in is
1027 // assumed to be a malloc'd string buffer, and is free'd by this function.
1029 static void setValueName(Value *V, std::string *NameStr) {
1030 if (!NameStr) return;
1031 std::string Name(*NameStr); // Copy string
1032 delete NameStr; // Free old string
1034 if (V->getType() == Type::VoidTy) {
1035 GenerateError("Can't assign name '" + Name+"' to value with void type");
1039 assert(inFunctionScope() && "Must be in function scope!");
1040 ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1041 if (ST.lookup(Name)) {
1042 GenerateError("Redefinition of value '" + Name + "' of type '" +
1043 V->getType()->getDescription() + "'");
1051 /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
1052 /// this is a declaration, otherwise it is a definition.
1053 static GlobalVariable *
1054 ParseGlobalVariable(std::string *NameStr,
1055 GlobalValue::LinkageTypes Linkage,
1056 GlobalValue::VisibilityTypes Visibility,
1057 bool isConstantGlobal, const Type *Ty,
1058 Constant *Initializer, bool IsThreadLocal) {
1059 if (isa<FunctionType>(Ty)) {
1060 GenerateError("Cannot declare global vars of function type");
1064 const PointerType *PTy = PointerType::get(Ty);
1068 Name = *NameStr; // Copy string
1069 delete NameStr; // Free old string
1072 // See if this global value was forward referenced. If so, recycle the
1075 if (!Name.empty()) {
1076 ID = ValID::createGlobalName(Name);
1078 ID = ValID::createGlobalID(CurModule.Values.size());
1081 if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1082 // Move the global to the end of the list, from whereever it was
1083 // previously inserted.
1084 GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1085 CurModule.CurrentModule->getGlobalList().remove(GV);
1086 CurModule.CurrentModule->getGlobalList().push_back(GV);
1087 GV->setInitializer(Initializer);
1088 GV->setLinkage(Linkage);
1089 GV->setVisibility(Visibility);
1090 GV->setConstant(isConstantGlobal);
1091 GV->setThreadLocal(IsThreadLocal);
1092 InsertValue(GV, CurModule.Values);
1096 // If this global has a name
1097 if (!Name.empty()) {
1098 // if the global we're parsing has an initializer (is a definition) and
1099 // has external linkage.
1100 if (Initializer && Linkage != GlobalValue::InternalLinkage)
1101 // If there is already a global with external linkage with this name
1102 if (CurModule.CurrentModule->getGlobalVariable(Name, false)) {
1103 // If we allow this GVar to get created, it will be renamed in the
1104 // symbol table because it conflicts with an existing GVar. We can't
1105 // allow redefinition of GVars whose linking indicates that their name
1106 // must stay the same. Issue the error.
1107 GenerateError("Redefinition of global variable named '" + Name +
1108 "' of type '" + Ty->getDescription() + "'");
1113 // Otherwise there is no existing GV to use, create one now.
1114 GlobalVariable *GV =
1115 new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1116 CurModule.CurrentModule, IsThreadLocal);
1117 GV->setVisibility(Visibility);
1118 InsertValue(GV, CurModule.Values);
1122 // setTypeName - Set the specified type to the name given. The name may be
1123 // null potentially, in which case this is a noop. The string passed in is
1124 // assumed to be a malloc'd string buffer, and is freed by this function.
1126 // This function returns true if the type has already been defined, but is
1127 // allowed to be redefined in the specified context. If the name is a new name
1128 // for the type plane, it is inserted and false is returned.
1129 static bool setTypeName(const Type *T, std::string *NameStr) {
1130 assert(!inFunctionScope() && "Can't give types function-local names!");
1131 if (NameStr == 0) return false;
1133 std::string Name(*NameStr); // Copy string
1134 delete NameStr; // Free old string
1136 // We don't allow assigning names to void type
1137 if (T == Type::VoidTy) {
1138 GenerateError("Can't assign name '" + Name + "' to the void type");
1142 // Set the type name, checking for conflicts as we do so.
1143 bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1145 if (AlreadyExists) { // Inserting a name that is already defined???
1146 const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1147 assert(Existing && "Conflict but no matching type?!");
1149 // There is only one case where this is allowed: when we are refining an
1150 // opaque type. In this case, Existing will be an opaque type.
1151 if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1152 // We ARE replacing an opaque type!
1153 const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1157 // Otherwise, this is an attempt to redefine a type. That's okay if
1158 // the redefinition is identical to the original. This will be so if
1159 // Existing and T point to the same Type object. In this one case we
1160 // allow the equivalent redefinition.
1161 if (Existing == T) return true; // Yes, it's equal.
1163 // Any other kind of (non-equivalent) redefinition is an error.
1164 GenerateError("Redefinition of type named '" + Name + "' of type '" +
1165 T->getDescription() + "'");
1171 //===----------------------------------------------------------------------===//
1172 // Code for handling upreferences in type names...
1175 // TypeContains - Returns true if Ty directly contains E in it.
1177 static bool TypeContains(const Type *Ty, const Type *E) {
1178 return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1179 E) != Ty->subtype_end();
1183 struct UpRefRecord {
1184 // NestingLevel - The number of nesting levels that need to be popped before
1185 // this type is resolved.
1186 unsigned NestingLevel;
1188 // LastContainedTy - This is the type at the current binding level for the
1189 // type. Every time we reduce the nesting level, this gets updated.
1190 const Type *LastContainedTy;
1192 // UpRefTy - This is the actual opaque type that the upreference is
1193 // represented with.
1194 OpaqueType *UpRefTy;
1196 UpRefRecord(unsigned NL, OpaqueType *URTy)
1197 : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1201 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1202 static std::vector<UpRefRecord> UpRefs;
1204 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1205 /// called. It loops through the UpRefs vector, which is a list of the
1206 /// currently active types. For each type, if the up reference is contained in
1207 /// the newly completed type, we decrement the level count. When the level
1208 /// count reaches zero, the upreferenced type is the type that is passed in:
1209 /// thus we can complete the cycle.
1211 static PATypeHolder HandleUpRefs(const Type *ty) {
1212 // If Ty isn't abstract, or if there are no up-references in it, then there is
1213 // nothing to resolve here.
1214 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1216 PATypeHolder Ty(ty);
1217 UR_OUT("Type '" << Ty->getDescription() <<
1218 "' newly formed. Resolving upreferences.\n" <<
1219 UpRefs.size() << " upreferences active!\n");
1221 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1222 // to zero), we resolve them all together before we resolve them to Ty. At
1223 // the end of the loop, if there is anything to resolve to Ty, it will be in
1225 OpaqueType *TypeToResolve = 0;
1227 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1228 UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1229 << UpRefs[i].second->getDescription() << ") = "
1230 << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1231 if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1232 // Decrement level of upreference
1233 unsigned Level = --UpRefs[i].NestingLevel;
1234 UpRefs[i].LastContainedTy = Ty;
1235 UR_OUT(" Uplevel Ref Level = " << Level << "\n");
1236 if (Level == 0) { // Upreference should be resolved!
1237 if (!TypeToResolve) {
1238 TypeToResolve = UpRefs[i].UpRefTy;
1240 UR_OUT(" * Resolving upreference for "
1241 << UpRefs[i].second->getDescription() << "\n";
1242 std::string OldName = UpRefs[i].UpRefTy->getDescription());
1243 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1244 UR_OUT(" * Type '" << OldName << "' refined upreference to: "
1245 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1247 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
1248 --i; // Do not skip the next element...
1253 if (TypeToResolve) {
1254 UR_OUT(" * Resolving upreference for "
1255 << UpRefs[i].second->getDescription() << "\n";
1256 std::string OldName = TypeToResolve->getDescription());
1257 TypeToResolve->refineAbstractTypeTo(Ty);
1263 //===----------------------------------------------------------------------===//
1264 // RunVMAsmParser - Define an interface to this parser
1265 //===----------------------------------------------------------------------===//
1267 static Module* RunParser(Module * M);
1269 Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) {
1272 CurFilename = Filename;
1273 return RunParser(new Module(CurFilename));
1276 Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
1277 set_scan_string(AsmString);
1279 CurFilename = "from_memory";
1281 return RunParser(new Module (CurFilename));
1283 return RunParser(M);
1289 /* Enabling traces. */
1294 /* Enabling verbose error messages. */
1295 #ifdef YYERROR_VERBOSE
1296 # undef YYERROR_VERBOSE
1297 # define YYERROR_VERBOSE 1
1299 # define YYERROR_VERBOSE 0
1302 /* Enabling the token table. */
1303 #ifndef YYTOKEN_TABLE
1304 # define YYTOKEN_TABLE 0
1307 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1308 #line 957 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
1309 typedef union YYSTYPE {
1310 llvm::Module *ModuleVal;
1311 llvm::Function *FunctionVal;
1312 llvm::BasicBlock *BasicBlockVal;
1313 llvm::TerminatorInst *TermInstVal;
1314 llvm::Instruction *InstVal;
1315 llvm::Constant *ConstVal;
1317 const llvm::Type *PrimType;
1318 std::list<llvm::PATypeHolder> *TypeList;
1319 llvm::PATypeHolder *TypeVal;
1320 llvm::Value *ValueVal;
1321 std::vector<llvm::Value*> *ValueList;
1322 llvm::ArgListType *ArgList;
1323 llvm::TypeWithAttrs TypeWithAttrs;
1324 llvm::TypeWithAttrsList *TypeWithAttrsList;
1325 llvm::ValueRefList *ValueRefList;
1327 // Represent the RHS of PHI node
1328 std::list<std::pair<llvm::Value*,
1329 llvm::BasicBlock*> > *PHIList;
1330 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1331 std::vector<llvm::Constant*> *ConstVector;
1333 llvm::GlobalValue::LinkageTypes Linkage;
1334 llvm::GlobalValue::VisibilityTypes Visibility;
1335 uint16_t ParamAttrs;
1336 llvm::APInt *APIntVal;
1344 std::string *StrVal; // This memory must be deleted
1345 llvm::ValID ValIDVal;
1347 llvm::Instruction::BinaryOps BinaryOpVal;
1348 llvm::Instruction::TermOps TermOpVal;
1349 llvm::Instruction::MemoryOps MemOpVal;
1350 llvm::Instruction::CastOps CastOpVal;
1351 llvm::Instruction::OtherOps OtherOpVal;
1352 llvm::ICmpInst::Predicate IPredicate;
1353 llvm::FCmpInst::Predicate FPredicate;
1355 /* Line 196 of yacc.c. */
1356 #line 1357 "llvmAsmParser.tab.c"
1357 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1358 # define YYSTYPE_IS_DECLARED 1
1359 # define YYSTYPE_IS_TRIVIAL 1
1364 /* Copy the second part of user declarations. */
1367 /* Line 219 of yacc.c. */
1368 #line 1369 "llvmAsmParser.tab.c"
1370 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1371 # define YYSIZE_T __SIZE_TYPE__
1373 #if ! defined (YYSIZE_T) && defined (size_t)
1374 # define YYSIZE_T size_t
1376 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1377 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1378 # define YYSIZE_T size_t
1380 #if ! defined (YYSIZE_T)
1381 # define YYSIZE_T unsigned int
1387 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1388 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1392 # define YY_(msgid) msgid
1396 #if ! defined (yyoverflow) || YYERROR_VERBOSE
1398 /* The parser invokes alloca or malloc; define the necessary symbols. */
1400 # ifdef YYSTACK_USE_ALLOCA
1401 # if YYSTACK_USE_ALLOCA
1403 # define YYSTACK_ALLOC __builtin_alloca
1405 # define YYSTACK_ALLOC alloca
1406 # if defined (__STDC__) || defined (__cplusplus)
1407 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1408 # define YYINCLUDED_STDLIB_H
1414 # ifdef YYSTACK_ALLOC
1415 /* Pacify GCC's `empty if-body' warning. */
1416 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1417 # ifndef YYSTACK_ALLOC_MAXIMUM
1418 /* The OS might guarantee only one guard page at the bottom of the stack,
1419 and a page size can be as small as 4096 bytes. So we cannot safely
1420 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1421 to allow for a few compiler-allocated temporary stack slots. */
1422 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1425 # define YYSTACK_ALLOC YYMALLOC
1426 # define YYSTACK_FREE YYFREE
1427 # ifndef YYSTACK_ALLOC_MAXIMUM
1428 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1434 # define YYMALLOC malloc
1435 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1436 && (defined (__STDC__) || defined (__cplusplus)))
1437 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1441 # define YYFREE free
1442 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1443 && (defined (__STDC__) || defined (__cplusplus)))
1444 void free (void *); /* INFRINGES ON USER NAME SPACE */
1451 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1454 #if (! defined (yyoverflow) \
1455 && (! defined (__cplusplus) \
1456 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1458 /* A type that is properly aligned for any stack member. */
1465 /* The size of the maximum gap between one aligned stack and the next. */
1466 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1468 /* The size of an array large to enough to hold all stacks, each with
1470 # define YYSTACK_BYTES(N) \
1471 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
1472 + YYSTACK_GAP_MAXIMUM)
1474 /* Copy COUNT objects from FROM to TO. The source and destination do
1477 # if defined (__GNUC__) && 1 < __GNUC__
1478 # define YYCOPY(To, From, Count) \
1479 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1481 # define YYCOPY(To, From, Count) \
1485 for (yyi = 0; yyi < (Count); yyi++) \
1486 (To)[yyi] = (From)[yyi]; \
1492 /* Relocate STACK from its old location to the new one. The
1493 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1494 elements in the stack, and YYPTR gives the new location of the
1495 stack. Advance YYPTR to a properly aligned location for the next
1497 # define YYSTACK_RELOCATE(Stack) \
1500 YYSIZE_T yynewbytes; \
1501 YYCOPY (&yyptr->Stack, Stack, yysize); \
1502 Stack = &yyptr->Stack; \
1503 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1504 yyptr += yynewbytes / sizeof (*yyptr); \
1510 #if defined (__STDC__) || defined (__cplusplus)
1511 typedef signed char yysigned_char;
1513 typedef short int yysigned_char;
1516 /* YYFINAL -- State number of the termination state. */
1518 /* YYLAST -- Last index in YYTABLE. */
1521 /* YYNTOKENS -- Number of terminals. */
1522 #define YYNTOKENS 152
1523 /* YYNNTS -- Number of nonterminals. */
1525 /* YYNRULES -- Number of rules. */
1526 #define YYNRULES 298
1527 /* YYNRULES -- Number of states. */
1528 #define YYNSTATES 582
1530 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1531 #define YYUNDEFTOK 2
1532 #define YYMAXUTOK 392
1534 #define YYTRANSLATE(YYX) \
1535 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1537 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1538 static const unsigned char yytranslate[] =
1540 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1544 142, 143, 140, 2, 139, 2, 2, 2, 2, 2,
1545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1546 147, 138, 148, 2, 2, 2, 2, 2, 2, 2,
1547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1549 2, 144, 141, 146, 2, 2, 2, 2, 2, 151,
1550 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1552 145, 2, 2, 149, 2, 150, 2, 2, 2, 2,
1553 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1554 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1555 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1556 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1559 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1565 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1566 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1567 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1568 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1569 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1570 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1571 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1572 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1573 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1574 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1575 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1576 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1577 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
1578 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1583 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1585 static const unsigned short int yyprhs[] =
1587 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
1588 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
1589 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
1590 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
1591 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
1592 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
1593 119, 121, 123, 124, 127, 128, 130, 132, 134, 135,
1594 138, 140, 142, 144, 146, 148, 150, 152, 154, 155,
1595 157, 159, 161, 162, 164, 166, 167, 169, 171, 173,
1596 175, 176, 178, 180, 181, 183, 185, 187, 189, 191,
1597 194, 196, 198, 200, 202, 203, 206, 208, 210, 212,
1598 213, 216, 217, 220, 221, 225, 228, 229, 231, 232,
1599 236, 238, 241, 243, 245, 247, 249, 251, 253, 256,
1600 258, 261, 267, 273, 279, 285, 289, 292, 298, 303,
1601 306, 308, 310, 312, 316, 318, 322, 324, 325, 327,
1602 331, 336, 340, 344, 349, 354, 358, 365, 371, 374,
1603 377, 380, 383, 386, 389, 392, 395, 398, 401, 404,
1604 407, 414, 420, 429, 436, 443, 451, 459, 466, 475,
1605 484, 488, 490, 492, 494, 496, 497, 500, 507, 509,
1606 510, 512, 515, 516, 520, 521, 525, 529, 533, 537,
1607 538, 546, 547, 556, 557, 566, 572, 575, 579, 581,
1608 585, 589, 593, 597, 599, 600, 606, 610, 612, 616,
1609 618, 619, 629, 631, 633, 638, 640, 642, 645, 649,
1610 650, 652, 654, 656, 658, 660, 662, 664, 666, 668,
1611 672, 674, 680, 682, 684, 686, 688, 690, 692, 695,
1612 698, 701, 705, 708, 709, 711, 714, 717, 721, 731,
1613 741, 750, 765, 767, 769, 776, 782, 785, 792, 800,
1614 804, 810, 811, 812, 816, 819, 821, 827, 833, 840,
1615 847, 852, 859, 864, 869, 876, 883, 886, 895, 897,
1616 899, 900, 904, 911, 915, 922, 925, 931, 939
1619 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1620 static const short int yyrhs[] =
1622 196, 0, -1, 70, -1, 71, -1, 72, -1, 73,
1623 -1, 74, -1, 75, -1, 76, -1, 77, -1, 78,
1624 -1, 82, -1, 83, -1, 84, -1, 79, -1, 80,
1625 -1, 81, -1, 113, -1, 114, -1, 115, -1, 116,
1626 -1, 117, -1, 118, -1, 119, -1, 120, -1, 121,
1627 -1, 122, -1, 123, -1, 124, -1, 87, -1, 88,
1628 -1, 89, -1, 90, -1, 91, -1, 92, -1, 93,
1629 -1, 94, -1, 95, -1, 96, -1, 97, -1, 98,
1630 -1, 99, -1, 100, -1, 101, -1, 102, -1, 103,
1631 -1, 104, -1, 105, -1, 106, -1, 93, -1, 94,
1632 -1, 95, -1, 96, -1, 23, -1, 24, -1, 11,
1633 -1, 12, -1, 13, -1, 16, -1, 19, -1, 21,
1634 -1, 160, -1, -1, 160, 138, -1, -1, 17, -1,
1635 20, -1, 165, -1, -1, 163, 138, -1, 39, -1,
1636 41, -1, 40, -1, 42, -1, 44, -1, 43, -1,
1637 45, -1, 47, -1, -1, 135, -1, 136, -1, 137,
1638 -1, -1, 43, -1, 45, -1, -1, 39, -1, 40,
1639 -1, 41, -1, 44, -1, -1, 41, -1, 39, -1,
1640 -1, 58, -1, 59, -1, 60, -1, 61, -1, 62,
1641 -1, 57, 4, -1, 114, -1, 115, -1, 132, -1,
1642 133, -1, -1, 174, 173, -1, 131, -1, 134, -1,
1643 173, -1, -1, 176, 175, -1, -1, 50, 4, -1,
1644 -1, 139, 50, 4, -1, 31, 19, -1, -1, 179,
1645 -1, -1, 139, 182, 181, -1, 179, -1, 50, 4,
1646 -1, 11, -1, 12, -1, 13, -1, 14, -1, 46,
1647 -1, 183, -1, 184, 140, -1, 218, -1, 141, 4,
1648 -1, 184, 142, 188, 143, 176, -1, 10, 142, 188,
1649 143, 176, -1, 144, 4, 145, 184, 146, -1, 147,
1650 4, 145, 184, 148, -1, 149, 189, 150, -1, 149,
1651 150, -1, 147, 149, 189, 150, 148, -1, 147, 149,
1652 150, 148, -1, 184, 174, -1, 184, -1, 10, -1,
1653 185, -1, 187, 139, 185, -1, 187, -1, 187, 139,
1654 36, -1, 36, -1, -1, 184, -1, 189, 139, 184,
1655 -1, 184, 144, 192, 146, -1, 184, 144, 146, -1,
1656 184, 151, 19, -1, 184, 147, 192, 148, -1, 184,
1657 149, 192, 150, -1, 184, 149, 150, -1, 184, 147,
1658 149, 192, 150, 148, -1, 184, 147, 149, 150, 148,
1659 -1, 184, 37, -1, 184, 38, -1, 184, 218, -1,
1660 184, 191, -1, 184, 22, -1, 158, 3, -1, 158,
1661 5, -1, 158, 4, -1, 158, 6, -1, 11, 23,
1662 -1, 11, 24, -1, 159, 9, -1, 155, 142, 190,
1663 35, 184, 143, -1, 112, 142, 190, 229, 143, -1,
1664 126, 142, 190, 139, 190, 139, 190, 143, -1, 153,
1665 142, 190, 139, 190, 143, -1, 154, 142, 190, 139,
1666 190, 143, -1, 85, 156, 142, 190, 139, 190, 143,
1667 -1, 86, 157, 142, 190, 139, 190, 143, -1, 128,
1668 142, 190, 139, 190, 143, -1, 129, 142, 190, 139,
1669 190, 139, 190, 143, -1, 130, 142, 190, 139, 190,
1670 139, 190, 143, -1, 192, 139, 190, -1, 190, -1,
1671 29, -1, 30, -1, 34, -1, -1, 186, 218, -1,
1672 118, 142, 195, 35, 184, 143, -1, 197, -1, -1,
1673 198, -1, 197, 198, -1, -1, 28, 199, 214, -1,
1674 -1, 27, 200, 215, -1, 55, 54, 204, -1, 162,
1675 15, 184, -1, 162, 15, 10, -1, -1, 164, 168,
1676 194, 193, 190, 201, 181, -1, -1, 164, 166, 168,
1677 194, 193, 190, 202, 181, -1, -1, 164, 167, 168,
1678 194, 193, 184, 203, 181, -1, 164, 168, 32, 171,
1679 195, -1, 48, 205, -1, 51, 138, 206, -1, 19,
1680 -1, 49, 138, 19, -1, 63, 138, 19, -1, 144,
1681 207, 146, -1, 207, 139, 19, -1, 19, -1, -1,
1682 208, 139, 184, 174, 161, -1, 184, 174, 161, -1,
1683 208, -1, 208, 139, 36, -1, 36, -1, -1, 172,
1684 186, 163, 142, 209, 143, 176, 180, 177, -1, 25,
1685 -1, 149, -1, 170, 168, 210, 211, -1, 26, -1,
1686 150, -1, 221, 213, -1, 169, 168, 210, -1, -1,
1687 56, -1, 3, -1, 4, -1, 9, -1, 23, -1,
1688 24, -1, 37, -1, 38, -1, 22, -1, 147, 192,
1689 148, -1, 191, -1, 54, 216, 19, 139, 19, -1,
1690 7, -1, 8, -1, 160, -1, 163, -1, 218, -1,
1691 217, -1, 184, 219, -1, 221, 222, -1, 212, 222,
1692 -1, 223, 162, 224, -1, 223, 226, -1, -1, 18,
1693 -1, 64, 220, -1, 64, 10, -1, 65, 14, 219,
1694 -1, 65, 11, 219, 139, 14, 219, 139, 14, 219,
1695 -1, 66, 158, 219, 139, 14, 219, 144, 225, 146,
1696 -1, 66, 158, 219, 139, 14, 219, 144, 146, -1,
1697 67, 172, 186, 219, 142, 228, 143, 176, 35, 14,
1698 219, 68, 14, 219, -1, 68, -1, 69, -1, 225,
1699 158, 217, 139, 14, 219, -1, 158, 217, 139, 14,
1700 219, -1, 162, 231, -1, 184, 144, 219, 139, 219,
1701 146, -1, 227, 139, 144, 219, 139, 219, 146, -1,
1702 184, 219, 174, -1, 228, 139, 184, 219, 174, -1,
1703 -1, -1, 229, 139, 220, -1, 53, 52, -1, 52,
1704 -1, 153, 184, 219, 139, 219, -1, 154, 184, 219,
1705 139, 219, -1, 85, 156, 184, 219, 139, 219, -1,
1706 86, 157, 184, 219, 139, 219, -1, 155, 220, 35,
1707 184, -1, 126, 220, 139, 220, 139, 220, -1, 127,
1708 220, 139, 184, -1, 128, 220, 139, 220, -1, 129,
1709 220, 139, 220, 139, 220, -1, 130, 220, 139, 220,
1710 139, 220, -1, 125, 227, -1, 230, 172, 186, 219,
1711 142, 228, 143, 176, -1, 233, -1, 33, -1, -1,
1712 107, 184, 178, -1, 107, 184, 139, 11, 219, 178,
1713 -1, 108, 184, 178, -1, 108, 184, 139, 11, 219,
1714 178, -1, 109, 220, -1, 232, 110, 184, 219, 178,
1715 -1, 232, 111, 220, 139, 184, 219, 178, -1, 112,
1719 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1720 static const unsigned short int yyrline[] =
1722 0, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116, 1116,
1723 1116, 1117, 1117, 1117, 1117, 1117, 1117, 1118, 1118, 1118,
1724 1118, 1118, 1118, 1119, 1119, 1119, 1119, 1119, 1119, 1122,
1725 1122, 1123, 1123, 1124, 1124, 1125, 1125, 1126, 1126, 1130,
1726 1130, 1131, 1131, 1132, 1132, 1133, 1133, 1134, 1134, 1135,
1727 1135, 1136, 1136, 1137, 1138, 1143, 1144, 1144, 1146, 1146,
1728 1146, 1147, 1147, 1151, 1155, 1160, 1160, 1162, 1163, 1168,
1729 1174, 1175, 1176, 1177, 1178, 1182, 1183, 1184, 1188, 1189,
1730 1190, 1191, 1195, 1196, 1197, 1201, 1202, 1203, 1204, 1205,
1731 1209, 1210, 1211, 1214, 1215, 1216, 1217, 1218, 1219, 1220,
1732 1227, 1228, 1229, 1230, 1233, 1234, 1239, 1240, 1241, 1244,
1733 1245, 1252, 1253, 1259, 1260, 1268, 1276, 1277, 1282, 1283,
1734 1284, 1289, 1302, 1302, 1302, 1302, 1305, 1309, 1313, 1320,
1735 1325, 1333, 1363, 1394, 1399, 1411, 1421, 1425, 1435, 1442,
1736 1449, 1456, 1461, 1466, 1473, 1474, 1481, 1488, 1496, 1502,
1737 1514, 1542, 1558, 1585, 1613, 1639, 1659, 1685, 1705, 1717,
1738 1724, 1790, 1800, 1810, 1816, 1826, 1832, 1842, 1847, 1852,
1739 1860, 1872, 1894, 1902, 1908, 1919, 1924, 1929, 1935, 1941,
1740 1950, 1954, 1962, 1962, 1965, 1965, 1968, 1979, 2000, 2005,
1741 2013, 2014, 2018, 2018, 2022, 2022, 2025, 2028, 2052, 2063,
1742 2063, 2074, 2073, 2083, 2082, 2093, 2112, 2115, 2121, 2131,
1743 2135, 2140, 2142, 2147, 2152, 2161, 2171, 2182, 2186, 2195,
1744 2204, 2209, 2330, 2330, 2332, 2341, 2341, 2343, 2348, 2360,
1745 2364, 2369, 2373, 2377, 2381, 2385, 2389, 2393, 2397, 2401,
1746 2426, 2430, 2440, 2444, 2448, 2453, 2460, 2460, 2466, 2475,
1747 2479, 2488, 2497, 2506, 2510, 2517, 2521, 2525, 2530, 2540,
1748 2559, 2568, 2648, 2652, 2659, 2670, 2683, 2693, 2704, 2714,
1749 2723, 2732, 2735, 2736, 2743, 2747, 2752, 2773, 2790, 2804,
1750 2818, 2830, 2838, 2845, 2851, 2857, 2863, 2878, 2963, 2968,
1751 2972, 2979, 2986, 2994, 3001, 3009, 3017, 3031, 3048
1755 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1756 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1757 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1758 static const char *const yytname[] =
1760 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1761 "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1762 "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
1763 "STRINGCONSTANT", "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT",
1764 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
1765 "DECLARE", "DEFINE", "GLOBAL", "CONSTANT", "SECTION", "ALIAS",
1766 "VOLATILE", "THREAD_LOCAL", "TO", "DOTDOTDOT", "NULL_TOK", "UNDEF",
1767 "INTERNAL", "LINKONCE", "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT",
1768 "EXTERN_WEAK", "OPAQUE", "EXTERNAL", "TARGET", "TRIPLE", "ALIGN",
1769 "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK",
1770 "CCC_TOK", "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK",
1771 "X86_FASTCALLCC_TOK", "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE",
1772 "UNWIND", "UNREACHABLE", "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV",
1773 "UREM", "SREM", "FREM", "AND", "OR", "XOR", "SHL", "LSHR", "ASHR",
1774 "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", "UGT",
1775 "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO",
1776 "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE",
1777 "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST",
1778 "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT",
1779 "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT",
1780 "SHUFFLEVECTOR", "NORETURN", "INREG", "SRET", "NOUNWIND", "DEFAULT",
1781 "HIDDEN", "PROTECTED", "'='", "','", "'*'", "'\\\\'", "'('", "')'",
1782 "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'", "$accept",
1783 "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates", "FPredicates",
1784 "IntType", "FPType", "LocalName", "OptLocalName", "OptLocalAssign",
1785 "GlobalName", "OptGlobalAssign", "GlobalAssign", "GVInternalLinkage",
1786 "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage",
1787 "FunctionDefineLinkage", "AliasLinkage", "OptCallingConv", "ParamAttr",
1788 "OptParamAttrs", "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign",
1789 "SectionString", "OptSection", "GlobalVarAttributes",
1790 "GlobalVarAttribute", "PrimType", "Types", "ArgType", "ResultTypes",
1791 "ArgTypeList", "ArgTypeListI", "TypeListI", "ConstVal", "ConstExpr",
1792 "ConstVector", "GlobalType", "ThreadLocal", "AliaseeRef", "Module",
1793 "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5", "AsmBlock",
1794 "TargetDefinition", "LibrariesDefinition", "LibList", "ArgListH",
1795 "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader", "END",
1796 "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
1797 "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
1798 "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
1799 "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
1800 "OptVolatile", "MemoryInst", 0
1805 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1807 static const unsigned short int yytoknum[] =
1809 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1810 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1811 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1812 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1813 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1814 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1815 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1816 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1817 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1818 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1819 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1820 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1821 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1822 385, 386, 387, 388, 389, 390, 391, 392, 61, 44,
1823 42, 92, 40, 41, 91, 120, 93, 60, 62, 123,
1828 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1829 static const unsigned char yyr1[] =
1831 0, 152, 153, 153, 153, 153, 153, 153, 153, 153,
1832 153, 154, 154, 154, 154, 154, 154, 155, 155, 155,
1833 155, 155, 155, 155, 155, 155, 155, 155, 155, 156,
1834 156, 156, 156, 156, 156, 156, 156, 156, 156, 157,
1835 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
1836 157, 157, 157, 157, 157, 158, 159, 159, 160, 160,
1837 160, 161, 161, 162, 162, 163, 163, 164, 164, 165,
1838 166, 166, 166, 166, 166, 167, 167, 167, 168, 168,
1839 168, 168, 169, 169, 169, 170, 170, 170, 170, 170,
1840 171, 171, 171, 172, 172, 172, 172, 172, 172, 172,
1841 173, 173, 173, 173, 174, 174, 175, 175, 175, 176,
1842 176, 177, 177, 178, 178, 179, 180, 180, 181, 181,
1843 182, 182, 183, 183, 183, 183, 184, 184, 184, 184,
1844 184, 184, 184, 184, 184, 184, 184, 184, 184, 185,
1845 186, 186, 187, 187, 188, 188, 188, 188, 189, 189,
1846 190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
1847 190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
1848 191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
1849 192, 192, 193, 193, 194, 194, 195, 195, 196, 196,
1850 197, 197, 199, 198, 200, 198, 198, 198, 198, 201,
1851 198, 202, 198, 203, 198, 198, 198, 198, 204, 205,
1852 205, 206, 207, 207, 207, 208, 208, 209, 209, 209,
1853 209, 210, 211, 211, 212, 213, 213, 214, 215, 216,
1854 216, 217, 217, 217, 217, 217, 217, 217, 217, 217,
1855 217, 217, 218, 218, 218, 218, 219, 219, 220, 221,
1856 221, 222, 223, 223, 223, 224, 224, 224, 224, 224,
1857 224, 224, 224, 224, 225, 225, 226, 227, 227, 228,
1858 228, 228, 229, 229, 230, 230, 231, 231, 231, 231,
1859 231, 231, 231, 231, 231, 231, 231, 231, 231, 232,
1860 232, 233, 233, 233, 233, 233, 233, 233, 233
1863 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1864 static const unsigned char yyr2[] =
1866 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1867 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1868 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1869 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1870 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1871 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1872 1, 1, 0, 2, 0, 1, 1, 1, 0, 2,
1873 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
1874 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,
1875 0, 1, 1, 0, 1, 1, 1, 1, 1, 2,
1876 1, 1, 1, 1, 0, 2, 1, 1, 1, 0,
1877 2, 0, 2, 0, 3, 2, 0, 1, 0, 3,
1878 1, 2, 1, 1, 1, 1, 1, 1, 2, 1,
1879 2, 5, 5, 5, 5, 3, 2, 5, 4, 2,
1880 1, 1, 1, 3, 1, 3, 1, 0, 1, 3,
1881 4, 3, 3, 4, 4, 3, 6, 5, 2, 2,
1882 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1883 6, 5, 8, 6, 6, 7, 7, 6, 8, 8,
1884 3, 1, 1, 1, 1, 0, 2, 6, 1, 0,
1885 1, 2, 0, 3, 0, 3, 3, 3, 3, 0,
1886 7, 0, 8, 0, 8, 5, 2, 3, 1, 3,
1887 3, 3, 3, 1, 0, 5, 3, 1, 3, 1,
1888 0, 9, 1, 1, 4, 1, 1, 2, 3, 0,
1889 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1890 1, 5, 1, 1, 1, 1, 1, 1, 2, 2,
1891 2, 3, 2, 0, 1, 2, 2, 3, 9, 9,
1892 8, 14, 1, 1, 6, 5, 2, 6, 7, 3,
1893 5, 0, 0, 3, 2, 1, 5, 5, 6, 6,
1894 4, 6, 4, 4, 6, 6, 2, 8, 1, 1,
1895 0, 3, 6, 3, 6, 2, 5, 7, 4
1898 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1899 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1900 means the default is an error. */
1901 static const unsigned short int yydefact[] =
1903 68, 58, 65, 59, 66, 60, 194, 192, 0, 0,
1904 0, 0, 0, 0, 78, 67, 0, 68, 190, 82,
1905 85, 0, 0, 206, 0, 0, 63, 0, 69, 70,
1906 72, 71, 73, 75, 74, 76, 77, 79, 80, 81,
1907 78, 78, 185, 1, 191, 83, 84, 78, 195, 86,
1908 87, 88, 89, 78, 253, 193, 253, 0, 0, 214,
1909 207, 208, 196, 242, 243, 198, 122, 123, 124, 125,
1910 126, 0, 0, 0, 0, 244, 245, 127, 197, 129,
1911 185, 185, 90, 184, 0, 93, 93, 254, 250, 64,
1912 225, 226, 227, 249, 209, 210, 213, 0, 147, 130,
1913 0, 0, 0, 0, 136, 148, 0, 128, 147, 0,
1914 0, 92, 91, 0, 182, 183, 0, 0, 94, 95,
1915 96, 97, 98, 0, 228, 0, 290, 252, 0, 211,
1916 146, 104, 142, 144, 0, 0, 0, 0, 0, 0,
1917 135, 0, 0, 0, 141, 0, 140, 0, 205, 122,
1918 123, 124, 0, 0, 0, 199, 99, 0, 222, 223,
1919 224, 289, 275, 0, 0, 0, 0, 93, 262, 263,
1920 2, 3, 4, 5, 6, 7, 8, 9, 10, 14,
1921 15, 16, 11, 12, 13, 0, 0, 0, 0, 0,
1922 0, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1923 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
1924 0, 0, 251, 93, 266, 0, 288, 212, 139, 0,
1925 109, 0, 0, 138, 0, 149, 109, 201, 203, 0,
1926 186, 167, 168, 163, 165, 164, 166, 169, 162, 158,
1927 159, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1928 0, 0, 0, 0, 0, 161, 160, 118, 0, 274,
1929 256, 0, 255, 0, 0, 55, 0, 0, 29, 30,
1930 31, 32, 33, 34, 35, 36, 37, 38, 0, 53,
1931 54, 49, 50, 51, 52, 39, 40, 41, 42, 43,
1932 44, 45, 46, 47, 48, 0, 113, 113, 295, 0,
1933 0, 286, 0, 0, 0, 0, 0, 0, 0, 0,
1934 0, 0, 0, 100, 101, 102, 103, 105, 145, 143,
1935 132, 133, 134, 137, 131, 118, 118, 0, 0, 0,
1936 0, 0, 0, 0, 0, 151, 181, 0, 0, 0,
1937 155, 0, 152, 0, 0, 0, 0, 200, 220, 231,
1938 232, 233, 238, 234, 235, 236, 237, 229, 0, 240,
1939 247, 246, 248, 0, 257, 0, 0, 0, 0, 0,
1940 291, 0, 293, 272, 0, 0, 0, 0, 0, 0,
1941 0, 0, 0, 0, 0, 0, 0, 106, 107, 108,
1942 110, 202, 204, 0, 0, 0, 272, 0, 0, 0,
1943 0, 0, 150, 136, 148, 0, 153, 154, 0, 0,
1944 0, 0, 0, 120, 118, 219, 104, 217, 0, 230,
1945 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1946 298, 0, 0, 0, 282, 283, 0, 0, 0, 0,
1947 280, 0, 113, 0, 0, 0, 0, 0, 0, 0,
1948 0, 0, 180, 157, 0, 0, 0, 0, 115, 121,
1949 119, 62, 0, 109, 0, 239, 0, 0, 271, 0,
1950 0, 113, 114, 113, 0, 0, 0, 0, 0, 0,
1951 276, 277, 271, 0, 296, 0, 187, 0, 0, 171,
1952 0, 0, 0, 0, 156, 0, 0, 0, 61, 216,
1953 218, 104, 116, 0, 0, 0, 0, 0, 278, 279,
1954 292, 294, 273, 0, 0, 281, 284, 285, 0, 113,
1955 0, 0, 0, 177, 0, 0, 173, 174, 170, 62,
1956 117, 111, 241, 0, 0, 104, 0, 109, 267, 0,
1957 109, 297, 175, 176, 0, 0, 0, 215, 0, 221,
1958 0, 260, 0, 0, 269, 0, 0, 268, 287, 172,
1959 178, 179, 112, 258, 0, 259, 0, 104, 0, 0,
1960 0, 270, 0, 0, 0, 0, 265, 0, 0, 264,
1964 /* YYDEFGOTO[NTERM-NUM]. */
1965 static const short int yydefgoto[] =
1967 -1, 252, 253, 254, 278, 295, 152, 153, 75, 499,
1968 12, 76, 14, 15, 40, 41, 42, 47, 53, 113,
1969 123, 317, 218, 390, 320, 549, 370, 413, 531, 347,
1970 414, 77, 154, 132, 147, 133, 134, 106, 336, 359,
1971 337, 116, 84, 148, 16, 17, 18, 20, 19, 257,
1972 325, 326, 62, 23, 60, 97, 417, 418, 124, 160,
1973 54, 92, 55, 48, 420, 360, 79, 362, 262, 56,
1974 88, 89, 212, 553, 127, 301, 507, 430, 213, 214,
1978 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1980 #define YYPACT_NINF -509
1981 static const short int yypact[] =
1983 47, -509, -509, -509, -509, -509, -509, -509, -8, -120,
1984 -11, -110, 58, -77, 432, -509, 79, 240, -509, 204,
1985 64, -50, -32, -509, -17, 114, -509, 1280, -509, -509,
1986 -509, -509, -509, -509, -509, -509, -509, -509, -509, -509,
1987 102, 102, 286, -509, -509, -509, -509, 102, -509, -509,
1988 -509, -509, -509, 102, 122, -509, 1, 130, 141, 157,
1989 -509, -509, -509, -509, -509, 62, -509, -509, -509, -509,
1990 -509, 191, 239, 5, 365, -509, -509, -509, 181, -509,
1991 196, 196, 292, -509, 170, 220, 220, -509, -509, 118,
1992 -509, -509, -509, -509, -509, -509, -509, -93, 1082, -509,
1993 101, 106, 566, 62, -509, 181, -94, -509, 1082, 170,
1994 170, -509, -509, 1122, -509, -509, 1327, 250, -509, -509,
1995 -509, -509, -509, 1342, -509, -14, 1480, -509, 251, -509,
1996 -509, 181, -509, 119, 140, 1379, 1379, 125, -58, 1379,
1997 -509, 147, 1327, 1379, 62, 151, 181, 255, -509, 28,
1998 302, 308, 219, 315, 863, -509, -509, 149, -509, -509,
1999 -509, -509, -509, 273, 1394, 222, 317, 220, -509, -509,
2000 -509, -509, -509, -509, -509, -509, -509, -509, -509, -509,
2001 -509, -509, -509, -509, -509, 395, 443, 1379, 1379, 1379,
2002 1379, -509, -509, -509, -509, -509, -509, -509, -509, -509,
2003 -509, -509, -509, 1379, 1379, 1379, 1379, 1379, 1379, 1379,
2004 1379, 1379, -509, 220, -509, 155, -509, -509, 14, 1137,
2005 -509, -10, -41, -509, 184, 181, -509, -509, 181, 1122,
2006 -509, -509, -509, -509, -509, -509, -509, -509, -509, -509,
2007 -509, 395, 443, 192, 194, 195, 197, 198, 1168, 1431,
2008 820, 319, 199, 200, 201, -509, -509, 205, 206, -509,
2009 62, 610, -509, 739, 739, -509, 739, 1342, -509, -509,
2010 -509, -509, -509, -509, -509, -509, -509, -509, 1379, -509,
2011 -509, -509, -509, -509, -509, -509, -509, -509, -509, -509,
2012 -509, -509, -509, -509, -509, 1379, 2, 66, -509, 610,
2013 46, 207, 208, 210, 216, 217, 224, 610, 610, 323,
2014 1342, 1379, 1379, -509, -509, -509, -509, -509, -509, -509,
2015 41, -509, -509, -509, 41, 205, 205, 326, 227, 238,
2016 1327, 1327, 1327, 1327, 1327, -509, -509, -46, 904, -99,
2017 -509, -56, -509, 1327, 1327, 1327, 19, -509, 1184, -509,
2018 -509, -509, -509, -509, -509, -509, -509, 312, 1327, -509,
2019 -509, -509, -509, 244, -509, 248, 739, 610, 610, 10,
2020 -509, 15, -509, -509, 739, 246, 1379, 1379, 1379, 1379,
2021 1379, 249, 252, 1379, 739, 610, 253, -509, -509, -509,
2022 -509, -509, -509, 1379, 1327, 1327, -509, 254, 257, 258,
2023 259, 1327, -509, 260, 863, -54, -509, -509, 261, 262,
2024 359, 380, 398, -509, 205, -509, 181, 266, 263, -509,
2025 388, -68, 399, 400, 267, 277, 283, 739, 408, 739,
2026 284, 285, 739, 288, 181, -509, 289, 290, 739, 739,
2027 181, 293, 291, 1379, 89, 295, 299, -24, 1327, 1327,
2028 1327, 1327, -509, -509, 296, 1327, 1327, 1379, -509, -509,
2029 -509, 38, 1231, -509, 300, -509, 739, 739, 1379, 739,
2030 739, 291, -509, 291, 1379, 739, 304, 1379, 1379, 1379,
2031 -509, -509, 1379, 391, -509, 610, -509, 1327, 1327, -509,
2032 306, 303, 310, 311, -509, 316, 322, 154, -509, -509,
2033 -509, 181, 83, 428, 321, 324, 610, -23, -509, -509,
2034 -509, -509, -509, 309, 739, -509, -509, -509, 53, 291,
2035 335, 350, 1327, -509, 1327, 1327, -509, -509, -509, 38,
2036 -509, 404, -509, 455, -1, -509, 1379, -509, -509, 351,
2037 -509, -509, -509, -509, 353, 355, 356, -509, 496, -509,
2038 739, -509, 993, 4, 14, 610, 87, -509, 41, -509,
2039 -509, -509, -509, -509, 362, -509, 993, -509, 488, 489,
2040 366, 14, 739, 739, 490, 439, -509, 739, 494, -509,
2044 /* YYPGOTO[NTERM-NUM]. */
2045 static const short int yypgoto[] =
2047 -509, 385, 387, 390, 276, 278, -164, -509, 0, -7,
2048 429, 8, -509, -509, -509, -509, 37, -509, -509, -509,
2049 -143, -308, -410, -509, -221, -509, -284, 17, -509, -296,
2050 -509, -509, -26, 305, -119, -509, 413, 424, -30, -151,
2051 -227, 103, 226, 298, -509, -509, 513, -509, -509, -509,
2052 -509, -509, -509, -509, -509, -509, -509, -509, 445, -509,
2053 -509, -509, -509, -509, -509, -508, -140, 96, -169, -509,
2054 476, -509, -509, -509, -509, -509, 51, 156, -509, -509,
2058 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2059 positive, shift that token. If negative, reduce the rule which
2060 number is the opposite. If zero, do what YYDEFACT says.
2061 If YYTABLE_NINF, syntax error. */
2062 #define YYTABLE_NINF -190
2063 static const short int yytable[] =
2065 11, 78, 266, 255, 157, 324, 461, 230, 13, 101,
2066 265, 158, 389, 372, 256, 265, 389, 11, 24, 87,
2067 298, 427, 339, 341, 267, 13, 429, 90, 26, 391,
2068 392, -55, -55, -55, -55, 302, 303, 304, 305, 306,
2069 401, 21, 309, 25, 564, 139, 128, -189, 105, 406,
2070 411, 231, 232, 129, 1, 22, 140, 3, 570, 5,
2071 428, 28, -64, 1, 2, 428, 3, 4, 5, 412,
2072 310, 401, 131, 27, 6, 7, 105, 80, 81, 43,
2073 465, 139, 131, 401, 85, 401, 155, 146, 57, 11,
2074 86, 529, 224, 401, 407, 8, 454, 146, 9, 107,
2075 402, 108, 10, 49, 50, 51, 58, 322, 52, 221,
2076 222, 405, 227, 225, 411, 474, 536, 228, 460, 489,
2077 537, 361, 568, 361, 361, 554, 361, 59, 313, 314,
2078 107, 421, 108, 61, 1, 159, 321, 3, 261, 5,
2079 87, 369, 107, 386, 108, 551, 315, 316, 366, 94,
2080 565, 91, 313, 314, 102, 313, 314, 571, 484, 361,
2081 95, 296, 297, 261, 299, 258, 2, 361, 361, 4,
2082 315, 316, 387, 315, 316, 388, 96, 300, 261, 261,
2083 261, 261, 261, 307, 308, 261, 107, 510, 108, 511,
2084 374, 384, 536, 131, 389, 99, 540, 313, 314, 114,
2085 115, 313, 314, 146, 98, 371, 107, 433, 108, 435,
2086 436, 437, 142, 143, 387, 315, 316, 388, 387, 315,
2087 316, 388, 233, 234, 235, 236, 361, 361, 361, 107,
2088 83, 108, 486, 263, 361, 541, 264, 37, 38, 39,
2089 -188, 146, 502, 100, 361, 361, 135, 45, 389, 46,
2090 389, 136, 367, 255, 156, -64, 1, 2, 219, 3,
2091 4, 5, 63, 64, 256, 311, 312, 6, 7, 368,
2092 217, 1, 2, 223, 3, 4, 5, 117, 118, 119,
2093 120, 121, 122, 220, 146, 385, 261, 361, 8, 361,
2094 226, 9, 361, 229, 107, 10, 108, 528, 361, 361,
2095 396, 397, 398, 399, 400, 512, 109, 110, 515, 516,
2096 517, -56, 404, 408, 409, 410, 556, -57, 82, 558,
2097 83, 107, 416, 108, 237, 259, 361, 361, 265, 361,
2098 361, 111, 323, 112, 330, 361, 331, 332, 342, 333,
2099 334, 343, 344, 345, 346, 361, 375, 376, 348, 377,
2100 261, 434, 261, 261, 261, 378, 379, 440, 383, 363,
2101 364, 393, 365, 380, 445, 446, 361, 444, 419, 394,
2102 552, 452, 63, 64, 361, 103, 66, 67, 68, 69,
2103 395, 1, 2, 422, 3, 4, 5, 423, 438, 566,
2104 432, 439, 443, 448, 457, 373, 449, 450, 451, 458,
2105 455, 456, 459, 381, 382, 462, 463, 464, 453, 468,
2106 361, 70, 472, 466, 467, 361, 469, 485, 490, 491,
2107 492, 493, 470, 474, 475, 495, 496, 477, 478, 479,
2108 483, 497, 361, 361, 487, 482, 501, 361, 488, 503,
2109 361, 428, 506, 514, 494, 522, 523, 532, 261, 524,
2110 525, 261, 261, 261, 548, 538, 506, 520, 521, 526,
2111 533, 498, 424, 425, 426, 527, 279, 280, 534, 550,
2112 431, 29, 30, 31, 32, 33, 34, 35, 542, 36,
2113 441, 442, 268, 269, 270, 271, 272, 273, 274, 275,
2114 276, 277, 544, 543, 545, 546, 559, 557, 560, 561,
2115 562, 569, 572, 573, 577, 574, 71, 578, 580, 72,
2116 555, 209, 73, 210, 74, 104, 211, 328, 126, 530,
2117 329, 141, 547, 471, 319, 473, 138, 327, 476, 498,
2118 44, 125, 93, 518, 480, 481, 281, 282, 283, 284,
2119 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2120 0, 0, 447, 0, 0, 0, 0, 0, 0, 0,
2121 0, 0, 504, 505, 0, 508, 509, 37, 38, 39,
2122 0, 513, 0, 63, 64, 0, 103, 66, 67, 68,
2123 69, 519, 1, 2, 0, 3, 4, 5, 0, 0,
2124 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2125 0, 0, 535, 0, 0, 0, 0, 0, 0, 0,
2126 539, 0, 70, 349, 350, 0, 0, 63, 64, 351,
2127 0, 0, 0, 0, 0, 0, 1, 2, 0, 3,
2128 4, 5, 352, 353, 354, 0, 0, 0, 0, 0,
2129 0, 0, 0, 0, 0, 0, 563, 355, 356, 0,
2130 0, 567, 0, 0, 0, 0, 0, 0, 0, 0,
2131 0, 0, 0, 0, 357, 0, 0, 0, 575, 576,
2132 0, 0, 0, 579, 0, 0, 581, 0, 0, 0,
2133 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
2134 180, 181, 182, 183, 184, 241, 242, 0, 0, 0,
2135 0, 0, 0, 0, 0, 0, 0, 71, 0, 0,
2136 72, 0, 0, 73, 0, 74, 137, 0, 0, 0,
2137 0, 0, 243, 191, 192, 193, 194, 195, 196, 197,
2138 198, 199, 200, 201, 202, 0, 244, 0, 245, 246,
2139 247, 0, 349, 350, 0, 0, 63, 64, 351, 0,
2140 107, 0, 108, 0, 0, 1, 2, 358, 3, 4,
2141 5, 352, 353, 354, 0, 0, 0, 0, 0, 0,
2142 0, 0, 0, 0, 0, 0, 355, 356, 0, 0,
2143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2144 0, 0, 0, 357, 0, 0, 0, 0, 0, 0,
2145 0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
2146 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
2147 181, 182, 183, 184, 241, 242, 0, 63, 64, 0,
2148 103, 149, 150, 151, 69, 0, 1, 2, 0, 3,
2149 4, 5, 0, 0, 0, 0, 0, 0, 0, 0,
2150 0, 243, 191, 192, 193, 194, 195, 196, 197, 198,
2151 199, 200, 201, 202, 0, 244, 70, 245, 246, 247,
2152 63, 64, 0, 0, 0, 0, 0, 0, 0, 1,
2153 2, 0, 3, 4, 5, 238, 358, 0, 0, 0,
2154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2155 239, 240, 0, 0, 0, 0, 0, 0, 0, 0,
2156 0, 63, 64, 0, 103, 149, 150, 151, 69, 0,
2157 1, 2, 0, 3, 4, 5, 0, 0, 0, 0,
2158 0, 0, 0, 170, 171, 172, 173, 174, 175, 176,
2159 177, 178, 179, 180, 181, 182, 183, 184, 241, 242,
2160 70, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2161 0, 71, 0, 0, 72, 0, 0, 73, 0, 74,
2162 340, 0, 0, 0, 0, 243, 191, 192, 193, 194,
2163 195, 196, 197, 198, 199, 200, 201, 202, 0, 244,
2164 0, 245, 246, 247, 0, 0, 349, 350, 0, 0,
2165 0, 0, 351, 107, 0, 108, 0, 248, 0, 0,
2166 249, 0, 250, 0, 251, 352, 353, 354, 0, 0,
2167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2168 355, 356, 0, 0, 0, 0, 0, 0, 0, 0,
2169 0, 0, 0, 0, 0, 71, 0, 357, 72, 0,
2170 0, 73, 0, 74, 403, 0, 0, 0, 0, 0,
2171 0, 0, 0, 170, 171, 172, 173, 174, 175, 176,
2172 177, 178, 179, 180, 181, 182, 183, 184, 241, 242,
2173 0, 0, 0, 0, 0, 0, 0, 0, 0, 63,
2174 64, 0, 103, 66, 67, 68, 69, 0, 1, 2,
2175 0, 3, 4, 5, 0, 243, 191, 192, 193, 194,
2176 195, 196, 197, 198, 199, 200, 201, 202, 130, 244,
2177 0, 245, 246, 247, 0, 0, 0, 0, 70, 63,
2178 64, 0, 144, 66, 67, 68, 69, 0, 1, 2,
2179 358, 3, 4, 5, 63, 64, 0, 103, 66, 67,
2180 68, 69, 0, 1, 2, 0, 3, 4, 5, 0,
2181 0, 0, 0, 0, 0, 0, 0, 0, 70, 0,
2182 0, 0, 0, 318, 0, 63, 64, 0, 103, 149,
2183 150, 151, 69, 70, 1, 2, 0, 3, 4, 5,
2184 0, 63, 64, 0, 103, 66, 67, 68, 69, 0,
2185 1, 2, 0, 3, 4, 5, 0, 0, 0, 0,
2186 0, 0, 0, 0, 70, 0, 0, 0, 0, 0,
2187 415, 0, 0, 71, 0, 0, 72, 0, 0, 73,
2188 70, 74, 0, 0, 0, 0, 0, 0, 63, 64,
2189 145, 103, 66, 67, 68, 69, 0, 1, 2, 0,
2190 3, 4, 5, 0, 0, 0, 0, 0, 0, 0,
2191 0, 0, 0, 71, 0, 0, 72, 500, 0, 73,
2192 0, 74, 0, 0, 0, 0, 0, 70, 71, 0,
2193 0, 72, 0, 0, 73, 0, 74, 63, 64, 0,
2194 65, 66, 67, 68, 69, 0, 1, 2, 0, 3,
2195 4, 5, 0, 0, 0, 0, 0, 0, 0, 71,
2196 0, 0, 72, 0, 335, 73, 0, 74, 0, 0,
2197 0, 0, 0, 0, 0, 71, 70, 0, 72, 0,
2198 0, 73, 0, 74, 63, 64, 0, 103, 149, 150,
2199 151, 69, 0, 1, 2, 0, 3, 4, 5, 63,
2200 64, 0, 144, 66, 67, 68, 69, 0, 1, 2,
2201 0, 3, 4, 5, 0, 0, 0, 0, 0, 0,
2202 0, 0, 71, 70, 0, 72, 0, 0, 73, 0,
2203 74, 0, 0, 0, 0, 0, 63, 64, 70, 103,
2204 66, 67, 68, 69, 0, 1, 2, 0, 3, 4,
2205 5, 63, 64, 0, 260, 66, 67, 68, 69, 0,
2206 1, 2, 0, 3, 4, 5, 0, 0, 0, 0,
2207 0, 71, 0, 0, 72, 70, 0, 73, 0, 74,
2208 0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2209 70, 103, 149, 150, 151, 69, 0, 1, 2, 0,
2210 3, 4, 5, 0, 0, 0, 0, 0, 0, 0,
2211 0, 0, 0, 0, 0, 0, 0, 0, 71, 0,
2212 0, 72, 0, 0, 73, 0, 74, 70, 0, 0,
2213 0, 0, 0, 71, 0, 0, 72, 0, 0, 73,
2214 0, 74, 0, 0, 0, 0, 0, 0, 0, 0,
2215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2216 0, 0, 0, 161, 0, 0, 0, 0, 0, 0,
2217 71, 0, 0, 72, 0, 0, 73, 0, 74, 0,
2218 0, 0, 162, 163, 0, 71, 0, 0, 72, 0,
2219 0, 73, 0, 74, 164, 165, 166, 167, 168, 169,
2220 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
2221 180, 181, 182, 183, 184, 185, 186, 0, 0, 0,
2222 0, 0, 71, 0, 0, 72, 0, 0, 73, 0,
2223 338, 0, 0, 0, 0, 0, 0, 187, 188, 189,
2224 0, 0, 190, 191, 192, 193, 194, 195, 196, 197,
2225 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
2229 static const short int yycheck[] =
2231 0, 27, 166, 154, 123, 226, 416, 147, 0, 4,
2232 11, 25, 320, 297, 154, 11, 324, 17, 138, 18,
2233 189, 11, 249, 250, 167, 17, 11, 26, 138, 325,
2234 326, 3, 4, 5, 6, 204, 205, 206, 207, 208,
2235 139, 49, 211, 54, 552, 139, 139, 0, 74, 148,
2236 31, 23, 24, 146, 16, 63, 150, 19, 566, 21,
2237 50, 138, 15, 16, 17, 50, 19, 20, 21, 50,
2238 213, 139, 98, 15, 27, 28, 102, 40, 41, 0,
2239 148, 139, 108, 139, 47, 139, 116, 113, 138, 89,
2240 53, 501, 150, 139, 150, 48, 150, 123, 51, 140,
2241 146, 142, 55, 39, 40, 41, 138, 148, 44, 135,
2242 136, 338, 142, 139, 31, 139, 139, 143, 414, 143,
2243 143, 261, 35, 263, 264, 535, 266, 144, 114, 115,
2244 140, 358, 142, 19, 16, 149, 146, 19, 164, 21,
2245 18, 139, 140, 312, 142, 146, 132, 133, 267, 19,
2246 146, 150, 114, 115, 149, 114, 115, 567, 442, 299,
2247 19, 187, 188, 189, 190, 157, 17, 307, 308, 20,
2248 132, 133, 131, 132, 133, 134, 19, 203, 204, 205,
2249 206, 207, 208, 209, 210, 211, 140, 471, 142, 473,
2250 144, 310, 139, 219, 502, 4, 143, 114, 115, 29,
2251 30, 114, 115, 229, 142, 139, 140, 376, 142, 378,
2252 379, 380, 109, 110, 131, 132, 133, 134, 131, 132,
2253 133, 134, 3, 4, 5, 6, 366, 367, 368, 140,
2254 34, 142, 143, 11, 374, 519, 14, 135, 136, 137,
2255 0, 267, 463, 4, 384, 385, 145, 43, 556, 45,
2256 558, 145, 278, 404, 4, 15, 16, 17, 139, 19,
2257 20, 21, 7, 8, 404, 110, 111, 27, 28, 295,
2258 19, 16, 17, 148, 19, 20, 21, 57, 58, 59,
2259 60, 61, 62, 143, 310, 311, 312, 427, 48, 429,
2260 143, 51, 432, 142, 140, 55, 142, 143, 438, 439,
2261 330, 331, 332, 333, 334, 474, 80, 81, 477, 478,
2262 479, 9, 338, 343, 344, 345, 537, 9, 32, 540,
2263 34, 140, 348, 142, 9, 52, 466, 467, 11, 469,
2264 470, 39, 148, 41, 142, 475, 142, 142, 19, 142,
2265 142, 142, 142, 142, 139, 485, 139, 139, 142, 139,
2266 376, 377, 378, 379, 380, 139, 139, 383, 35, 263,
2267 264, 35, 266, 139, 394, 395, 506, 393, 56, 142,
2268 534, 401, 7, 8, 514, 10, 11, 12, 13, 14,
2269 142, 16, 17, 139, 19, 20, 21, 139, 139, 553,
2270 144, 139, 139, 139, 35, 299, 139, 139, 139, 19,
2271 139, 139, 4, 307, 308, 139, 143, 19, 148, 142,
2272 550, 46, 4, 14, 14, 555, 139, 443, 448, 449,
2273 450, 451, 139, 139, 139, 455, 456, 139, 139, 139,
2274 139, 457, 572, 573, 139, 142, 462, 577, 139, 139,
2275 580, 50, 468, 139, 148, 139, 143, 19, 474, 139,
2276 139, 477, 478, 479, 50, 146, 482, 487, 488, 143,
2277 139, 461, 366, 367, 368, 143, 23, 24, 144, 14,
2278 374, 39, 40, 41, 42, 43, 44, 45, 143, 47,
2279 384, 385, 87, 88, 89, 90, 91, 92, 93, 94,
2280 95, 96, 522, 143, 524, 525, 143, 146, 143, 143,
2281 4, 139, 14, 14, 14, 139, 141, 68, 14, 144,
2282 536, 126, 147, 126, 149, 150, 126, 241, 89, 502,
2283 242, 108, 529, 427, 219, 429, 102, 229, 432, 529,
2284 17, 86, 56, 482, 438, 439, 93, 94, 95, 96,
2285 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
2286 -1, -1, 396, -1, -1, -1, -1, -1, -1, -1,
2287 -1, -1, 466, 467, -1, 469, 470, 135, 136, 137,
2288 -1, 475, -1, 7, 8, -1, 10, 11, 12, 13,
2289 14, 485, 16, 17, -1, 19, 20, 21, -1, -1,
2290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2291 -1, -1, 506, -1, -1, -1, -1, -1, -1, -1,
2292 514, -1, 46, 3, 4, -1, -1, 7, 8, 9,
2293 -1, -1, -1, -1, -1, -1, 16, 17, -1, 19,
2294 20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
2295 -1, -1, -1, -1, -1, -1, 550, 37, 38, -1,
2296 -1, 555, -1, -1, -1, -1, -1, -1, -1, -1,
2297 -1, -1, -1, -1, 54, -1, -1, -1, 572, 573,
2298 -1, -1, -1, 577, -1, -1, 580, -1, -1, -1,
2299 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
2300 80, 81, 82, 83, 84, 85, 86, -1, -1, -1,
2301 -1, -1, -1, -1, -1, -1, -1, 141, -1, -1,
2302 144, -1, -1, 147, -1, 149, 150, -1, -1, -1,
2303 -1, -1, 112, 113, 114, 115, 116, 117, 118, 119,
2304 120, 121, 122, 123, 124, -1, 126, -1, 128, 129,
2305 130, -1, 3, 4, -1, -1, 7, 8, 9, -1,
2306 140, -1, 142, -1, -1, 16, 17, 147, 19, 20,
2307 21, 22, 23, 24, -1, -1, -1, -1, -1, -1,
2308 -1, -1, -1, -1, -1, -1, 37, 38, -1, -1,
2309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2310 -1, -1, -1, 54, -1, -1, -1, -1, -1, -1,
2311 -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
2312 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2313 81, 82, 83, 84, 85, 86, -1, 7, 8, -1,
2314 10, 11, 12, 13, 14, -1, 16, 17, -1, 19,
2315 20, 21, -1, -1, -1, -1, -1, -1, -1, -1,
2316 -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
2317 121, 122, 123, 124, -1, 126, 46, 128, 129, 130,
2318 7, 8, -1, -1, -1, -1, -1, -1, -1, 16,
2319 17, -1, 19, 20, 21, 22, 147, -1, -1, -1,
2320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2321 37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
2322 -1, 7, 8, -1, 10, 11, 12, 13, 14, -1,
2323 16, 17, -1, 19, 20, 21, -1, -1, -1, -1,
2324 -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
2325 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2326 46, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2327 -1, 141, -1, -1, 144, -1, -1, 147, -1, 149,
2328 150, -1, -1, -1, -1, 112, 113, 114, 115, 116,
2329 117, 118, 119, 120, 121, 122, 123, 124, -1, 126,
2330 -1, 128, 129, 130, -1, -1, 3, 4, -1, -1,
2331 -1, -1, 9, 140, -1, 142, -1, 144, -1, -1,
2332 147, -1, 149, -1, 151, 22, 23, 24, -1, -1,
2333 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2334 37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
2335 -1, -1, -1, -1, -1, 141, -1, 54, 144, -1,
2336 -1, 147, -1, 149, 150, -1, -1, -1, -1, -1,
2337 -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
2338 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2339 -1, -1, -1, -1, -1, -1, -1, -1, -1, 7,
2340 8, -1, 10, 11, 12, 13, 14, -1, 16, 17,
2341 -1, 19, 20, 21, -1, 112, 113, 114, 115, 116,
2342 117, 118, 119, 120, 121, 122, 123, 124, 36, 126,
2343 -1, 128, 129, 130, -1, -1, -1, -1, 46, 7,
2344 8, -1, 10, 11, 12, 13, 14, -1, 16, 17,
2345 147, 19, 20, 21, 7, 8, -1, 10, 11, 12,
2346 13, 14, -1, 16, 17, -1, 19, 20, 21, -1,
2347 -1, -1, -1, -1, -1, -1, -1, -1, 46, -1,
2348 -1, -1, -1, 36, -1, 7, 8, -1, 10, 11,
2349 12, 13, 14, 46, 16, 17, -1, 19, 20, 21,
2350 -1, 7, 8, -1, 10, 11, 12, 13, 14, -1,
2351 16, 17, -1, 19, 20, 21, -1, -1, -1, -1,
2352 -1, -1, -1, -1, 46, -1, -1, -1, -1, -1,
2353 36, -1, -1, 141, -1, -1, 144, -1, -1, 147,
2354 46, 149, -1, -1, -1, -1, -1, -1, 7, 8,
2355 118, 10, 11, 12, 13, 14, -1, 16, 17, -1,
2356 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2357 -1, -1, -1, 141, -1, -1, 144, 36, -1, 147,
2358 -1, 149, -1, -1, -1, -1, -1, 46, 141, -1,
2359 -1, 144, -1, -1, 147, -1, 149, 7, 8, -1,
2360 10, 11, 12, 13, 14, -1, 16, 17, -1, 19,
2361 20, 21, -1, -1, -1, -1, -1, -1, -1, 141,
2362 -1, -1, 144, -1, 146, 147, -1, 149, -1, -1,
2363 -1, -1, -1, -1, -1, 141, 46, -1, 144, -1,
2364 -1, 147, -1, 149, 7, 8, -1, 10, 11, 12,
2365 13, 14, -1, 16, 17, -1, 19, 20, 21, 7,
2366 8, -1, 10, 11, 12, 13, 14, -1, 16, 17,
2367 -1, 19, 20, 21, -1, -1, -1, -1, -1, -1,
2368 -1, -1, 141, 46, -1, 144, -1, -1, 147, -1,
2369 149, -1, -1, -1, -1, -1, 7, 8, 46, 10,
2370 11, 12, 13, 14, -1, 16, 17, -1, 19, 20,
2371 21, 7, 8, -1, 10, 11, 12, 13, 14, -1,
2372 16, 17, -1, 19, 20, 21, -1, -1, -1, -1,
2373 -1, 141, -1, -1, 144, 46, -1, 147, -1, 149,
2374 -1, -1, -1, -1, -1, -1, -1, -1, 7, 8,
2375 46, 10, 11, 12, 13, 14, -1, 16, 17, -1,
2376 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2377 -1, -1, -1, -1, -1, -1, -1, -1, 141, -1,
2378 -1, 144, -1, -1, 147, -1, 149, 46, -1, -1,
2379 -1, -1, -1, 141, -1, -1, 144, -1, -1, 147,
2380 -1, 149, -1, -1, -1, -1, -1, -1, -1, -1,
2381 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2382 -1, -1, -1, 33, -1, -1, -1, -1, -1, -1,
2383 141, -1, -1, 144, -1, -1, 147, -1, 149, -1,
2384 -1, -1, 52, 53, -1, 141, -1, -1, 144, -1,
2385 -1, 147, -1, 149, 64, 65, 66, 67, 68, 69,
2386 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
2387 80, 81, 82, 83, 84, 85, 86, -1, -1, -1,
2388 -1, -1, 141, -1, -1, 144, -1, -1, 147, -1,
2389 149, -1, -1, -1, -1, -1, -1, 107, 108, 109,
2390 -1, -1, 112, 113, 114, 115, 116, 117, 118, 119,
2391 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2395 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2396 symbol of state STATE-NUM. */
2397 static const unsigned char yystos[] =
2399 0, 16, 17, 19, 20, 21, 27, 28, 48, 51,
2400 55, 160, 162, 163, 164, 165, 196, 197, 198, 200,
2401 199, 49, 63, 205, 138, 54, 138, 15, 138, 39,
2402 40, 41, 42, 43, 44, 45, 47, 135, 136, 137,
2403 166, 167, 168, 0, 198, 43, 45, 169, 215, 39,
2404 40, 41, 44, 170, 212, 214, 221, 138, 138, 144,
2405 206, 19, 204, 7, 8, 10, 11, 12, 13, 14,
2406 46, 141, 144, 147, 149, 160, 163, 183, 184, 218,
2407 168, 168, 32, 34, 194, 168, 168, 18, 222, 223,
2408 26, 150, 213, 222, 19, 19, 19, 207, 142, 4,
2409 4, 4, 149, 10, 150, 184, 189, 140, 142, 194,
2410 194, 39, 41, 171, 29, 30, 193, 57, 58, 59,
2411 60, 61, 62, 172, 210, 210, 162, 226, 139, 146,
2412 36, 184, 185, 187, 188, 145, 145, 150, 189, 139,
2413 150, 188, 193, 193, 10, 118, 184, 186, 195, 11,
2414 12, 13, 158, 159, 184, 190, 4, 186, 25, 149,
2415 211, 33, 52, 53, 64, 65, 66, 67, 68, 69,
2416 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
2417 80, 81, 82, 83, 84, 85, 86, 107, 108, 109,
2418 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2419 122, 123, 124, 125, 126, 127, 128, 129, 130, 153,
2420 154, 155, 224, 230, 231, 232, 233, 19, 174, 139,
2421 143, 184, 184, 148, 150, 184, 143, 190, 184, 142,
2422 218, 23, 24, 3, 4, 5, 6, 9, 22, 37,
2423 38, 85, 86, 112, 126, 128, 129, 130, 144, 147,
2424 149, 151, 153, 154, 155, 191, 218, 201, 163, 52,
2425 10, 184, 220, 11, 14, 11, 158, 172, 87, 88,
2426 89, 90, 91, 92, 93, 94, 95, 96, 156, 23,
2427 24, 93, 94, 95, 96, 97, 98, 99, 100, 101,
2428 102, 103, 104, 105, 106, 157, 184, 184, 220, 184,
2429 184, 227, 220, 220, 220, 220, 220, 184, 184, 220,
2430 172, 110, 111, 114, 115, 132, 133, 173, 36, 185,
2431 176, 146, 148, 148, 176, 202, 203, 195, 156, 157,
2432 142, 142, 142, 142, 142, 146, 190, 192, 149, 192,
2433 150, 192, 19, 142, 142, 142, 139, 181, 142, 3,
2434 4, 9, 22, 23, 24, 37, 38, 54, 147, 191,
2435 217, 218, 219, 219, 219, 219, 186, 184, 184, 139,
2436 178, 139, 178, 219, 144, 139, 139, 139, 139, 139,
2437 139, 219, 219, 35, 186, 184, 220, 131, 134, 173,
2438 175, 181, 181, 35, 142, 142, 190, 190, 190, 190,
2439 190, 139, 146, 150, 184, 192, 148, 150, 190, 190,
2440 190, 31, 50, 179, 182, 36, 184, 208, 209, 56,
2441 216, 192, 139, 139, 219, 219, 219, 11, 50, 11,
2442 229, 219, 144, 220, 184, 220, 220, 220, 139, 139,
2443 184, 219, 219, 139, 184, 190, 190, 229, 139, 139,
2444 139, 139, 190, 148, 150, 139, 139, 35, 19, 4,
2445 181, 174, 139, 143, 19, 148, 14, 14, 142, 139,
2446 139, 219, 4, 219, 139, 139, 219, 139, 139, 139,
2447 219, 219, 142, 139, 178, 184, 143, 139, 139, 143,
2448 190, 190, 190, 190, 148, 190, 190, 184, 160, 161,
2449 36, 184, 176, 139, 219, 219, 184, 228, 219, 219,
2450 178, 178, 220, 219, 139, 220, 220, 220, 228, 219,
2451 190, 190, 139, 143, 139, 139, 143, 143, 143, 174,
2452 179, 180, 19, 139, 144, 219, 139, 143, 146, 219,
2453 143, 178, 143, 143, 190, 190, 190, 161, 50, 177,
2454 14, 146, 158, 225, 174, 184, 176, 146, 176, 143,
2455 143, 143, 4, 219, 217, 146, 158, 219, 35, 139,
2456 217, 174, 14, 14, 139, 219, 219, 14, 68, 219,
2460 #define yyerrok (yyerrstatus = 0)
2461 #define yyclearin (yychar = YYEMPTY)
2462 #define YYEMPTY (-2)
2465 #define YYACCEPT goto yyacceptlab
2466 #define YYABORT goto yyabortlab
2467 #define YYERROR goto yyerrorlab
2470 /* Like YYERROR except do call yyerror. This remains here temporarily
2471 to ease the transition to the new meaning of YYERROR, for GCC.
2472 Once GCC version 2 has supplanted version 1, this can go. */
2474 #define YYFAIL goto yyerrlab
2476 #define YYRECOVERING() (!!yyerrstatus)
2478 #define YYBACKUP(Token, Value) \
2480 if (yychar == YYEMPTY && yylen == 1) \
2484 yytoken = YYTRANSLATE (yychar); \
2490 yyerror (YY_("syntax error: cannot back up")); \
2497 #define YYERRCODE 256
2500 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2501 If N is 0, then set CURRENT to the empty location which ends
2502 the previous symbol: RHS[0] (always defined). */
2504 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2505 #ifndef YYLLOC_DEFAULT
2506 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2510 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
2511 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
2512 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
2513 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
2517 (Current).first_line = (Current).last_line = \
2518 YYRHSLOC (Rhs, 0).last_line; \
2519 (Current).first_column = (Current).last_column = \
2520 YYRHSLOC (Rhs, 0).last_column; \
2526 /* YY_LOCATION_PRINT -- Print the location on the stream.
2527 This macro was not mandated originally: define only if we know
2528 we won't break user code: when these are the locations we know. */
2530 #ifndef YY_LOCATION_PRINT
2531 # if YYLTYPE_IS_TRIVIAL
2532 # define YY_LOCATION_PRINT(File, Loc) \
2533 fprintf (File, "%d.%d-%d.%d", \
2534 (Loc).first_line, (Loc).first_column, \
2535 (Loc).last_line, (Loc).last_column)
2537 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2542 /* YYLEX -- calling `yylex' with the right arguments. */
2545 # define YYLEX yylex (YYLEX_PARAM)
2547 # define YYLEX yylex ()
2550 /* Enable debugging if requested. */
2554 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2555 # define YYFPRINTF fprintf
2558 # define YYDPRINTF(Args) \
2564 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2568 YYFPRINTF (stderr, "%s ", Title); \
2569 yysymprint (stderr, \
2571 YYFPRINTF (stderr, "\n"); \
2575 /*------------------------------------------------------------------.
2576 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2578 `------------------------------------------------------------------*/
2580 #if defined (__STDC__) || defined (__cplusplus)
2582 yy_stack_print (short int *bottom, short int *top)
2585 yy_stack_print (bottom, top)
2590 YYFPRINTF (stderr, "Stack now");
2591 for (/* Nothing. */; bottom <= top; ++bottom)
2592 YYFPRINTF (stderr, " %d", *bottom);
2593 YYFPRINTF (stderr, "\n");
2596 # define YY_STACK_PRINT(Bottom, Top) \
2599 yy_stack_print ((Bottom), (Top)); \
2603 /*------------------------------------------------.
2604 | Report that the YYRULE is going to be reduced. |
2605 `------------------------------------------------*/
2607 #if defined (__STDC__) || defined (__cplusplus)
2609 yy_reduce_print (int yyrule)
2612 yy_reduce_print (yyrule)
2617 unsigned long int yylno = yyrline[yyrule];
2618 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2620 /* Print the symbols being reduced, and their result. */
2621 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2622 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2623 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2626 # define YY_REDUCE_PRINT(Rule) \
2629 yy_reduce_print (Rule); \
2632 /* Nonzero means print parse trace. It is left uninitialized so that
2633 multiple parsers can coexist. */
2635 #else /* !YYDEBUG */
2636 # define YYDPRINTF(Args)
2637 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2638 # define YY_STACK_PRINT(Bottom, Top)
2639 # define YY_REDUCE_PRINT(Rule)
2640 #endif /* !YYDEBUG */
2643 /* YYINITDEPTH -- initial size of the parser's stacks. */
2645 # define YYINITDEPTH 200
2648 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2649 if the built-in stack extension method is used).
2651 Do not make this value too large; the results are undefined if
2652 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2653 evaluated with infinite-precision integer arithmetic. */
2656 # define YYMAXDEPTH 10000
2664 # if defined (__GLIBC__) && defined (_STRING_H)
2665 # define yystrlen strlen
2667 /* Return the length of YYSTR. */
2669 # if defined (__STDC__) || defined (__cplusplus)
2670 yystrlen (const char *yystr)
2676 const char *yys = yystr;
2678 while (*yys++ != '\0')
2681 return yys - yystr - 1;
2687 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
2688 # define yystpcpy stpcpy
2690 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2693 # if defined (__STDC__) || defined (__cplusplus)
2694 yystpcpy (char *yydest, const char *yysrc)
2696 yystpcpy (yydest, yysrc)
2702 const char *yys = yysrc;
2704 while ((*yyd++ = *yys++) != '\0')
2713 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2714 quotes and backslashes, so that it's suitable for yyerror. The
2715 heuristic is that double-quoting is unnecessary unless the string
2716 contains an apostrophe, a comma, or backslash (other than
2717 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2718 null, do not copy; instead, return the length of what the result
2721 yytnamerr (char *yyres, const char *yystr)
2726 char const *yyp = yystr;
2733 goto do_not_strip_quotes;
2737 goto do_not_strip_quotes;
2750 do_not_strip_quotes: ;
2754 return yystrlen (yystr);
2756 return yystpcpy (yyres, yystr) - yyres;
2760 #endif /* YYERROR_VERBOSE */
2765 /*--------------------------------.
2766 | Print this symbol on YYOUTPUT. |
2767 `--------------------------------*/
2769 #if defined (__STDC__) || defined (__cplusplus)
2771 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
2774 yysymprint (yyoutput, yytype, yyvaluep)
2780 /* Pacify ``unused variable'' warnings. */
2783 if (yytype < YYNTOKENS)
2784 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2786 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2790 if (yytype < YYNTOKENS)
2791 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2798 YYFPRINTF (yyoutput, ")");
2801 #endif /* ! YYDEBUG */
2802 /*-----------------------------------------------.
2803 | Release the memory associated to this symbol. |
2804 `-----------------------------------------------*/
2806 #if defined (__STDC__) || defined (__cplusplus)
2808 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2811 yydestruct (yymsg, yytype, yyvaluep)
2817 /* Pacify ``unused variable'' warnings. */
2822 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2833 /* Prevent warnings from -Wmissing-prototypes. */
2835 #ifdef YYPARSE_PARAM
2836 # if defined (__STDC__) || defined (__cplusplus)
2837 int yyparse (void *YYPARSE_PARAM);
2841 #else /* ! YYPARSE_PARAM */
2842 #if defined (__STDC__) || defined (__cplusplus)
2847 #endif /* ! YYPARSE_PARAM */
2851 /* The look-ahead symbol. */
2854 /* The semantic value of the look-ahead symbol. */
2857 /* Number of syntax errors so far. */
2866 #ifdef YYPARSE_PARAM
2867 # if defined (__STDC__) || defined (__cplusplus)
2868 int yyparse (void *YYPARSE_PARAM)
2870 int yyparse (YYPARSE_PARAM)
2871 void *YYPARSE_PARAM;
2873 #else /* ! YYPARSE_PARAM */
2874 #if defined (__STDC__) || defined (__cplusplus)
2888 /* Number of tokens to shift before error messages enabled. */
2890 /* Look-ahead token as an internal (translated) token number. */
2893 /* Three stacks and their tools:
2894 `yyss': related to states,
2895 `yyvs': related to semantic values,
2896 `yyls': related to locations.
2898 Refer to the stacks thru separate pointers, to allow yyoverflow
2899 to reallocate them elsewhere. */
2901 /* The state stack. */
2902 short int yyssa[YYINITDEPTH];
2903 short int *yyss = yyssa;
2906 /* The semantic value stack. */
2907 YYSTYPE yyvsa[YYINITDEPTH];
2908 YYSTYPE *yyvs = yyvsa;
2913 #define YYPOPSTACK (yyvsp--, yyssp--)
2915 YYSIZE_T yystacksize = YYINITDEPTH;
2917 /* The variables used to return semantic value and location from the
2922 /* When reducing, the number of symbols on the RHS of the reduced
2926 YYDPRINTF ((stderr, "Starting parse\n"));
2931 yychar = YYEMPTY; /* Cause a token to be read. */
2933 /* Initialize stack pointers.
2934 Waste one element of value and location stack
2935 so that they stay on the same level as the state stack.
2936 The wasted elements are never initialized. */
2943 /*------------------------------------------------------------.
2944 | yynewstate -- Push a new state, which is found in yystate. |
2945 `------------------------------------------------------------*/
2947 /* In all cases, when you get here, the value and location stacks
2948 have just been pushed. so pushing a state here evens the stacks.
2955 if (yyss + yystacksize - 1 <= yyssp)
2957 /* Get the current used size of the three stacks, in elements. */
2958 YYSIZE_T yysize = yyssp - yyss + 1;
2962 /* Give user a chance to reallocate the stack. Use copies of
2963 these so that the &'s don't force the real ones into
2965 YYSTYPE *yyvs1 = yyvs;
2966 short int *yyss1 = yyss;
2969 /* Each stack pointer address is followed by the size of the
2970 data in use in that stack, in bytes. This used to be a
2971 conditional around just the two extra args, but that might
2972 be undefined if yyoverflow is a macro. */
2973 yyoverflow (YY_("memory exhausted"),
2974 &yyss1, yysize * sizeof (*yyssp),
2975 &yyvs1, yysize * sizeof (*yyvsp),
2982 #else /* no yyoverflow */
2983 # ifndef YYSTACK_RELOCATE
2984 goto yyexhaustedlab;
2986 /* Extend the stack our own way. */
2987 if (YYMAXDEPTH <= yystacksize)
2988 goto yyexhaustedlab;
2990 if (YYMAXDEPTH < yystacksize)
2991 yystacksize = YYMAXDEPTH;
2994 short int *yyss1 = yyss;
2995 union yyalloc *yyptr =
2996 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2998 goto yyexhaustedlab;
2999 YYSTACK_RELOCATE (yyss);
3000 YYSTACK_RELOCATE (yyvs);
3002 # undef YYSTACK_RELOCATE
3004 YYSTACK_FREE (yyss1);
3007 #endif /* no yyoverflow */
3009 yyssp = yyss + yysize - 1;
3010 yyvsp = yyvs + yysize - 1;
3013 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3014 (unsigned long int) yystacksize));
3016 if (yyss + yystacksize - 1 <= yyssp)
3020 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3029 /* Do appropriate processing given the current state. */
3030 /* Read a look-ahead token if we need one and don't already have one. */
3033 /* First try to decide what to do without reference to look-ahead token. */
3035 yyn = yypact[yystate];
3036 if (yyn == YYPACT_NINF)
3039 /* Not known => get a look-ahead token if don't already have one. */
3041 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3042 if (yychar == YYEMPTY)
3044 YYDPRINTF ((stderr, "Reading a token: "));
3048 if (yychar <= YYEOF)
3050 yychar = yytoken = YYEOF;
3051 YYDPRINTF ((stderr, "Now at end of input.\n"));
3055 yytoken = YYTRANSLATE (yychar);
3056 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3059 /* If the proper action on seeing token YYTOKEN is to reduce or to
3060 detect an error, take that action. */
3062 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3067 if (yyn == 0 || yyn == YYTABLE_NINF)
3076 /* Shift the look-ahead token. */
3077 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3079 /* Discard the token being shifted unless it is eof. */
3080 if (yychar != YYEOF)
3086 /* Count tokens shifted since error; after three, turn off error
3095 /*-----------------------------------------------------------.
3096 | yydefault -- do the default action for the current state. |
3097 `-----------------------------------------------------------*/
3099 yyn = yydefact[yystate];
3105 /*-----------------------------.
3106 | yyreduce -- Do a reduction. |
3107 `-----------------------------*/
3109 /* yyn is the number of a rule to reduce with. */
3112 /* If YYLEN is nonzero, implement the default value of the action:
3115 Otherwise, the following line sets YYVAL to garbage.
3116 This behavior is undocumented and Bison
3117 users should not rely upon it. Assigning to YYVAL
3118 unconditionally makes the parser a bit smaller, and it avoids a
3119 GCC warning that YYVAL may be used uninitialized. */
3120 yyval = yyvsp[1-yylen];
3123 YY_REDUCE_PRINT (yyn);
3127 #line 1122 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3128 { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
3132 #line 1122 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3133 { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
3137 #line 1123 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3138 { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
3142 #line 1123 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3143 { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
3147 #line 1124 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3148 { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
3152 #line 1124 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3153 { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
3157 #line 1125 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3158 { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
3162 #line 1125 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3163 { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
3167 #line 1126 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3168 { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
3172 #line 1126 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3173 { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
3177 #line 1130 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3178 { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
3182 #line 1130 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3183 { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
3187 #line 1131 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3188 { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
3192 #line 1131 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3193 { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
3197 #line 1132 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3198 { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
3202 #line 1132 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3203 { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
3207 #line 1133 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3208 { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
3212 #line 1133 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3213 { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
3217 #line 1134 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3218 { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
3222 #line 1134 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3223 { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
3227 #line 1135 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3228 { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
3232 #line 1135 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3233 { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
3237 #line 1136 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3238 { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
3242 #line 1136 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3243 { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
3247 #line 1137 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3248 { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
3252 #line 1138 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3253 { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
3257 #line 1147 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3258 { (yyval.StrVal) = 0; ;}
3262 #line 1151 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3264 (yyval.StrVal) = (yyvsp[-1].StrVal);
3270 #line 1155 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3278 #line 1163 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3286 #line 1168 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3288 (yyval.StrVal) = (yyvsp[-1].StrVal);
3294 #line 1174 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3295 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3299 #line 1175 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3300 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3304 #line 1176 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3305 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3309 #line 1177 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3310 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3314 #line 1178 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3315 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3319 #line 1182 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3320 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3324 #line 1183 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3325 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3329 #line 1184 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3330 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3334 #line 1188 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3335 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3339 #line 1189 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3340 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3344 #line 1190 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3345 { (yyval.Visibility) = GlobalValue::HiddenVisibility; ;}
3349 #line 1191 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3350 { (yyval.Visibility) = GlobalValue::ProtectedVisibility; ;}
3354 #line 1195 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3355 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3359 #line 1196 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3360 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3364 #line 1197 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3365 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3369 #line 1201 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3370 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3374 #line 1202 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3375 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3379 #line 1203 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3380 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3384 #line 1204 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3385 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3389 #line 1205 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3390 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3394 #line 1209 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3395 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3399 #line 1210 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3400 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3404 #line 1211 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3405 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3409 #line 1214 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3410 { (yyval.UIntVal) = CallingConv::C; ;}
3414 #line 1215 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3415 { (yyval.UIntVal) = CallingConv::C; ;}
3419 #line 1216 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3420 { (yyval.UIntVal) = CallingConv::Fast; ;}
3424 #line 1217 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3425 { (yyval.UIntVal) = CallingConv::Cold; ;}
3429 #line 1218 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3430 { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
3434 #line 1219 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3435 { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
3439 #line 1220 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3441 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
3442 GEN_ERROR("Calling conv too large");
3443 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3449 #line 1227 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3450 { (yyval.ParamAttrs) = ParamAttr::ZExt; ;}
3454 #line 1228 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3455 { (yyval.ParamAttrs) = ParamAttr::SExt; ;}
3459 #line 1229 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3460 { (yyval.ParamAttrs) = ParamAttr::InReg; ;}
3464 #line 1230 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3465 { (yyval.ParamAttrs) = ParamAttr::StructRet; ;}
3469 #line 1233 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3470 { (yyval.ParamAttrs) = ParamAttr::None; ;}
3474 #line 1234 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3476 (yyval.ParamAttrs) = (yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs);
3481 #line 1239 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3482 { (yyval.ParamAttrs) = ParamAttr::NoReturn; ;}
3486 #line 1240 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3487 { (yyval.ParamAttrs) = ParamAttr::NoUnwind; ;}
3491 #line 1244 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3492 { (yyval.ParamAttrs) = ParamAttr::None; ;}
3496 #line 1245 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3498 (yyval.ParamAttrs) = (yyvsp[-1].ParamAttrs) | (yyvsp[0].ParamAttrs);
3503 #line 1252 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3504 { (yyval.UIntVal) = 0; ;}
3508 #line 1253 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3510 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3511 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3512 GEN_ERROR("Alignment must be a power of two");
3518 #line 1259 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3519 { (yyval.UIntVal) = 0; ;}
3523 #line 1260 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3525 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3526 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3527 GEN_ERROR("Alignment must be a power of two");
3533 #line 1268 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3535 for (unsigned i = 0, e = (yyvsp[0].StrVal)->length(); i != e; ++i)
3536 if ((*(yyvsp[0].StrVal))[i] == '"' || (*(yyvsp[0].StrVal))[i] == '\\')
3537 GEN_ERROR("Invalid character in section name");
3538 (yyval.StrVal) = (yyvsp[0].StrVal);
3544 #line 1276 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3545 { (yyval.StrVal) = 0; ;}
3549 #line 1277 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3550 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
3554 #line 1282 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3559 #line 1283 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3564 #line 1284 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3566 CurGV->setSection(*(yyvsp[0].StrVal));
3567 delete (yyvsp[0].StrVal);
3573 #line 1289 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3575 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
3576 GEN_ERROR("Alignment must be a power of two");
3577 CurGV->setAlignment((yyvsp[0].UInt64Val));
3583 #line 1305 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3585 (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
3591 #line 1309 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3593 (yyval.TypeVal) = new PATypeHolder((yyvsp[0].PrimType));
3599 #line 1313 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3601 if (*(yyvsp[-1].TypeVal) == Type::LabelTy)
3602 GEN_ERROR("Cannot form a pointer to a basic block");
3603 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[-1].TypeVal))));
3604 delete (yyvsp[-1].TypeVal);
3610 #line 1320 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3611 { // Named types are also simple types...
3612 const Type* tmp = getTypeVal((yyvsp[0].ValIDVal));
3614 (yyval.TypeVal) = new PATypeHolder(tmp);
3619 #line 1325 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3620 { // Type UpReference
3621 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range");
3622 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
3623 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
3624 (yyval.TypeVal) = new PATypeHolder(OT);
3625 UR_OUT("New Upreference!\n");
3631 #line 1333 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3633 std::vector<const Type*> Params;
3634 ParamAttrsVector Attrs;
3635 if ((yyvsp[0].ParamAttrs) != ParamAttr::None) {
3636 ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[0].ParamAttrs);
3640 TypeWithAttrsList::iterator I = (yyvsp[-2].TypeWithAttrsList)->begin(), E = (yyvsp[-2].TypeWithAttrsList)->end();
3641 for (; I != E; ++I, ++index) {
3642 const Type *Ty = I->Ty->get();
3643 Params.push_back(Ty);
3644 if (Ty != Type::VoidTy)
3645 if (I->Attrs != ParamAttr::None) {
3646 ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs;
3650 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
3651 if (isVarArg) Params.pop_back();
3653 ParamAttrsList *ActualAttrs = 0;
3655 ActualAttrs = ParamAttrsList::get(Attrs);
3656 FunctionType *FT = FunctionType::get(*(yyvsp[-4].TypeVal), Params, isVarArg, ActualAttrs);
3657 delete (yyvsp[-2].TypeWithAttrsList); // Delete the argument list
3658 delete (yyvsp[-4].TypeVal); // Delete the return type handle
3659 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
3665 #line 1363 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3667 std::vector<const Type*> Params;
3668 ParamAttrsVector Attrs;
3669 if ((yyvsp[0].ParamAttrs) != ParamAttr::None) {
3670 ParamAttrsWithIndex X; X.index = 0; X.attrs = (yyvsp[0].ParamAttrs);
3673 TypeWithAttrsList::iterator I = (yyvsp[-2].TypeWithAttrsList)->begin(), E = (yyvsp[-2].TypeWithAttrsList)->end();
3675 for ( ; I != E; ++I, ++index) {
3676 const Type* Ty = I->Ty->get();
3677 Params.push_back(Ty);
3678 if (Ty != Type::VoidTy)
3679 if (I->Attrs != ParamAttr::None) {
3680 ParamAttrsWithIndex X; X.index = index; X.attrs = I->Attrs;
3684 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
3685 if (isVarArg) Params.pop_back();
3687 ParamAttrsList *ActualAttrs = 0;
3689 ActualAttrs = ParamAttrsList::get(Attrs);
3691 FunctionType *FT = FunctionType::get((yyvsp[-4].PrimType), Params, isVarArg, ActualAttrs);
3692 delete (yyvsp[-2].TypeWithAttrsList); // Delete the argument list
3693 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
3699 #line 1394 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3700 { // Sized array type?
3701 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
3702 delete (yyvsp[-1].TypeVal);
3708 #line 1399 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3710 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal)->get();
3711 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
3712 GEN_ERROR("Unsigned result not equal to signed result");
3713 if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
3714 GEN_ERROR("Element type of a VectorType must be primitive");
3715 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
3716 GEN_ERROR("Vector length should be a power of 2");
3717 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[-1].TypeVal), (unsigned)(yyvsp[-3].UInt64Val))));
3718 delete (yyvsp[-1].TypeVal);
3724 #line 1411 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3725 { // Structure type?
3726 std::vector<const Type*> Elements;
3727 for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[-1].TypeList)->begin(),
3728 E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
3729 Elements.push_back(*I);
3731 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
3732 delete (yyvsp[-1].TypeList);
3738 #line 1421 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3739 { // Empty structure type?
3740 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>()));
3746 #line 1425 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3748 std::vector<const Type*> Elements;
3749 for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[-2].TypeList)->begin(),
3750 E = (yyvsp[-2].TypeList)->end(); I != E; ++I)
3751 Elements.push_back(*I);
3753 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
3754 delete (yyvsp[-2].TypeList);
3760 #line 1435 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3761 { // Empty structure type?
3762 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
3768 #line 1442 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3770 (yyval.TypeWithAttrs).Ty = (yyvsp[-1].TypeVal);
3771 (yyval.TypeWithAttrs).Attrs = (yyvsp[0].ParamAttrs);
3776 #line 1449 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3778 if (!UpRefs.empty())
3779 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
3780 if (!(*(yyvsp[0].TypeVal))->isFirstClassType())
3781 GEN_ERROR("LLVM functions cannot return aggregate types");
3782 (yyval.TypeVal) = (yyvsp[0].TypeVal);
3787 #line 1456 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3789 (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
3794 #line 1461 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3796 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
3797 (yyval.TypeWithAttrsList)->push_back((yyvsp[0].TypeWithAttrs));
3803 #line 1466 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3805 ((yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList))->push_back((yyvsp[0].TypeWithAttrs));
3811 #line 1474 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3813 (yyval.TypeWithAttrsList)=(yyvsp[-2].TypeWithAttrsList);
3814 TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
3815 TWA.Ty = new PATypeHolder(Type::VoidTy);
3816 (yyval.TypeWithAttrsList)->push_back(TWA);
3822 #line 1481 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3824 (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
3825 TypeWithAttrs TWA; TWA.Attrs = ParamAttr::None;
3826 TWA.Ty = new PATypeHolder(Type::VoidTy);
3827 (yyval.TypeWithAttrsList)->push_back(TWA);
3833 #line 1488 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3835 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
3841 #line 1496 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3843 (yyval.TypeList) = new std::list<PATypeHolder>();
3844 (yyval.TypeList)->push_back(*(yyvsp[0].TypeVal));
3845 delete (yyvsp[0].TypeVal);
3851 #line 1502 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3853 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(*(yyvsp[0].TypeVal));
3854 delete (yyvsp[0].TypeVal);
3860 #line 1514 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3861 { // Nonempty unsized arr
3862 if (!UpRefs.empty())
3863 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
3864 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal)->get());
3866 GEN_ERROR("Cannot make array constant with type: '" +
3867 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3868 const Type *ETy = ATy->getElementType();
3869 int NumElements = ATy->getNumElements();
3871 // Verify that we have the correct size...
3872 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
3873 GEN_ERROR("Type mismatch: constant sized array initialized with " +
3874 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
3875 itostr(NumElements) + "");
3877 // Verify all elements are correct type!
3878 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
3879 if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
3880 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
3881 ETy->getDescription() +"' as required!\nIt is of type '"+
3882 (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
3885 (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[-1].ConstVector));
3886 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
3892 #line 1542 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3894 if (!UpRefs.empty())
3895 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
3896 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal)->get());
3898 GEN_ERROR("Cannot make array constant with type: '" +
3899 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
3901 int NumElements = ATy->getNumElements();
3902 if (NumElements != -1 && NumElements != 0)
3903 GEN_ERROR("Type mismatch: constant sized array initialized with 0"
3904 " arguments, but has size of " + itostr(NumElements) +"");
3905 (yyval.ConstVal) = ConstantArray::get(ATy, std::vector<Constant*>());
3906 delete (yyvsp[-2].TypeVal);
3912 #line 1558 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3914 if (!UpRefs.empty())
3915 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
3916 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal)->get());
3918 GEN_ERROR("Cannot make array constant with type: '" +
3919 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
3921 int NumElements = ATy->getNumElements();
3922 const Type *ETy = ATy->getElementType();
3923 if (NumElements != -1 && NumElements != int((yyvsp[0].StrVal)->length()))
3924 GEN_ERROR("Can't build string constant of size " +
3925 itostr((int)((yyvsp[0].StrVal)->length())) +
3926 " when array has size " + itostr(NumElements) + "");
3927 std::vector<Constant*> Vals;
3928 if (ETy == Type::Int8Ty) {
3929 for (unsigned i = 0; i < (yyvsp[0].StrVal)->length(); ++i)
3930 Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[0].StrVal))[i]));
3932 delete (yyvsp[0].StrVal);
3933 GEN_ERROR("Cannot build string arrays of non byte sized elements");
3935 delete (yyvsp[0].StrVal);
3936 (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
3937 delete (yyvsp[-2].TypeVal);
3943 #line 1585 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3944 { // Nonempty unsized arr
3945 if (!UpRefs.empty())
3946 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
3947 const VectorType *PTy = dyn_cast<VectorType>((yyvsp[-3].TypeVal)->get());
3949 GEN_ERROR("Cannot make packed constant with type: '" +
3950 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3951 const Type *ETy = PTy->getElementType();
3952 int NumElements = PTy->getNumElements();
3954 // Verify that we have the correct size...
3955 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
3956 GEN_ERROR("Type mismatch: constant sized packed initialized with " +
3957 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
3958 itostr(NumElements) + "");
3960 // Verify all elements are correct type!
3961 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
3962 if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
3963 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
3964 ETy->getDescription() +"' as required!\nIt is of type '"+
3965 (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
3968 (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[-1].ConstVector));
3969 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
3975 #line 1613 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
3977 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal)->get());
3979 GEN_ERROR("Cannot make struct constant with type: '" +
3980 (*(yyvsp[-3].TypeVal))->getDescription() + "'");
3982 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
3983 GEN_ERROR("Illegal number of initializers for structure type");
3985 // Check to ensure that constants are compatible with the type initializer!
3986 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i)
3987 if ((*(yyvsp[-1].ConstVector))[i]->getType() != STy->getElementType(i))
3988 GEN_ERROR("Expected type '" +
3989 STy->getElementType(i)->getDescription() +
3990 "' for element #" + utostr(i) +
3991 " of structure initializer");
3993 // Check to ensure that Type is not packed
3994 if (STy->isPacked())
3995 GEN_ERROR("Unpacked Initializer to vector type '" +
3996 STy->getDescription() + "'");
3998 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-1].ConstVector));
3999 delete (yyvsp[-3].TypeVal); delete (yyvsp[-1].ConstVector);
4005 #line 1639 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4007 if (!UpRefs.empty())
4008 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
4009 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal)->get());
4011 GEN_ERROR("Cannot make struct constant with type: '" +
4012 (*(yyvsp[-2].TypeVal))->getDescription() + "'");
4014 if (STy->getNumContainedTypes() != 0)
4015 GEN_ERROR("Illegal number of initializers for structure type");
4017 // Check to ensure that Type is not packed
4018 if (STy->isPacked())
4019 GEN_ERROR("Unpacked Initializer to vector type '" +
4020 STy->getDescription() + "'");
4022 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4023 delete (yyvsp[-2].TypeVal);
4029 #line 1659 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4031 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal)->get());
4033 GEN_ERROR("Cannot make struct constant with type: '" +
4034 (*(yyvsp[-5].TypeVal))->getDescription() + "'");
4036 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4037 GEN_ERROR("Illegal number of initializers for structure type");
4039 // Check to ensure that constants are compatible with the type initializer!
4040 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i)
4041 if ((*(yyvsp[-2].ConstVector))[i]->getType() != STy->getElementType(i))
4042 GEN_ERROR("Expected type '" +
4043 STy->getElementType(i)->getDescription() +
4044 "' for element #" + utostr(i) +
4045 " of structure initializer");
4047 // Check to ensure that Type is packed
4048 if (!STy->isPacked())
4049 GEN_ERROR("Vector initializer to non-vector type '" +
4050 STy->getDescription() + "'");
4052 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[-2].ConstVector));
4053 delete (yyvsp[-5].TypeVal); delete (yyvsp[-2].ConstVector);
4059 #line 1685 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4061 if (!UpRefs.empty())
4062 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
4063 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal)->get());
4065 GEN_ERROR("Cannot make struct constant with type: '" +
4066 (*(yyvsp[-4].TypeVal))->getDescription() + "'");
4068 if (STy->getNumContainedTypes() != 0)
4069 GEN_ERROR("Illegal number of initializers for structure type");
4071 // Check to ensure that Type is packed
4072 if (!STy->isPacked())
4073 GEN_ERROR("Vector initializer to non-vector type '" +
4074 STy->getDescription() + "'");
4076 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4077 delete (yyvsp[-4].TypeVal);
4083 #line 1705 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4085 if (!UpRefs.empty())
4086 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4087 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal)->get());
4089 GEN_ERROR("Cannot make null pointer constant with type: '" +
4090 (*(yyvsp[-1].TypeVal))->getDescription() + "'");
4092 (yyval.ConstVal) = ConstantPointerNull::get(PTy);
4093 delete (yyvsp[-1].TypeVal);
4099 #line 1717 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4101 if (!UpRefs.empty())
4102 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4103 (yyval.ConstVal) = UndefValue::get((yyvsp[-1].TypeVal)->get());
4104 delete (yyvsp[-1].TypeVal);
4110 #line 1724 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4112 if (!UpRefs.empty())
4113 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4114 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal)->get());
4116 GEN_ERROR("Global const reference must be a pointer type");
4118 // ConstExprs can exist in the body of a function, thus creating
4119 // GlobalValues whenever they refer to a variable. Because we are in
4120 // the context of a function, getExistingVal will search the functions
4121 // symbol table instead of the module symbol table for the global symbol,
4122 // which throws things all off. To get around this, we just tell
4123 // getExistingVal that we are at global scope here.
4125 Function *SavedCurFn = CurFun.CurrentFunction;
4126 CurFun.CurrentFunction = 0;
4128 Value *V = getExistingVal(Ty, (yyvsp[0].ValIDVal));
4131 CurFun.CurrentFunction = SavedCurFn;
4133 // If this is an initializer for a constant pointer, which is referencing a
4134 // (currently) undefined variable, create a stub now that shall be replaced
4135 // in the future with the right type of variable.
4138 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
4139 const PointerType *PT = cast<PointerType>(Ty);
4141 // First check to see if the forward references value is already created!
4142 PerModuleInfo::GlobalRefsType::iterator I =
4143 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4145 if (I != CurModule.GlobalRefs.end()) {
4146 V = I->second; // Placeholder already exists, use it...
4147 (yyvsp[0].ValIDVal).destroy();
4150 if ((yyvsp[0].ValIDVal).Type == ValID::GlobalName)
4151 Name = (yyvsp[0].ValIDVal).getName();
4152 else if ((yyvsp[0].ValIDVal).Type != ValID::GlobalID)
4153 GEN_ERROR("Invalid reference to global");
4155 // Create the forward referenced global.
4157 if (const FunctionType *FTy =
4158 dyn_cast<FunctionType>(PT->getElementType())) {
4159 GV = new Function(FTy, GlobalValue::ExternalWeakLinkage, Name,
4160 CurModule.CurrentModule);
4162 GV = new GlobalVariable(PT->getElementType(), false,
4163 GlobalValue::ExternalWeakLinkage, 0,
4164 Name, CurModule.CurrentModule);
4167 // Keep track of the fact that we have a forward ref to recycle it
4168 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4173 (yyval.ConstVal) = cast<GlobalValue>(V);
4174 delete (yyvsp[-1].TypeVal); // Free the type handle
4180 #line 1790 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4182 if (!UpRefs.empty())
4183 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4184 if ((yyvsp[-1].TypeVal)->get() != (yyvsp[0].ConstVal)->getType())
4185 GEN_ERROR("Mismatched types for constant expression: " +
4186 (*(yyvsp[-1].TypeVal))->getDescription() + " and " + (yyvsp[0].ConstVal)->getType()->getDescription());
4187 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4188 delete (yyvsp[-1].TypeVal);
4194 #line 1800 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4196 if (!UpRefs.empty())
4197 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4198 const Type *Ty = (yyvsp[-1].TypeVal)->get();
4199 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4200 GEN_ERROR("Cannot create a null initialized value of this type");
4201 (yyval.ConstVal) = Constant::getNullValue(Ty);
4202 delete (yyvsp[-1].TypeVal);
4208 #line 1810 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4209 { // integral constants
4210 if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val)))
4211 GEN_ERROR("Constant value doesn't fit in type");
4212 (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].SInt64Val), true);
4218 #line 1816 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4219 { // arbitrary precision integer constants
4220 uint32_t BitWidth = cast<IntegerType>((yyvsp[-1].PrimType))->getBitWidth();
4221 if ((yyvsp[0].APIntVal)->getBitWidth() > BitWidth) {
4222 GEN_ERROR("Constant value does not fit in type");
4224 (yyvsp[0].APIntVal)->sextOrTrunc(BitWidth);
4225 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[0].APIntVal));
4226 delete (yyvsp[0].APIntVal);
4232 #line 1826 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4233 { // integral constants
4234 if (!ConstantInt::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val)))
4235 GEN_ERROR("Constant value doesn't fit in type");
4236 (yyval.ConstVal) = ConstantInt::get((yyvsp[-1].PrimType), (yyvsp[0].UInt64Val), false);
4242 #line 1832 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4243 { // arbitrary precision integer constants
4244 uint32_t BitWidth = cast<IntegerType>((yyvsp[-1].PrimType))->getBitWidth();
4245 if ((yyvsp[0].APIntVal)->getBitWidth() > BitWidth) {
4246 GEN_ERROR("Constant value does not fit in type");
4248 (yyvsp[0].APIntVal)->zextOrTrunc(BitWidth);
4249 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[0].APIntVal));
4250 delete (yyvsp[0].APIntVal);
4256 #line 1842 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4257 { // Boolean constants
4258 assert(cast<IntegerType>((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
4259 (yyval.ConstVal) = ConstantInt::getTrue();
4265 #line 1847 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4266 { // Boolean constants
4267 assert(cast<IntegerType>((yyvsp[-1].PrimType))->getBitWidth() == 1 && "Not Bool?");
4268 (yyval.ConstVal) = ConstantInt::getFalse();
4274 #line 1852 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4275 { // Float & Double constants
4276 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType), (yyvsp[0].FPVal)))
4277 GEN_ERROR("Floating point constant invalid for type");
4278 (yyval.ConstVal) = ConstantFP::get((yyvsp[-1].PrimType), (yyvsp[0].FPVal));
4284 #line 1860 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4286 if (!UpRefs.empty())
4287 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
4288 Constant *Val = (yyvsp[-3].ConstVal);
4289 const Type *DestTy = (yyvsp[-1].TypeVal)->get();
4290 if (!CastInst::castIsValid((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy))
4291 GEN_ERROR("invalid cast opcode for cast from '" +
4292 Val->getType()->getDescription() + "' to '" +
4293 DestTy->getDescription() + "'");
4294 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy);
4295 delete (yyvsp[-1].TypeVal);
4300 #line 1872 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4302 if (!isa<PointerType>((yyvsp[-2].ConstVal)->getType()))
4303 GEN_ERROR("GetElementPtr requires a pointer operand");
4306 GetElementPtrInst::getIndexedType((yyvsp[-2].ConstVal)->getType(), &(*(yyvsp[-1].ValueList))[0], (yyvsp[-1].ValueList)->size(),
4309 GEN_ERROR("Index list invalid for constant getelementptr");
4311 SmallVector<Constant*, 8> IdxVec;
4312 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i != e; ++i)
4313 if (Constant *C = dyn_cast<Constant>((*(yyvsp[-1].ValueList))[i]))
4314 IdxVec.push_back(C);
4316 GEN_ERROR("Indices to constant getelementptr must be constants");
4318 delete (yyvsp[-1].ValueList);
4320 (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal), &IdxVec[0], IdxVec.size());
4326 #line 1894 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4328 if ((yyvsp[-5].ConstVal)->getType() != Type::Int1Ty)
4329 GEN_ERROR("Select condition must be of boolean type");
4330 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4331 GEN_ERROR("Select operand types must match");
4332 (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4338 #line 1902 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4340 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4341 GEN_ERROR("Binary operator types must match");
4343 (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4348 #line 1908 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4350 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4351 GEN_ERROR("Logical operator types must match");
4352 if (!(yyvsp[-3].ConstVal)->getType()->isInteger()) {
4353 if (Instruction::isShift((yyvsp[-5].BinaryOpVal)) || !isa<VectorType>((yyvsp[-3].ConstVal)->getType()) ||
4354 !cast<VectorType>((yyvsp[-3].ConstVal)->getType())->getElementType()->isInteger())
4355 GEN_ERROR("Logical operator requires integral operands");
4357 (yyval.ConstVal) = ConstantExpr::get((yyvsp[-5].BinaryOpVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4363 #line 1919 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4365 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4366 GEN_ERROR("icmp operand types must match");
4367 (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[-5].IPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4372 #line 1924 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4374 if ((yyvsp[-3].ConstVal)->getType() != (yyvsp[-1].ConstVal)->getType())
4375 GEN_ERROR("fcmp operand types must match");
4376 (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[-5].FPredicate), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4381 #line 1929 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4383 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4384 GEN_ERROR("Invalid extractelement operands");
4385 (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4391 #line 1935 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4393 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4394 GEN_ERROR("Invalid insertelement operands");
4395 (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4401 #line 1941 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4403 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal)))
4404 GEN_ERROR("Invalid shufflevector operands");
4405 (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal), (yyvsp[-3].ConstVal), (yyvsp[-1].ConstVal));
4411 #line 1950 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4413 ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal));
4419 #line 1954 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4421 (yyval.ConstVector) = new std::vector<Constant*>();
4422 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4428 #line 1962 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4429 { (yyval.BoolVal) = false; ;}
4433 #line 1962 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4434 { (yyval.BoolVal) = true; ;}
4438 #line 1965 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4439 { (yyval.BoolVal) = true; ;}
4443 #line 1965 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4444 { (yyval.BoolVal) = false; ;}
4448 #line 1968 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4450 const Type* VTy = (yyvsp[-1].TypeVal)->get();
4451 Value *V = getVal(VTy, (yyvsp[0].ValIDVal));
4452 GlobalValue* Aliasee = dyn_cast<GlobalValue>(V);
4454 GEN_ERROR("Aliases can be created only to global values");
4456 (yyval.ConstVal) = Aliasee;
4458 delete (yyvsp[-1].TypeVal);
4463 #line 1979 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4465 Constant *Val = (yyvsp[-3].ConstVal);
4466 const Type *DestTy = (yyvsp[-1].TypeVal)->get();
4467 if (!CastInst::castIsValid((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy))
4468 GEN_ERROR("invalid cast opcode for cast from '" +
4469 Val->getType()->getDescription() + "' to '" +
4470 DestTy->getDescription() + "'");
4472 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal), DestTy);
4474 delete (yyvsp[-1].TypeVal);
4479 #line 2000 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4481 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
4482 CurModule.ModuleDone();
4488 #line 2005 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4490 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
4491 CurModule.ModuleDone();
4497 #line 2018 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4498 { CurFun.isDeclare = false; ;}
4502 #line 2018 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4504 CurFun.FunctionDone();
4510 #line 2022 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4511 { CurFun.isDeclare = true; ;}
4515 #line 2022 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4522 #line 2025 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4529 #line 2028 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4531 if (!UpRefs.empty())
4532 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
4533 // Eagerly resolve types. This is not an optimization, this is a
4534 // requirement that is due to the fact that we could have this:
4536 // %list = type { %list * }
4537 // %list = type { %list * } ; repeated type decl
4539 // If types are not resolved eagerly, then the two types will not be
4540 // determined to be the same type!
4542 ResolveTypeTo((yyvsp[-2].StrVal), *(yyvsp[0].TypeVal));
4544 if (!setTypeName(*(yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4546 // If this is a named type that is not a redefinition, add it to the slot
4548 CurModule.Types.push_back(*(yyvsp[0].TypeVal));
4551 delete (yyvsp[0].TypeVal);
4557 #line 2052 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4559 ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].PrimType));
4561 if (!setTypeName((yyvsp[0].PrimType), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4563 // If this is a named type that is not a redefinition, add it to the slot
4565 CurModule.Types.push_back((yyvsp[0].PrimType));
4572 #line 2063 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4574 /* "Externally Visible" Linkage */
4575 if ((yyvsp[0].ConstVal) == 0)
4576 GEN_ERROR("Global value initializer is not a constant");
4577 CurGV = ParseGlobalVariable((yyvsp[-4].StrVal), GlobalValue::ExternalLinkage,
4578 (yyvsp[-3].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal), (yyvsp[-2].BoolVal));
4584 #line 2070 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4591 #line 2074 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4593 if ((yyvsp[0].ConstVal) == 0)
4594 GEN_ERROR("Global value initializer is not a constant");
4595 CurGV = ParseGlobalVariable((yyvsp[-5].StrVal), (yyvsp[-4].Linkage), (yyvsp[-3].Visibility), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal)->getType(), (yyvsp[0].ConstVal), (yyvsp[-2].BoolVal));
4601 #line 2079 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4608 #line 2083 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4610 if (!UpRefs.empty())
4611 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
4612 CurGV = ParseGlobalVariable((yyvsp[-5].StrVal), (yyvsp[-4].Linkage), (yyvsp[-3].Visibility), (yyvsp[-1].BoolVal), *(yyvsp[0].TypeVal), 0, (yyvsp[-2].BoolVal));
4614 delete (yyvsp[0].TypeVal);
4619 #line 2089 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4627 #line 2093 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4630 if ((yyvsp[-4].StrVal)) {
4631 Name = *(yyvsp[-4].StrVal);
4632 delete (yyvsp[-4].StrVal);
4635 GEN_ERROR("Alias name cannot be empty");
4637 Constant* Aliasee = (yyvsp[0].ConstVal);
4639 GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name);
4641 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), (yyvsp[-1].Linkage), Name, Aliasee,
4642 CurModule.CurrentModule);
4643 GA->setVisibility((yyvsp[-3].Visibility));
4644 InsertValue(GA, CurModule.Values);
4650 #line 2112 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4657 #line 2115 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4664 #line 2121 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4666 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
4667 if (AsmSoFar.empty())
4668 CurModule.CurrentModule->setModuleInlineAsm(*(yyvsp[0].StrVal));
4670 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*(yyvsp[0].StrVal));
4671 delete (yyvsp[0].StrVal);
4677 #line 2131 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4679 CurModule.CurrentModule->setTargetTriple(*(yyvsp[0].StrVal));
4680 delete (yyvsp[0].StrVal);
4685 #line 2135 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4687 CurModule.CurrentModule->setDataLayout(*(yyvsp[0].StrVal));
4688 delete (yyvsp[0].StrVal);
4693 #line 2142 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4695 CurModule.CurrentModule->addLibrary(*(yyvsp[0].StrVal));
4696 delete (yyvsp[0].StrVal);
4702 #line 2147 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4704 CurModule.CurrentModule->addLibrary(*(yyvsp[0].StrVal));
4705 delete (yyvsp[0].StrVal);
4711 #line 2152 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4718 #line 2161 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4720 if (!UpRefs.empty())
4721 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
4722 if (*(yyvsp[-2].TypeVal) == Type::VoidTy)
4723 GEN_ERROR("void typed arguments are invalid");
4724 ArgListEntry E; E.Attrs = (yyvsp[-1].ParamAttrs); E.Ty = (yyvsp[-2].TypeVal); E.Name = (yyvsp[0].StrVal);
4725 (yyval.ArgList) = (yyvsp[-4].ArgList);
4726 (yyvsp[-4].ArgList)->push_back(E);
4732 #line 2171 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4734 if (!UpRefs.empty())
4735 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
4736 if (*(yyvsp[-2].TypeVal) == Type::VoidTy)
4737 GEN_ERROR("void typed arguments are invalid");
4738 ArgListEntry E; E.Attrs = (yyvsp[-1].ParamAttrs); E.Ty = (yyvsp[-2].TypeVal); E.Name = (yyvsp[0].StrVal);
4739 (yyval.ArgList) = new ArgListType;
4740 (yyval.ArgList)->push_back(E);
4746 #line 2182 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4748 (yyval.ArgList) = (yyvsp[0].ArgList);
4754 #line 2186 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4756 (yyval.ArgList) = (yyvsp[-2].ArgList);
4757 struct ArgListEntry E;
4758 E.Ty = new PATypeHolder(Type::VoidTy);
4760 E.Attrs = ParamAttr::None;
4761 (yyval.ArgList)->push_back(E);
4767 #line 2195 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4769 (yyval.ArgList) = new ArgListType;
4770 struct ArgListEntry E;
4771 E.Ty = new PATypeHolder(Type::VoidTy);
4773 E.Attrs = ParamAttr::None;
4774 (yyval.ArgList)->push_back(E);
4780 #line 2204 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4782 (yyval.ArgList) = 0;
4788 #line 2210 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4790 std::string FunctionName(*(yyvsp[-6].StrVal));
4791 delete (yyvsp[-6].StrVal); // Free strdup'd memory!
4793 // Check the function result for abstractness if this is a define. We should
4794 // have no abstract types at this point
4795 if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[-7].TypeVal)))
4796 GEN_ERROR("Reference to abstract result: "+ (yyvsp[-7].TypeVal)->get()->getDescription());
4798 std::vector<const Type*> ParamTypeList;
4799 ParamAttrsVector Attrs;
4800 if ((yyvsp[-2].ParamAttrs) != ParamAttr::None) {
4801 ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = (yyvsp[-2].ParamAttrs);
4802 Attrs.push_back(PAWI);
4804 if ((yyvsp[-4].ArgList)) { // If there are arguments...
4806 for (ArgListType::iterator I = (yyvsp[-4].ArgList)->begin(); I != (yyvsp[-4].ArgList)->end(); ++I, ++index) {
4807 const Type* Ty = I->Ty->get();
4808 if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
4809 GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
4810 ParamTypeList.push_back(Ty);
4811 if (Ty != Type::VoidTy)
4812 if (I->Attrs != ParamAttr::None) {
4813 ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs;
4814 Attrs.push_back(PAWI);
4819 bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
4820 if (isVarArg) ParamTypeList.pop_back();
4822 ParamAttrsList *PAL = 0;
4824 PAL = ParamAttrsList::get(Attrs);
4826 FunctionType *FT = FunctionType::get(*(yyvsp[-7].TypeVal), ParamTypeList, isVarArg, PAL);
4827 const PointerType *PFT = PointerType::get(FT);
4828 delete (yyvsp[-7].TypeVal);
4831 if (!FunctionName.empty()) {
4832 ID = ValID::createGlobalName((char*)FunctionName.c_str());
4834 ID = ValID::createGlobalID(CurModule.Values.size());
4838 // See if this function was forward referenced. If so, recycle the object.
4839 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
4840 // Move the function to the end of the list, from whereever it was
4841 // previously inserted.
4842 Fn = cast<Function>(FWRef);
4843 CurModule.CurrentModule->getFunctionList().remove(Fn);
4844 CurModule.CurrentModule->getFunctionList().push_back(Fn);
4845 } else if (!FunctionName.empty() && // Merge with an earlier prototype?
4846 (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
4847 if (Fn->getFunctionType() != FT) {
4848 // The existing function doesn't have the same type. This is an overload
4850 GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
4851 } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
4852 // Neither the existing or the current function is a declaration and they
4853 // have the same name and same type. Clearly this is a redefinition.
4854 GEN_ERROR("Redefinition of function '" + FunctionName + "'");
4855 } if (Fn->isDeclaration()) {
4856 // Make sure to strip off any argument names so we can't get conflicts.
4857 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
4861 } else { // Not already defined?
4862 Fn = new Function(FT, GlobalValue::ExternalWeakLinkage, FunctionName,
4863 CurModule.CurrentModule);
4865 InsertValue(Fn, CurModule.Values);
4868 CurFun.FunctionStart(Fn);
4870 if (CurFun.isDeclare) {
4871 // If we have declaration, always overwrite linkage. This will allow us to
4872 // correctly handle cases, when pointer to function is passed as argument to
4873 // another function.
4874 Fn->setLinkage(CurFun.Linkage);
4875 Fn->setVisibility(CurFun.Visibility);
4877 Fn->setCallingConv((yyvsp[-8].UIntVal));
4878 Fn->setAlignment((yyvsp[0].UIntVal));
4879 if ((yyvsp[-1].StrVal)) {
4880 Fn->setSection(*(yyvsp[-1].StrVal));
4881 delete (yyvsp[-1].StrVal);
4884 // Add all of the arguments we parsed to the function...
4885 if ((yyvsp[-4].ArgList)) { // Is null if empty...
4886 if (isVarArg) { // Nuke the last entry
4887 assert((yyvsp[-4].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[-4].ArgList)->back().Name == 0 &&
4888 "Not a varargs marker!");
4889 delete (yyvsp[-4].ArgList)->back().Ty;
4890 (yyvsp[-4].ArgList)->pop_back(); // Delete the last entry
4892 Function::arg_iterator ArgIt = Fn->arg_begin();
4893 Function::arg_iterator ArgEnd = Fn->arg_end();
4895 for (ArgListType::iterator I = (yyvsp[-4].ArgList)->begin();
4896 I != (yyvsp[-4].ArgList)->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
4897 delete I->Ty; // Delete the typeholder...
4898 setValueName(ArgIt, I->Name); // Insert arg into symtab...
4904 delete (yyvsp[-4].ArgList); // We're now done with the argument list
4911 #line 2332 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4913 (yyval.FunctionVal) = CurFun.CurrentFunction;
4915 // Make sure that we keep track of the linkage type even if there was a
4916 // previous "declare".
4917 (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage));
4918 (yyval.FunctionVal)->setVisibility((yyvsp[-2].Visibility));
4923 #line 2343 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4925 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
4931 #line 2348 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4933 CurFun.CurrentFunction->setLinkage((yyvsp[-2].Linkage));
4934 CurFun.CurrentFunction->setVisibility((yyvsp[-1].Visibility));
4935 (yyval.FunctionVal) = CurFun.CurrentFunction;
4936 CurFun.FunctionDone();
4942 #line 2360 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4944 (yyval.BoolVal) = false;
4950 #line 2364 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4952 (yyval.BoolVal) = true;
4958 #line 2369 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4959 { // A reference to a direct constant
4960 (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val));
4966 #line 2373 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4968 (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val));
4974 #line 2377 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4975 { // Perhaps it's an FP constant?
4976 (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal));
4982 #line 2381 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4984 (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue());
4990 #line 2385 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
4992 (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse());
4998 #line 2389 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5000 (yyval.ValIDVal) = ValID::createNull();
5006 #line 2393 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5008 (yyval.ValIDVal) = ValID::createUndef();
5014 #line 2397 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5015 { // A vector zero constant.
5016 (yyval.ValIDVal) = ValID::createZeroInit();
5022 #line 2401 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5023 { // Nonempty unsized packed vector
5024 const Type *ETy = (*(yyvsp[-1].ConstVector))[0]->getType();
5025 int NumElements = (yyvsp[-1].ConstVector)->size();
5027 VectorType* pt = VectorType::get(ETy, NumElements);
5028 PATypeHolder* PTy = new PATypeHolder(
5036 // Verify all elements are correct type!
5037 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5038 if (ETy != (*(yyvsp[-1].ConstVector))[i]->getType())
5039 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
5040 ETy->getDescription() +"' as required!\nIt is of type '" +
5041 (*(yyvsp[-1].ConstVector))[i]->getType()->getDescription() + "'.");
5044 (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, *(yyvsp[-1].ConstVector)));
5045 delete PTy; delete (yyvsp[-1].ConstVector);
5051 #line 2426 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5053 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal));
5059 #line 2430 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5061 (yyval.ValIDVal) = ValID::createInlineAsm(*(yyvsp[-2].StrVal), *(yyvsp[0].StrVal), (yyvsp[-3].BoolVal));
5062 delete (yyvsp[-2].StrVal);
5063 delete (yyvsp[0].StrVal);
5069 #line 2440 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5070 { // Is it an integer reference...?
5071 (yyval.ValIDVal) = ValID::createLocalID((yyvsp[0].UIntVal));
5077 #line 2444 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5079 (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[0].UIntVal));
5085 #line 2448 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5086 { // Is it a named reference...?
5087 (yyval.ValIDVal) = ValID::createLocalName(*(yyvsp[0].StrVal));
5088 delete (yyvsp[0].StrVal);
5094 #line 2453 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5095 { // Is it a named reference...?
5096 (yyval.ValIDVal) = ValID::createGlobalName(*(yyvsp[0].StrVal));
5097 delete (yyvsp[0].StrVal);
5103 #line 2466 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5105 if (!UpRefs.empty())
5106 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
5107 (yyval.ValueVal) = getVal(*(yyvsp[-1].TypeVal), (yyvsp[0].ValIDVal));
5108 delete (yyvsp[-1].TypeVal);
5114 #line 2475 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5116 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5122 #line 2479 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5123 { // Do not allow functions with 0 basic blocks
5124 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5130 #line 2488 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5132 setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
5134 InsertValue((yyvsp[0].TermInstVal));
5135 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
5136 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5142 #line 2497 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5144 if (CastInst *CI1 = dyn_cast<CastInst>((yyvsp[0].InstVal)))
5145 if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
5146 if (CI2->getParent() == 0)
5147 (yyvsp[-1].BasicBlockVal)->getInstList().push_back(CI2);
5148 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal));
5149 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5155 #line 2506 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5156 { // Empty space between instruction lists
5157 (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
5163 #line 2510 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5164 { // Labelled (named) basic block
5165 (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName(*(yyvsp[0].StrVal)));
5166 delete (yyvsp[0].StrVal);
5173 #line 2517 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5174 { // Return with a result...
5175 (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal));
5181 #line 2521 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5182 { // Return with no result...
5183 (yyval.TermInstVal) = new ReturnInst();
5189 #line 2525 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5190 { // Unconditional Branch...
5191 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5193 (yyval.TermInstVal) = new BranchInst(tmpBB);
5198 #line 2530 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5200 assert(cast<IntegerType>((yyvsp[-7].PrimType))->getBitWidth() == 1 && "Not Bool?");
5201 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5203 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5205 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5207 (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5212 #line 2540 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5214 Value* tmpVal = getVal((yyvsp[-7].PrimType), (yyvsp[-6].ValIDVal));
5216 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5218 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5219 (yyval.TermInstVal) = S;
5221 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5222 E = (yyvsp[-1].JumpTable)->end();
5223 for (; I != E; ++I) {
5224 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5225 S->addCase(CI, I->second);
5227 GEN_ERROR("Switch case is constant, but not a simple integer");
5229 delete (yyvsp[-1].JumpTable);
5235 #line 2559 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5237 Value* tmpVal = getVal((yyvsp[-6].PrimType), (yyvsp[-5].ValIDVal));
5239 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5241 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5242 (yyval.TermInstVal) = S;
5248 #line 2569 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5251 // Handle the short syntax
5252 const PointerType *PFTy = 0;
5253 const FunctionType *Ty = 0;
5254 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-11].TypeVal)->get())) ||
5255 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5256 // Pull out the types of all of the arguments...
5257 std::vector<const Type*> ParamTypes;
5258 ParamAttrsVector Attrs;
5259 if ((yyvsp[-6].ParamAttrs) != ParamAttr::None) {
5260 ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = (yyvsp[-6].ParamAttrs);
5261 Attrs.push_back(PAWI);
5263 ValueRefList::iterator I = (yyvsp[-8].ValueRefList)->begin(), E = (yyvsp[-8].ValueRefList)->end();
5265 for (; I != E; ++I, ++index) {
5266 const Type *Ty = I->Val->getType();
5267 if (Ty == Type::VoidTy)
5268 GEN_ERROR("Short call syntax cannot be used with varargs");
5269 ParamTypes.push_back(Ty);
5270 if (I->Attrs != ParamAttr::None) {
5271 ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs;
5272 Attrs.push_back(PAWI);
5276 ParamAttrsList *PAL = 0;
5278 PAL = ParamAttrsList::get(Attrs);
5279 Ty = FunctionType::get((yyvsp[-11].TypeVal)->get(), ParamTypes, false, PAL);
5280 PFTy = PointerType::get(Ty);
5283 delete (yyvsp[-11].TypeVal);
5285 Value *V = getVal(PFTy, (yyvsp[-10].ValIDVal)); // Get the function we're calling...
5287 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5289 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5292 // Check the arguments
5294 if ((yyvsp[-8].ValueRefList)->empty()) { // Has no arguments?
5295 // Make sure no arguments is a good thing!
5296 if (Ty->getNumParams() != 0)
5297 GEN_ERROR("No arguments passed to a function that "
5298 "expects arguments");
5299 } else { // Has arguments?
5300 // Loop through FunctionType's arguments and ensure they are specified
5302 FunctionType::param_iterator I = Ty->param_begin();
5303 FunctionType::param_iterator E = Ty->param_end();
5304 ValueRefList::iterator ArgI = (yyvsp[-8].ValueRefList)->begin(), ArgE = (yyvsp[-8].ValueRefList)->end();
5306 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5307 if (ArgI->Val->getType() != *I)
5308 GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
5309 (*I)->getDescription() + "'");
5310 Args.push_back(ArgI->Val);
5313 if (Ty->isVarArg()) {
5315 for (; ArgI != ArgE; ++ArgI)
5316 Args.push_back(ArgI->Val); // push the remaining varargs
5317 } else if (I != E || ArgI != ArgE)
5318 GEN_ERROR("Invalid number of parameters detected");
5321 // Create the InvokeInst
5322 InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
5323 II->setCallingConv((yyvsp[-12].UIntVal));
5324 (yyval.TermInstVal) = II;
5325 delete (yyvsp[-8].ValueRefList);
5331 #line 2648 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5333 (yyval.TermInstVal) = new UnwindInst();
5339 #line 2652 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5341 (yyval.TermInstVal) = new UnreachableInst();
5347 #line 2659 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5349 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5350 Constant *V = cast<Constant>(getExistingVal((yyvsp[-4].PrimType), (yyvsp[-3].ValIDVal)));
5353 GEN_ERROR("May only switch on a constant pool value");
5355 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5357 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5362 #line 2670 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5364 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5365 Constant *V = cast<Constant>(getExistingVal((yyvsp[-4].PrimType), (yyvsp[-3].ValIDVal)));
5369 GEN_ERROR("May only switch on a constant pool value");
5371 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5373 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5378 #line 2683 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5380 // Is this definition named?? if so, assign the name...
5381 setValueName((yyvsp[0].InstVal), (yyvsp[-1].StrVal));
5383 InsertValue((yyvsp[0].InstVal));
5384 (yyval.InstVal) = (yyvsp[0].InstVal);
5390 #line 2693 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5391 { // Used for PHI nodes
5392 if (!UpRefs.empty())
5393 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-5].TypeVal))->getDescription());
5394 (yyval.PHIList) = new std::list<std::pair<Value*, BasicBlock*> >();
5395 Value* tmpVal = getVal(*(yyvsp[-5].TypeVal), (yyvsp[-3].ValIDVal));
5397 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5399 (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
5400 delete (yyvsp[-5].TypeVal);
5405 #line 2704 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5407 (yyval.PHIList) = (yyvsp[-6].PHIList);
5408 Value* tmpVal = getVal((yyvsp[-6].PHIList)->front().first->getType(), (yyvsp[-3].ValIDVal));
5410 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5412 (yyvsp[-6].PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
5417 #line 2714 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5419 if (!UpRefs.empty())
5420 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
5421 // Used for call and invoke instructions
5422 (yyval.ValueRefList) = new ValueRefList();
5423 ValueRefListEntry E; E.Attrs = (yyvsp[0].ParamAttrs); E.Val = getVal((yyvsp[-2].TypeVal)->get(), (yyvsp[-1].ValIDVal));
5424 (yyval.ValueRefList)->push_back(E);
5425 delete (yyvsp[-2].TypeVal);
5430 #line 2723 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5432 if (!UpRefs.empty())
5433 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
5434 (yyval.ValueRefList) = (yyvsp[-4].ValueRefList);
5435 ValueRefListEntry E; E.Attrs = (yyvsp[0].ParamAttrs); E.Val = getVal((yyvsp[-2].TypeVal)->get(), (yyvsp[-1].ValIDVal));
5436 (yyval.ValueRefList)->push_back(E);
5437 delete (yyvsp[-2].TypeVal);
5443 #line 2732 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5444 { (yyval.ValueRefList) = new ValueRefList(); ;}
5448 #line 2735 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5449 { (yyval.ValueList) = new std::vector<Value*>(); ;}
5453 #line 2736 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5455 (yyval.ValueList) = (yyvsp[-2].ValueList);
5456 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
5462 #line 2743 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5464 (yyval.BoolVal) = true;
5470 #line 2747 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5472 (yyval.BoolVal) = false;
5478 #line 2752 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5480 if (!UpRefs.empty())
5481 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
5482 if (!(*(yyvsp[-3].TypeVal))->isInteger() && !(*(yyvsp[-3].TypeVal))->isFloatingPoint() &&
5483 !isa<VectorType>((*(yyvsp[-3].TypeVal)).get()))
5485 "Arithmetic operator requires integer, FP, or packed operands");
5486 if (isa<VectorType>((*(yyvsp[-3].TypeVal)).get()) &&
5487 ((yyvsp[-4].BinaryOpVal) == Instruction::URem ||
5488 (yyvsp[-4].BinaryOpVal) == Instruction::SRem ||
5489 (yyvsp[-4].BinaryOpVal) == Instruction::FRem))
5490 GEN_ERROR("Remainder not supported on vector types");
5491 Value* val1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
5493 Value* val2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
5495 (yyval.InstVal) = BinaryOperator::create((yyvsp[-4].BinaryOpVal), val1, val2);
5496 if ((yyval.InstVal) == 0)
5497 GEN_ERROR("binary operator returned null");
5498 delete (yyvsp[-3].TypeVal);
5503 #line 2773 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5505 if (!UpRefs.empty())
5506 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
5507 if (!(*(yyvsp[-3].TypeVal))->isInteger()) {
5508 if (Instruction::isShift((yyvsp[-4].BinaryOpVal)) || !isa<VectorType>((yyvsp[-3].TypeVal)->get()) ||
5509 !cast<VectorType>((yyvsp[-3].TypeVal)->get())->getElementType()->isInteger())
5510 GEN_ERROR("Logical operator requires integral operands");
5512 Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
5514 Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
5516 (yyval.InstVal) = BinaryOperator::create((yyvsp[-4].BinaryOpVal), tmpVal1, tmpVal2);
5517 if ((yyval.InstVal) == 0)
5518 GEN_ERROR("binary operator returned null");
5519 delete (yyvsp[-3].TypeVal);
5524 #line 2790 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5526 if (!UpRefs.empty())
5527 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
5528 if (isa<VectorType>((*(yyvsp[-3].TypeVal)).get()))
5529 GEN_ERROR("Vector types not supported by icmp instruction");
5530 Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
5532 Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
5534 (yyval.InstVal) = CmpInst::create((yyvsp[-5].OtherOpVal), (yyvsp[-4].IPredicate), tmpVal1, tmpVal2);
5535 if ((yyval.InstVal) == 0)
5536 GEN_ERROR("icmp operator returned null");
5537 delete (yyvsp[-3].TypeVal);
5542 #line 2804 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5544 if (!UpRefs.empty())
5545 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-3].TypeVal))->getDescription());
5546 if (isa<VectorType>((*(yyvsp[-3].TypeVal)).get()))
5547 GEN_ERROR("Vector types not supported by fcmp instruction");
5548 Value* tmpVal1 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[-2].ValIDVal));
5550 Value* tmpVal2 = getVal(*(yyvsp[-3].TypeVal), (yyvsp[0].ValIDVal));
5552 (yyval.InstVal) = CmpInst::create((yyvsp[-5].OtherOpVal), (yyvsp[-4].FPredicate), tmpVal1, tmpVal2);
5553 if ((yyval.InstVal) == 0)
5554 GEN_ERROR("fcmp operator returned null");
5555 delete (yyvsp[-3].TypeVal);
5560 #line 2818 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5562 if (!UpRefs.empty())
5563 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
5564 Value* Val = (yyvsp[-2].ValueVal);
5565 const Type* DestTy = (yyvsp[0].TypeVal)->get();
5566 if (!CastInst::castIsValid((yyvsp[-3].CastOpVal), Val, DestTy))
5567 GEN_ERROR("invalid cast opcode for cast from '" +
5568 Val->getType()->getDescription() + "' to '" +
5569 DestTy->getDescription() + "'");
5570 (yyval.InstVal) = CastInst::create((yyvsp[-3].CastOpVal), Val, DestTy);
5571 delete (yyvsp[0].TypeVal);
5576 #line 2830 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5578 if ((yyvsp[-4].ValueVal)->getType() != Type::Int1Ty)
5579 GEN_ERROR("select condition must be boolean");
5580 if ((yyvsp[-2].ValueVal)->getType() != (yyvsp[0].ValueVal)->getType())
5581 GEN_ERROR("select value types should match");
5582 (yyval.InstVal) = new SelectInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
5588 #line 2838 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5590 if (!UpRefs.empty())
5591 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[0].TypeVal))->getDescription());
5592 (yyval.InstVal) = new VAArgInst((yyvsp[-2].ValueVal), *(yyvsp[0].TypeVal));
5593 delete (yyvsp[0].TypeVal);
5599 #line 2845 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5601 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
5602 GEN_ERROR("Invalid extractelement operands");
5603 (yyval.InstVal) = new ExtractElementInst((yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
5609 #line 2851 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5611 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
5612 GEN_ERROR("Invalid insertelement operands");
5613 (yyval.InstVal) = new InsertElementInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
5619 #line 2857 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5621 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal)))
5622 GEN_ERROR("Invalid shufflevector operands");
5623 (yyval.InstVal) = new ShuffleVectorInst((yyvsp[-4].ValueVal), (yyvsp[-2].ValueVal), (yyvsp[0].ValueVal));
5629 #line 2863 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5631 const Type *Ty = (yyvsp[0].PHIList)->front().first->getType();
5632 if (!Ty->isFirstClassType())
5633 GEN_ERROR("PHI node operands must be of first class type");
5634 (yyval.InstVal) = new PHINode(Ty);
5635 ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[0].PHIList)->size());
5636 while ((yyvsp[0].PHIList)->begin() != (yyvsp[0].PHIList)->end()) {
5637 if ((yyvsp[0].PHIList)->front().first->getType() != Ty)
5638 GEN_ERROR("All elements of a PHI node must be of the same type");
5639 cast<PHINode>((yyval.InstVal))->addIncoming((yyvsp[0].PHIList)->front().first, (yyvsp[0].PHIList)->front().second);
5640 (yyvsp[0].PHIList)->pop_front();
5642 delete (yyvsp[0].PHIList); // Free the list...
5648 #line 2879 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5651 // Handle the short syntax
5652 const PointerType *PFTy = 0;
5653 const FunctionType *Ty = 0;
5654 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-5].TypeVal)->get())) ||
5655 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5656 // Pull out the types of all of the arguments...
5657 std::vector<const Type*> ParamTypes;
5658 ParamAttrsVector Attrs;
5659 if ((yyvsp[0].ParamAttrs) != ParamAttr::None) {
5660 ParamAttrsWithIndex PAWI; PAWI.index = 0; PAWI.attrs = (yyvsp[0].ParamAttrs);
5661 Attrs.push_back(PAWI);
5664 ValueRefList::iterator I = (yyvsp[-2].ValueRefList)->begin(), E = (yyvsp[-2].ValueRefList)->end();
5665 for (; I != E; ++I, ++index) {
5666 const Type *Ty = I->Val->getType();
5667 if (Ty == Type::VoidTy)
5668 GEN_ERROR("Short call syntax cannot be used with varargs");
5669 ParamTypes.push_back(Ty);
5670 if (I->Attrs != ParamAttr::None) {
5671 ParamAttrsWithIndex PAWI; PAWI.index = index; PAWI.attrs = I->Attrs;
5672 Attrs.push_back(PAWI);
5676 ParamAttrsList *PAL = 0;
5678 PAL = ParamAttrsList::get(Attrs);
5680 Ty = FunctionType::get((yyvsp[-5].TypeVal)->get(), ParamTypes, false, PAL);
5681 PFTy = PointerType::get(Ty);
5684 Value *V = getVal(PFTy, (yyvsp[-4].ValIDVal)); // Get the function we're calling...
5687 // Check for call to invalid intrinsic to avoid crashing later.
5688 if (Function *theF = dyn_cast<Function>(V)) {
5689 if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) &&
5690 (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) &&
5691 !theF->getIntrinsicID(true))
5692 GEN_ERROR("Call to invalid LLVM intrinsic function '" +
5693 theF->getName() + "'");
5696 // Check the arguments
5698 if ((yyvsp[-2].ValueRefList)->empty()) { // Has no arguments?
5699 // Make sure no arguments is a good thing!
5700 if (Ty->getNumParams() != 0)
5701 GEN_ERROR("No arguments passed to a function that "
5702 "expects arguments");
5703 } else { // Has arguments?
5704 // Loop through FunctionType's arguments and ensure they are specified
5707 FunctionType::param_iterator I = Ty->param_begin();
5708 FunctionType::param_iterator E = Ty->param_end();
5709 ValueRefList::iterator ArgI = (yyvsp[-2].ValueRefList)->begin(), ArgE = (yyvsp[-2].ValueRefList)->end();
5711 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5712 if (ArgI->Val->getType() != *I)
5713 GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
5714 (*I)->getDescription() + "'");
5715 Args.push_back(ArgI->Val);
5717 if (Ty->isVarArg()) {
5719 for (; ArgI != ArgE; ++ArgI)
5720 Args.push_back(ArgI->Val); // push the remaining varargs
5721 } else if (I != E || ArgI != ArgE)
5722 GEN_ERROR("Invalid number of parameters detected");
5724 // Create the call node
5725 CallInst *CI = new CallInst(V, &Args[0], Args.size());
5726 CI->setTailCall((yyvsp[-7].BoolVal));
5727 CI->setCallingConv((yyvsp[-6].UIntVal));
5728 (yyval.InstVal) = CI;
5729 delete (yyvsp[-2].ValueRefList);
5730 delete (yyvsp[-5].TypeVal);
5736 #line 2963 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5738 (yyval.InstVal) = (yyvsp[0].InstVal);
5744 #line 2968 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5746 (yyval.BoolVal) = true;
5752 #line 2972 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5754 (yyval.BoolVal) = false;
5760 #line 2979 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5762 if (!UpRefs.empty())
5763 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
5764 (yyval.InstVal) = new MallocInst(*(yyvsp[-1].TypeVal), 0, (yyvsp[0].UIntVal));
5765 delete (yyvsp[-1].TypeVal);
5771 #line 2986 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5773 if (!UpRefs.empty())
5774 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
5775 Value* tmpVal = getVal((yyvsp[-2].PrimType), (yyvsp[-1].ValIDVal));
5777 (yyval.InstVal) = new MallocInst(*(yyvsp[-4].TypeVal), tmpVal, (yyvsp[0].UIntVal));
5778 delete (yyvsp[-4].TypeVal);
5783 #line 2994 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5785 if (!UpRefs.empty())
5786 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-1].TypeVal))->getDescription());
5787 (yyval.InstVal) = new AllocaInst(*(yyvsp[-1].TypeVal), 0, (yyvsp[0].UIntVal));
5788 delete (yyvsp[-1].TypeVal);
5794 #line 3001 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5796 if (!UpRefs.empty())
5797 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-4].TypeVal))->getDescription());
5798 Value* tmpVal = getVal((yyvsp[-2].PrimType), (yyvsp[-1].ValIDVal));
5800 (yyval.InstVal) = new AllocaInst(*(yyvsp[-4].TypeVal), tmpVal, (yyvsp[0].UIntVal));
5801 delete (yyvsp[-4].TypeVal);
5806 #line 3009 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5808 if (!isa<PointerType>((yyvsp[0].ValueVal)->getType()))
5809 GEN_ERROR("Trying to free nonpointer type " +
5810 (yyvsp[0].ValueVal)->getType()->getDescription() + "");
5811 (yyval.InstVal) = new FreeInst((yyvsp[0].ValueVal));
5817 #line 3017 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5819 if (!UpRefs.empty())
5820 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
5821 if (!isa<PointerType>((yyvsp[-2].TypeVal)->get()))
5822 GEN_ERROR("Can't load from nonpointer type: " +
5823 (*(yyvsp[-2].TypeVal))->getDescription());
5824 if (!cast<PointerType>((yyvsp[-2].TypeVal)->get())->getElementType()->isFirstClassType())
5825 GEN_ERROR("Can't load from pointer of non-first-class type: " +
5826 (*(yyvsp[-2].TypeVal))->getDescription());
5827 Value* tmpVal = getVal(*(yyvsp[-2].TypeVal), (yyvsp[-1].ValIDVal));
5829 (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[-4].BoolVal), (yyvsp[0].UIntVal));
5830 delete (yyvsp[-2].TypeVal);
5835 #line 3031 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5837 if (!UpRefs.empty())
5838 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
5839 const PointerType *PT = dyn_cast<PointerType>((yyvsp[-2].TypeVal)->get());
5841 GEN_ERROR("Can't store to a nonpointer type: " +
5842 (*(yyvsp[-2].TypeVal))->getDescription());
5843 const Type *ElTy = PT->getElementType();
5844 if (ElTy != (yyvsp[-4].ValueVal)->getType())
5845 GEN_ERROR("Can't store '" + (yyvsp[-4].ValueVal)->getType()->getDescription() +
5846 "' into space of type '" + ElTy->getDescription() + "'");
5848 Value* tmpVal = getVal(*(yyvsp[-2].TypeVal), (yyvsp[-1].ValIDVal));
5850 (yyval.InstVal) = new StoreInst((yyvsp[-4].ValueVal), tmpVal, (yyvsp[-6].BoolVal), (yyvsp[0].UIntVal));
5851 delete (yyvsp[-2].TypeVal);
5856 #line 3048 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
5858 if (!UpRefs.empty())
5859 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[-2].TypeVal))->getDescription());
5860 if (!isa<PointerType>((yyvsp[-2].TypeVal)->get()))
5861 GEN_ERROR("getelementptr insn requires pointer operand");
5863 if (!GetElementPtrInst::getIndexedType(*(yyvsp[-2].TypeVal), &(*(yyvsp[0].ValueList))[0], (yyvsp[0].ValueList)->size(), true))
5864 GEN_ERROR("Invalid getelementptr indices for type '" +
5865 (*(yyvsp[-2].TypeVal))->getDescription()+ "'");
5866 Value* tmpVal = getVal(*(yyvsp[-2].TypeVal), (yyvsp[-1].ValIDVal));
5868 (yyval.InstVal) = new GetElementPtrInst(tmpVal, &(*(yyvsp[0].ValueList))[0], (yyvsp[0].ValueList)->size());
5869 delete (yyvsp[-2].TypeVal);
5870 delete (yyvsp[0].ValueList);
5878 /* Line 1126 of yacc.c. */
5879 #line 5880 "llvmAsmParser.tab.c"
5885 YY_STACK_PRINT (yyss, yyssp);
5890 /* Now `shift' the result of the reduction. Determine what state
5891 that goes to, based on the state we popped back to and the rule
5892 number reduced by. */
5896 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
5897 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
5898 yystate = yytable[yystate];
5900 yystate = yydefgoto[yyn - YYNTOKENS];
5905 /*------------------------------------.
5906 | yyerrlab -- here on detecting error |
5907 `------------------------------------*/
5909 /* If not already recovering from an error, report this error. */
5914 yyn = yypact[yystate];
5916 if (YYPACT_NINF < yyn && yyn < YYLAST)
5918 int yytype = YYTRANSLATE (yychar);
5919 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
5920 YYSIZE_T yysize = yysize0;
5922 int yysize_overflow = 0;
5924 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
5925 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
5929 /* This is so xgettext sees the translatable formats that are
5930 constructed on the fly. */
5931 YY_("syntax error, unexpected %s");
5932 YY_("syntax error, unexpected %s, expecting %s");
5933 YY_("syntax error, unexpected %s, expecting %s or %s");
5934 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
5935 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
5939 static char const yyunexpected[] = "syntax error, unexpected %s";
5940 static char const yyexpecting[] = ", expecting %s";
5941 static char const yyor[] = " or %s";
5942 char yyformat[sizeof yyunexpected
5943 + sizeof yyexpecting - 1
5944 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
5945 * (sizeof yyor - 1))];
5946 char const *yyprefix = yyexpecting;
5948 /* Start YYX at -YYN if negative to avoid negative indexes in
5950 int yyxbegin = yyn < 0 ? -yyn : 0;
5952 /* Stay within bounds of both yycheck and yytname. */
5953 int yychecklim = YYLAST - yyn;
5954 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
5957 yyarg[0] = yytname[yytype];
5958 yyfmt = yystpcpy (yyformat, yyunexpected);
5960 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
5961 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
5963 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
5967 yyformat[sizeof yyunexpected - 1] = '\0';
5970 yyarg[yycount++] = yytname[yyx];
5971 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
5972 yysize_overflow |= yysize1 < yysize;
5974 yyfmt = yystpcpy (yyfmt, yyprefix);
5978 yyf = YY_(yyformat);
5979 yysize1 = yysize + yystrlen (yyf);
5980 yysize_overflow |= yysize1 < yysize;
5983 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
5984 yymsg = (char *) YYSTACK_ALLOC (yysize);
5987 /* Avoid sprintf, as that infringes on the user's name space.
5988 Don't have undefined behavior even if the translation
5989 produced a string with the wrong number of "%s"s. */
5992 while ((*yyp = *yyf))
5994 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
5996 yyp += yytnamerr (yyp, yyarg[yyi++]);
6006 YYSTACK_FREE (yymsg);
6010 yyerror (YY_("syntax error"));
6011 goto yyexhaustedlab;
6015 #endif /* YYERROR_VERBOSE */
6016 yyerror (YY_("syntax error"));
6021 if (yyerrstatus == 3)
6023 /* If just tried and failed to reuse look-ahead token after an
6024 error, discard it. */
6026 if (yychar <= YYEOF)
6028 /* Return failure if at end of input. */
6029 if (yychar == YYEOF)
6034 yydestruct ("Error: discarding", yytoken, &yylval);
6039 /* Else will try to reuse look-ahead token after shifting the error
6044 /*---------------------------------------------------.
6045 | yyerrorlab -- error raised explicitly by YYERROR. |
6046 `---------------------------------------------------*/
6049 /* Pacify compilers like GCC when the user code never invokes
6050 YYERROR and the label yyerrorlab therefore never appears in user
6061 /*-------------------------------------------------------------.
6062 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6063 `-------------------------------------------------------------*/
6065 yyerrstatus = 3; /* Each real token shifted decrements this. */
6069 yyn = yypact[yystate];
6070 if (yyn != YYPACT_NINF)
6073 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6081 /* Pop the current state because it cannot handle the error token. */
6086 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6089 YY_STACK_PRINT (yyss, yyssp);
6098 /* Shift the error token. */
6099 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6105 /*-------------------------------------.
6106 | yyacceptlab -- YYACCEPT comes here. |
6107 `-------------------------------------*/
6112 /*-----------------------------------.
6113 | yyabortlab -- YYABORT comes here. |
6114 `-----------------------------------*/
6120 /*-------------------------------------------------.
6121 | yyexhaustedlab -- memory exhaustion comes here. |
6122 `-------------------------------------------------*/
6124 yyerror (YY_("memory exhausted"));
6130 if (yychar != YYEOF && yychar != YYEMPTY)
6131 yydestruct ("Cleanup: discarding lookahead",
6133 while (yyssp != yyss)
6135 yydestruct ("Cleanup: popping",
6136 yystos[*yyssp], yyvsp);
6141 YYSTACK_FREE (yyss);
6147 #line 3065 "/proj/llvm/llvm-4/lib/AsmParser/llvmAsmParser.y"
6150 // common code from the two 'RunVMAsmParser' functions
6151 static Module* RunParser(Module * M) {
6153 llvmAsmlineno = 1; // Reset the current line number...
6154 CurModule.CurrentModule = M;
6159 // Check to make sure the parser succeeded
6162 delete ParserResult;
6166 // Emit an error if there are any unresolved types left.
6167 if (!CurModule.LateResolveTypes.empty()) {
6168 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
6169 if (DID.Type == ValID::LocalName) {
6170 GenerateError("Undefined type remains at eof: '"+DID.getName() + "'");
6172 GenerateError("Undefined type remains at eof: #" + itostr(DID.Num));
6175 delete ParserResult;
6179 // Emit an error if there are any unresolved values left.
6180 if (!CurModule.LateResolveValues.empty()) {
6181 Value *V = CurModule.LateResolveValues.back();
6182 std::map<Value*, std::pair<ValID, int> >::iterator I =
6183 CurModule.PlaceHolderInfo.find(V);
6185 if (I != CurModule.PlaceHolderInfo.end()) {
6186 ValID &DID = I->second.first;
6187 if (DID.Type == ValID::LocalName) {
6188 GenerateError("Undefined value remains at eof: "+DID.getName() + "'");
6190 GenerateError("Undefined value remains at eof: #" + itostr(DID.Num));
6193 delete ParserResult;
6198 // Check to make sure that parsing produced a result
6202 // Reset ParserResult variable while saving its value for the result.
6203 Module *Result = ParserResult;
6209 void llvm::GenerateError(const std::string &message, int LineNo) {
6210 if (LineNo == -1) LineNo = llvmAsmlineno;
6211 // TODO: column number in exception
6213 TheParseError->setError(CurFilename, message, LineNo);
6217 int yyerror(const char *ErrorMsg) {
6219 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6220 + ":" + utostr((unsigned) llvmAsmlineno) + ": ";
6221 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6222 if (yychar != YYEMPTY && yychar != 0)
6223 errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+
6225 GenerateError(errMsg);