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 Upgradeparse
53 #define yylex Upgradelex
54 #define yyerror Upgradeerror
55 #define yylval Upgradelval
56 #define yychar Upgradechar
57 #define yydebug Upgradedebug
58 #define yynerrs Upgradenerrs
64 /* Put the tokens into the symbol table, so that GDB and other debuggers
90 ZEROINITIALIZER = 281,
133 X86_STDCALLCC_TOK = 324,
134 X86_FASTCALLCC_TOK = 325,
178 EXTRACTELEMENT = 369,
219 #define ESINT64VAL 258
220 #define EUINT64VAL 259
240 #define STRINGCONSTANT 279
241 #define IMPLEMENTATION 280
242 #define ZEROINITIALIZER 281
253 #define DOTDOTDOT 292
260 #define APPENDING 299
261 #define DLLIMPORT 300
262 #define DLLEXPORT 301
263 #define EXTERN_WEAK 302
270 #define POINTERSIZE 309
279 #define SIDEEFFECT 318
282 #define CSRETCC_TOK 321
283 #define FASTCC_TOK 322
284 #define COLDCC_TOK 323
285 #define X86_STDCALLCC_TOK 324
286 #define X86_FASTCALLCC_TOK 325
287 #define DATALAYOUT 326
292 #define UNREACHABLE 331
326 #define GETELEMENTPTR 365
330 #define EXTRACTELEMENT 369
331 #define INSERTELEMENT 370
332 #define SHUFFLEVECTOR 371
333 #define VAARG_old 372
334 #define VANEXT_old 373
372 /* Copy the first part of user declarations. */
373 #line 14 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
375 #include "UpgradeInternals.h"
376 #include "llvm/CallingConv.h"
377 #include "llvm/InlineAsm.h"
378 #include "llvm/Instructions.h"
379 #include "llvm/Module.h"
380 #include "llvm/ValueSymbolTable.h"
381 #include "llvm/Support/GetElementPtrTypeIterator.h"
382 #include "llvm/ADT/STLExtras.h"
383 #include "llvm/Support/MathExtras.h"
389 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
390 // relating to upreferences in the input stream.
392 //#define DEBUG_UPREFS 1
394 #define UR_OUT(X) std::cerr << X
399 #define YYERROR_VERBOSE 1
400 #define YYINCLUDED_STDLIB_H
406 int yyerror(const char*);
407 static void warning(const std::string& WarningMsg);
411 std::istream* LexInput;
412 static std::string CurFilename;
414 // This bool controls whether attributes are ever added to function declarations
415 // definitions and calls.
416 static bool AddAttributes = false;
418 static Module *ParserResult;
419 static bool ObsoleteVarArgs;
420 static bool NewVarArgs;
421 static BasicBlock *CurBB;
422 static GlobalVariable *CurGV;
424 // This contains info used when building the body of a function. It is
425 // destroyed when the function is completed.
427 typedef std::vector<Value *> ValueList; // Numbered defs
429 typedef std::pair<std::string,const Type*> RenameMapKey;
430 typedef std::map<RenameMapKey,std::string> RenameMapType;
433 ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
434 std::map<const Type *,ValueList> *FutureLateResolvers = 0);
436 static struct PerModuleInfo {
437 Module *CurrentModule;
438 std::map<const Type *, ValueList> Values; // Module level numbered definitions
439 std::map<const Type *,ValueList> LateResolveValues;
440 std::vector<PATypeHolder> Types;
441 std::map<ValID, PATypeHolder> LateResolveTypes;
442 static Module::Endianness Endian;
443 static Module::PointerSize PointerSize;
444 RenameMapType RenameMap;
446 /// PlaceHolderInfo - When temporary placeholder objects are created, remember
447 /// how they were referenced and on which line of the input they came from so
448 /// that we can resolve them later and print error messages as appropriate.
449 std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
451 // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
452 // references to global values. Global values may be referenced before they
453 // are defined, and if so, the temporary object that they represent is held
454 // here. This is used for forward references of GlobalValues.
456 typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*>
458 GlobalRefsType GlobalRefs;
461 // If we could not resolve some functions at function compilation time
462 // (calls to functions before they are defined), resolve them now... Types
463 // are resolved when the constant pool has been completely parsed.
465 ResolveDefinitions(LateResolveValues);
467 // Check to make sure that all global value forward references have been
470 if (!GlobalRefs.empty()) {
471 std::string UndefinedReferences = "Unresolved global references exist:\n";
473 for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
475 UndefinedReferences += " " + I->first.first->getDescription() + " " +
476 I->first.second.getName() + "\n";
478 error(UndefinedReferences);
482 if (CurrentModule->getDataLayout().empty()) {
483 std::string dataLayout;
484 if (Endian != Module::AnyEndianness)
485 dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
486 if (PointerSize != Module::AnyPointerSize) {
487 if (!dataLayout.empty())
489 dataLayout.append(PointerSize == Module::Pointer64 ?
490 "p:64:64" : "p:32:32");
492 CurrentModule->setDataLayout(dataLayout);
495 Values.clear(); // Clear out function local definitions
500 // GetForwardRefForGlobal - Check to see if there is a forward reference
501 // for this global. If so, remove it from the GlobalRefs map and return it.
502 // If not, just return null.
503 GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
504 // Check to see if there is a forward reference to this global variable...
505 // if there is, eliminate it and patch the reference to use the new def'n.
506 GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
507 GlobalValue *Ret = 0;
508 if (I != GlobalRefs.end()) {
514 void setEndianness(Module::Endianness E) { Endian = E; }
515 void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
518 Module::Endianness PerModuleInfo::Endian = Module::AnyEndianness;
519 Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
521 static struct PerFunctionInfo {
522 Function *CurrentFunction; // Pointer to current function being created
524 std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
525 std::map<const Type*, ValueList> LateResolveValues;
526 bool isDeclare; // Is this function a forward declararation?
527 GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
529 /// BBForwardRefs - When we see forward references to basic blocks, keep
530 /// track of them here.
531 std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
532 std::vector<BasicBlock*> NumberedBlocks;
533 RenameMapType RenameMap;
537 inline PerFunctionInfo() {
540 Linkage = GlobalValue::ExternalLinkage;
543 inline void FunctionStart(Function *M) {
548 void FunctionDone() {
549 NumberedBlocks.clear();
551 // Any forward referenced blocks left?
552 if (!BBForwardRefs.empty()) {
553 error("Undefined reference to label " +
554 BBForwardRefs.begin()->first->getName());
558 // Resolve all forward references now.
559 ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
561 Values.clear(); // Clear out function local definitions
565 Linkage = GlobalValue::ExternalLinkage;
567 } CurFun; // Info for the current function...
569 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
572 //===----------------------------------------------------------------------===//
573 // Code to handle definitions of all the types
574 //===----------------------------------------------------------------------===//
576 static int InsertValue(Value *V,
577 std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
578 if (V->hasName()) return -1; // Is this a numbered definition?
580 // Yes, insert the value into the value table...
581 ValueList &List = ValueTab[V->getType()];
583 return List.size()-1;
586 static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
588 case ValID::NumberVal: // Is it a numbered definition?
589 // Module constants occupy the lowest numbered slots...
590 if ((unsigned)D.Num < CurModule.Types.size()) {
591 return CurModule.Types[(unsigned)D.Num];
594 case ValID::NameVal: // Is it a named definition?
595 if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
596 D.destroy(); // Free old strdup'd memory...
601 error("Internal parser error: Invalid symbol type reference");
605 // If we reached here, we referenced either a symbol that we don't know about
606 // or an id number that hasn't been read yet. We may be referencing something
607 // forward, so just create an entry to be resolved later and get to it...
609 if (DoNotImprovise) return 0; // Do we just want a null to be returned?
612 if (inFunctionScope()) {
613 if (D.Type == ValID::NameVal) {
614 error("Reference to an undefined type: '" + D.getName() + "'");
617 error("Reference to an undefined type: #" + itostr(D.Num));
622 std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
623 if (I != CurModule.LateResolveTypes.end())
626 Type *Typ = OpaqueType::get();
627 CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
631 // getExistingValue - Look up the value specified by the provided type and
632 // the provided ValID. If the value exists and has already been defined, return
633 // it. Otherwise return null.
635 static Value *getExistingValue(const Type *Ty, const ValID &D) {
636 if (isa<FunctionType>(Ty)) {
637 error("Functions are not values and must be referenced as pointers");
641 case ValID::NumberVal: { // Is it a numbered definition?
642 unsigned Num = (unsigned)D.Num;
644 // Module constants occupy the lowest numbered slots...
645 std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
646 if (VI != CurModule.Values.end()) {
647 if (Num < VI->second.size())
648 return VI->second[Num];
649 Num -= VI->second.size();
652 // Make sure that our type is within bounds
653 VI = CurFun.Values.find(Ty);
654 if (VI == CurFun.Values.end()) return 0;
656 // Check that the number is within bounds...
657 if (VI->second.size() <= Num) return 0;
659 return VI->second[Num];
662 case ValID::NameVal: { // Is it a named definition?
663 // Get the name out of the ID
664 std::string Name(D.Name);
666 RenameMapKey Key = std::make_pair(Name, Ty);
667 if (inFunctionScope()) {
668 // See if the name was renamed
669 RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
670 std::string LookupName;
671 if (I != CurFun.RenameMap.end())
672 LookupName = I->second;
675 ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
676 V = SymTab.lookup(LookupName);
677 if (V && V->getType() != Ty)
681 RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
682 std::string LookupName;
683 if (I != CurModule.RenameMap.end())
684 LookupName = I->second;
687 V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName);
688 if (V && V->getType() != Ty)
694 D.destroy(); // Free old strdup'd memory...
698 // Check to make sure that "Ty" is an integral type, and that our
699 // value will fit into the specified type...
700 case ValID::ConstSIntVal: // Is it a constant pool reference??
701 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
702 error("Signed integral constant '" + itostr(D.ConstPool64) +
703 "' is invalid for type '" + Ty->getDescription() + "'");
705 return ConstantInt::get(Ty, D.ConstPool64);
707 case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
708 if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
709 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
710 error("Integral constant '" + utostr(D.UConstPool64) +
711 "' is invalid or out of range");
712 else // This is really a signed reference. Transmogrify.
713 return ConstantInt::get(Ty, D.ConstPool64);
715 return ConstantInt::get(Ty, D.UConstPool64);
717 case ValID::ConstFPVal: // Is it a floating point const pool reference?
718 if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
719 error("FP constant invalid for type");
720 return ConstantFP::get(Ty, D.ConstPoolFP);
722 case ValID::ConstNullVal: // Is it a null value?
723 if (!isa<PointerType>(Ty))
724 error("Cannot create a a non pointer null");
725 return ConstantPointerNull::get(cast<PointerType>(Ty));
727 case ValID::ConstUndefVal: // Is it an undef value?
728 return UndefValue::get(Ty);
730 case ValID::ConstZeroVal: // Is it a zero value?
731 return Constant::getNullValue(Ty);
733 case ValID::ConstantVal: // Fully resolved constant?
734 if (D.ConstantValue->getType() != Ty)
735 error("Constant expression type different from required type");
736 return D.ConstantValue;
738 case ValID::InlineAsmVal: { // Inline asm expression
739 const PointerType *PTy = dyn_cast<PointerType>(Ty);
740 const FunctionType *FTy =
741 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
742 if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
743 error("Invalid type for asm constraint string");
744 InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
745 D.IAD->HasSideEffects);
746 D.destroy(); // Free InlineAsmDescriptor.
750 assert(0 && "Unhandled case");
754 assert(0 && "Unhandled case");
758 // getVal - This function is identical to getExistingValue, except that if a
759 // value is not already defined, it "improvises" by creating a placeholder var
760 // that looks and acts just like the requested variable. When the value is
761 // defined later, all uses of the placeholder variable are replaced with the
764 static Value *getVal(const Type *Ty, const ValID &ID) {
765 if (Ty == Type::LabelTy)
766 error("Cannot use a basic block here");
768 // See if the value has already been defined.
769 Value *V = getExistingValue(Ty, ID);
772 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
773 error("Invalid use of a composite type");
775 // If we reached here, we referenced either a symbol that we don't know about
776 // or an id number that hasn't been read yet. We may be referencing something
777 // forward, so just create an entry to be resolved later and get to it...
778 V = new Argument(Ty);
780 // Remember where this forward reference came from. FIXME, shouldn't we try
781 // to recycle these things??
782 CurModule.PlaceHolderInfo.insert(
783 std::make_pair(V, std::make_pair(ID, Upgradelineno)));
785 if (inFunctionScope())
786 InsertValue(V, CurFun.LateResolveValues);
788 InsertValue(V, CurModule.LateResolveValues);
792 /// getBBVal - This is used for two purposes:
793 /// * If isDefinition is true, a new basic block with the specified ID is being
795 /// * If isDefinition is true, this is a reference to a basic block, which may
796 /// or may not be a forward reference.
798 static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
799 assert(inFunctionScope() && "Can't get basic block at global scope");
805 error("Illegal label reference " + ID.getName());
807 case ValID::NumberVal: // Is it a numbered definition?
808 if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
809 CurFun.NumberedBlocks.resize(ID.Num+1);
810 BB = CurFun.NumberedBlocks[ID.Num];
812 case ValID::NameVal: // Is it a named definition?
814 if (Value *N = CurFun.CurrentFunction->
815 getValueSymbolTable().lookup(Name)) {
816 if (N->getType() != Type::LabelTy)
817 error("Name '" + Name + "' does not refer to a BasicBlock");
818 BB = cast<BasicBlock>(N);
823 // See if the block has already been defined.
825 // If this is the definition of the block, make sure the existing value was
826 // just a forward reference. If it was a forward reference, there will be
827 // an entry for it in the PlaceHolderInfo map.
828 if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
829 // The existing value was a definition, not a forward reference.
830 error("Redefinition of label " + ID.getName());
832 ID.destroy(); // Free strdup'd memory.
836 // Otherwise this block has not been seen before.
837 BB = new BasicBlock("", CurFun.CurrentFunction);
838 if (ID.Type == ValID::NameVal) {
839 BB->setName(ID.Name);
841 CurFun.NumberedBlocks[ID.Num] = BB;
844 // If this is not a definition, keep track of it so we can use it as a forward
847 // Remember where this forward reference came from.
848 CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
850 // The forward declaration could have been inserted anywhere in the
851 // function: insert it into the correct place now.
852 CurFun.CurrentFunction->getBasicBlockList().remove(BB);
853 CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
860 //===----------------------------------------------------------------------===//
861 // Code to handle forward references in instructions
862 //===----------------------------------------------------------------------===//
864 // This code handles the late binding needed with statements that reference
865 // values not defined yet... for example, a forward branch, or the PHI node for
868 // This keeps a table (CurFun.LateResolveValues) of all such forward references
869 // and back patchs after we are done.
872 /// This function determines if two function types differ only in their use of
873 /// the sret parameter attribute in the first argument. If they are identical
874 /// in all other respects, it returns true. Otherwise, it returns false.
875 bool FuncTysDifferOnlyBySRet(const FunctionType *F1,
876 const FunctionType *F2) {
877 if (F1->getReturnType() != F2->getReturnType() ||
878 F1->getNumParams() != F2->getNumParams() ||
879 F1->getParamAttrs(0) != F2->getParamAttrs(0))
881 unsigned SRetMask = ~unsigned(FunctionType::StructRetAttribute);
882 for (unsigned i = 0; i < F1->getNumParams(); ++i) {
883 if (F1->getParamType(i) != F2->getParamType(i) ||
884 unsigned(F1->getParamAttrs(i+1)) & SRetMask !=
885 unsigned(F2->getParamAttrs(i+1)) & SRetMask)
891 // ResolveDefinitions - If we could not resolve some defs at parsing
892 // time (forward branches, phi functions for loops, etc...) resolve the
896 ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
897 std::map<const Type*,ValueList> *FutureLateResolvers) {
898 // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
899 for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
900 E = LateResolvers.end(); LRI != E; ++LRI) {
901 ValueList &List = LRI->second;
902 while (!List.empty()) {
903 Value *V = List.back();
906 std::map<Value*, std::pair<ValID, int> >::iterator PHI =
907 CurModule.PlaceHolderInfo.find(V);
908 assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
910 ValID &DID = PHI->second.first;
912 Value *TheRealValue = getExistingValue(LRI->first, DID);
914 V->replaceAllUsesWith(TheRealValue);
916 CurModule.PlaceHolderInfo.erase(PHI);
917 } else if (FutureLateResolvers) {
918 // Functions have their unresolved items forwarded to the module late
920 InsertValue(V, *FutureLateResolvers);
922 if (DID.Type == ValID::NameVal) {
923 // The upgrade of csretcc to sret param attribute may have caused a
924 // function to not be found because the param attribute changed the
925 // type of the called function. Detect this situation and insert a
926 // cast as necessary.
928 if (const PointerType *PTy = dyn_cast<PointerType>(V->getType()))
929 if (const FunctionType *FTy =
930 dyn_cast<FunctionType>(PTy->getElementType()))
931 if (Function *OtherF =
932 CurModule.CurrentModule->getNamedFunction(DID.getName()))
933 if (FuncTysDifferOnlyBySRet(FTy,OtherF->getFunctionType())) {
934 V->replaceAllUsesWith(ConstantExpr::getBitCast(OtherF, PTy));
938 error("Reference to an invalid definition: '" +DID.getName()+
939 "' of type '" + V->getType()->getDescription() + "'",
944 error("Reference to an invalid definition: #" +
945 itostr(DID.Num) + " of type '" +
946 V->getType()->getDescription() + "'", PHI->second.second);
953 LateResolvers.clear();
956 // ResolveTypeTo - A brand new type was just declared. This means that (if
957 // name is not null) things referencing Name can be resolved. Otherwise, things
958 // refering to the number can be resolved. Do this now.
960 static void ResolveTypeTo(char *Name, const Type *ToTy) {
962 if (Name) D = ValID::create(Name);
963 else D = ValID::create((int)CurModule.Types.size());
965 std::map<ValID, PATypeHolder>::iterator I =
966 CurModule.LateResolveTypes.find(D);
967 if (I != CurModule.LateResolveTypes.end()) {
968 ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
969 CurModule.LateResolveTypes.erase(I);
973 /// @brief This just makes any name given to it unique, up to MAX_UINT times.
974 static std::string makeNameUnique(const std::string& Name) {
975 static unsigned UniqueNameCounter = 1;
976 std::string Result(Name);
977 Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
981 /// This is the implementation portion of TypeHasInteger. It traverses the
982 /// type given, avoiding recursive types, and returns true as soon as it finds
983 /// an integer type. If no integer type is found, it returns false.
984 static bool TypeHasIntegerI(const Type *Ty, std::vector<const Type*> Stack) {
985 // Handle some easy cases
986 if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID))
990 if (const SequentialType *STy = dyn_cast<SequentialType>(Ty))
991 return STy->getElementType()->isInteger();
993 // Avoid type structure recursion
994 for (std::vector<const Type*>::iterator I = Stack.begin(), E = Stack.end();
999 // Push us on the type stack
1000 Stack.push_back(Ty);
1002 if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
1003 if (TypeHasIntegerI(FTy->getReturnType(), Stack))
1005 FunctionType::param_iterator I = FTy->param_begin();
1006 FunctionType::param_iterator E = FTy->param_end();
1008 if (TypeHasIntegerI(*I, Stack))
1011 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1012 StructType::element_iterator I = STy->element_begin();
1013 StructType::element_iterator E = STy->element_end();
1014 for (; I != E; ++I) {
1015 if (TypeHasIntegerI(*I, Stack))
1020 // There shouldn't be anything else, but its definitely not integer
1021 assert(0 && "What type is this?");
1025 /// This is the interface to TypeHasIntegerI. It just provides the type stack,
1026 /// to avoid recursion, and then calls TypeHasIntegerI.
1027 static inline bool TypeHasInteger(const Type *Ty) {
1028 std::vector<const Type*> TyStack;
1029 return TypeHasIntegerI(Ty, TyStack);
1032 // setValueName - Set the specified value to the name given. The name may be
1033 // null potentially, in which case this is a noop. The string passed in is
1034 // assumed to be a malloc'd string buffer, and is free'd by this function.
1036 static void setValueName(Value *V, char *NameStr) {
1038 std::string Name(NameStr); // Copy string
1039 free(NameStr); // Free old string
1041 if (V->getType() == Type::VoidTy) {
1042 error("Can't assign name '" + Name + "' to value with void type");
1046 assert(inFunctionScope() && "Must be in function scope");
1048 // Search the function's symbol table for an existing value of this name
1049 ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1050 Value* Existing = ST.lookup(Name);
1052 // An existing value of the same name was found. This might have happened
1053 // because of the integer type planes collapsing in LLVM 2.0.
1054 if (Existing->getType() == V->getType() &&
1055 !TypeHasInteger(Existing->getType())) {
1056 // If the type does not contain any integers in them then this can't be
1057 // a type plane collapsing issue. It truly is a redefinition and we
1058 // should error out as the assembly is invalid.
1059 error("Redefinition of value named '" + Name + "' of type '" +
1060 V->getType()->getDescription() + "'");
1063 // In LLVM 2.0 we don't allow names to be re-used for any values in a
1064 // function, regardless of Type. Previously re-use of names was okay as
1065 // long as they were distinct types. With type planes collapsing because
1066 // of the signedness change and because of PR411, this can no longer be
1067 // supported. We must search the entire symbol table for a conflicting
1068 // name and make the name unique. No warning is needed as this can't
1070 std::string NewName = makeNameUnique(Name);
1071 // We're changing the name but it will probably be used by other
1072 // instructions as operands later on. Consequently we have to retain
1073 // a mapping of the renaming that we're doing.
1074 RenameMapKey Key = std::make_pair(Name,V->getType());
1075 CurFun.RenameMap[Key] = NewName;
1084 /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
1085 /// this is a declaration, otherwise it is a definition.
1086 static GlobalVariable *
1087 ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
1088 bool isConstantGlobal, const Type *Ty,
1089 Constant *Initializer) {
1090 if (isa<FunctionType>(Ty))
1091 error("Cannot declare global vars of function type");
1093 const PointerType *PTy = PointerType::get(Ty);
1097 Name = NameStr; // Copy string
1098 free(NameStr); // Free old string
1101 // See if this global value was forward referenced. If so, recycle the
1104 if (!Name.empty()) {
1105 ID = ValID::create((char*)Name.c_str());
1107 ID = ValID::create((int)CurModule.Values[PTy].size());
1110 if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1111 // Move the global to the end of the list, from whereever it was
1112 // previously inserted.
1113 GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1114 CurModule.CurrentModule->getGlobalList().remove(GV);
1115 CurModule.CurrentModule->getGlobalList().push_back(GV);
1116 GV->setInitializer(Initializer);
1117 GV->setLinkage(Linkage);
1118 GV->setConstant(isConstantGlobal);
1119 InsertValue(GV, CurModule.Values);
1123 // If this global has a name, check to see if there is already a definition
1124 // of this global in the module and emit warnings if there are conflicts.
1125 if (!Name.empty()) {
1126 // The global has a name. See if there's an existing one of the same name.
1127 if (CurModule.CurrentModule->getNamedGlobal(Name)) {
1128 // We found an existing global ov the same name. This isn't allowed
1129 // in LLVM 2.0. Consequently, we must alter the name of the global so it
1130 // can at least compile. This can happen because of type planes
1131 // There is alread a global of the same name which means there is a
1132 // conflict. Let's see what we can do about it.
1133 std::string NewName(makeNameUnique(Name));
1134 if (Linkage == GlobalValue::InternalLinkage) {
1135 // The linkage type is internal so just warn about the rename without
1136 // invoking "scarey language" about linkage failures. GVars with
1137 // InternalLinkage can be renamed at will.
1138 warning("Global variable '" + Name + "' was renamed to '"+
1141 // The linkage of this gval is external so we can't reliably rename
1142 // it because it could potentially create a linking problem.
1143 // However, we can't leave the name conflict in the output either or
1144 // it won't assemble with LLVM 2.0. So, all we can do is rename
1145 // this one to something unique and emit a warning about the problem.
1146 warning("Renaming global variable '" + Name + "' to '" + NewName +
1147 "' may cause linkage errors");
1150 // Put the renaming in the global rename map
1151 RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
1152 CurModule.RenameMap[Key] = NewName;
1159 // Otherwise there is no existing GV to use, create one now.
1160 GlobalVariable *GV =
1161 new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1162 CurModule.CurrentModule);
1163 InsertValue(GV, CurModule.Values);
1167 // setTypeName - Set the specified type to the name given. The name may be
1168 // null potentially, in which case this is a noop. The string passed in is
1169 // assumed to be a malloc'd string buffer, and is freed by this function.
1171 // This function returns true if the type has already been defined, but is
1172 // allowed to be redefined in the specified context. If the name is a new name
1173 // for the type plane, it is inserted and false is returned.
1174 static bool setTypeName(const Type *T, char *NameStr) {
1175 assert(!inFunctionScope() && "Can't give types function-local names");
1176 if (NameStr == 0) return false;
1178 std::string Name(NameStr); // Copy string
1179 free(NameStr); // Free old string
1181 // We don't allow assigning names to void type
1182 if (T == Type::VoidTy) {
1183 error("Can't assign name '" + Name + "' to the void type");
1187 // Set the type name, checking for conflicts as we do so.
1188 bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1190 if (AlreadyExists) { // Inserting a name that is already defined???
1191 const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1192 assert(Existing && "Conflict but no matching type?");
1194 // There is only one case where this is allowed: when we are refining an
1195 // opaque type. In this case, Existing will be an opaque type.
1196 if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1197 // We ARE replacing an opaque type!
1198 const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1202 // Otherwise, this is an attempt to redefine a type. That's okay if
1203 // the redefinition is identical to the original. This will be so if
1204 // Existing and T point to the same Type object. In this one case we
1205 // allow the equivalent redefinition.
1206 if (Existing == T) return true; // Yes, it's equal.
1208 // Any other kind of (non-equivalent) redefinition is an error.
1209 error("Redefinition of type named '" + Name + "' in the '" +
1210 T->getDescription() + "' type plane");
1216 //===----------------------------------------------------------------------===//
1217 // Code for handling upreferences in type names...
1220 // TypeContains - Returns true if Ty directly contains E in it.
1222 static bool TypeContains(const Type *Ty, const Type *E) {
1223 return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1224 E) != Ty->subtype_end();
1228 struct UpRefRecord {
1229 // NestingLevel - The number of nesting levels that need to be popped before
1230 // this type is resolved.
1231 unsigned NestingLevel;
1233 // LastContainedTy - This is the type at the current binding level for the
1234 // type. Every time we reduce the nesting level, this gets updated.
1235 const Type *LastContainedTy;
1237 // UpRefTy - This is the actual opaque type that the upreference is
1238 // represented with.
1239 OpaqueType *UpRefTy;
1241 UpRefRecord(unsigned NL, OpaqueType *URTy)
1242 : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1246 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1247 static std::vector<UpRefRecord> UpRefs;
1249 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1250 /// called. It loops through the UpRefs vector, which is a list of the
1251 /// currently active types. For each type, if the up reference is contained in
1252 /// the newly completed type, we decrement the level count. When the level
1253 /// count reaches zero, the upreferenced type is the type that is passed in:
1254 /// thus we can complete the cycle.
1256 static PATypeHolder HandleUpRefs(const Type *ty) {
1257 // If Ty isn't abstract, or if there are no up-references in it, then there is
1258 // nothing to resolve here.
1259 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1261 PATypeHolder Ty(ty);
1262 UR_OUT("Type '" << Ty->getDescription() <<
1263 "' newly formed. Resolving upreferences.\n" <<
1264 UpRefs.size() << " upreferences active!\n");
1266 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1267 // to zero), we resolve them all together before we resolve them to Ty. At
1268 // the end of the loop, if there is anything to resolve to Ty, it will be in
1270 OpaqueType *TypeToResolve = 0;
1272 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1273 UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1274 << UpRefs[i].second->getDescription() << ") = "
1275 << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1276 if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1277 // Decrement level of upreference
1278 unsigned Level = --UpRefs[i].NestingLevel;
1279 UpRefs[i].LastContainedTy = Ty;
1280 UR_OUT(" Uplevel Ref Level = " << Level << "\n");
1281 if (Level == 0) { // Upreference should be resolved!
1282 if (!TypeToResolve) {
1283 TypeToResolve = UpRefs[i].UpRefTy;
1285 UR_OUT(" * Resolving upreference for "
1286 << UpRefs[i].second->getDescription() << "\n";
1287 std::string OldName = UpRefs[i].UpRefTy->getDescription());
1288 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1289 UR_OUT(" * Type '" << OldName << "' refined upreference to: "
1290 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1292 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
1293 --i; // Do not skip the next element...
1298 if (TypeToResolve) {
1299 UR_OUT(" * Resolving upreference for "
1300 << UpRefs[i].second->getDescription() << "\n";
1301 std::string OldName = TypeToResolve->getDescription());
1302 TypeToResolve->refineAbstractTypeTo(Ty);
1308 static inline Instruction::TermOps
1309 getTermOp(TermOps op) {
1311 default : assert(0 && "Invalid OldTermOp");
1312 case RetOp : return Instruction::Ret;
1313 case BrOp : return Instruction::Br;
1314 case SwitchOp : return Instruction::Switch;
1315 case InvokeOp : return Instruction::Invoke;
1316 case UnwindOp : return Instruction::Unwind;
1317 case UnreachableOp: return Instruction::Unreachable;
1321 static inline Instruction::BinaryOps
1322 getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
1324 default : assert(0 && "Invalid OldBinaryOps");
1330 case SetGT : assert(0 && "Should use getCompareOp");
1331 case AddOp : return Instruction::Add;
1332 case SubOp : return Instruction::Sub;
1333 case MulOp : return Instruction::Mul;
1335 // This is an obsolete instruction so we must upgrade it based on the
1336 // types of its operands.
1337 bool isFP = Ty->isFloatingPoint();
1338 if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1339 // If its a packed type we want to use the element type
1340 isFP = PTy->getElementType()->isFloatingPoint();
1342 return Instruction::FDiv;
1343 else if (Sign == Signed)
1344 return Instruction::SDiv;
1345 return Instruction::UDiv;
1347 case UDivOp : return Instruction::UDiv;
1348 case SDivOp : return Instruction::SDiv;
1349 case FDivOp : return Instruction::FDiv;
1351 // This is an obsolete instruction so we must upgrade it based on the
1352 // types of its operands.
1353 bool isFP = Ty->isFloatingPoint();
1354 if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1355 // If its a packed type we want to use the element type
1356 isFP = PTy->getElementType()->isFloatingPoint();
1357 // Select correct opcode
1359 return Instruction::FRem;
1360 else if (Sign == Signed)
1361 return Instruction::SRem;
1362 return Instruction::URem;
1364 case URemOp : return Instruction::URem;
1365 case SRemOp : return Instruction::SRem;
1366 case FRemOp : return Instruction::FRem;
1367 case LShrOp : return Instruction::LShr;
1368 case AShrOp : return Instruction::AShr;
1369 case ShlOp : return Instruction::Shl;
1372 return Instruction::AShr;
1373 return Instruction::LShr;
1374 case AndOp : return Instruction::And;
1375 case OrOp : return Instruction::Or;
1376 case XorOp : return Instruction::Xor;
1380 static inline Instruction::OtherOps
1381 getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
1383 bool isSigned = Sign == Signed;
1384 bool isFP = Ty->isFloatingPoint();
1386 default : assert(0 && "Invalid OldSetCC");
1389 predicate = FCmpInst::FCMP_OEQ;
1390 return Instruction::FCmp;
1392 predicate = ICmpInst::ICMP_EQ;
1393 return Instruction::ICmp;
1397 predicate = FCmpInst::FCMP_UNE;
1398 return Instruction::FCmp;
1400 predicate = ICmpInst::ICMP_NE;
1401 return Instruction::ICmp;
1405 predicate = FCmpInst::FCMP_OLE;
1406 return Instruction::FCmp;
1409 predicate = ICmpInst::ICMP_SLE;
1411 predicate = ICmpInst::ICMP_ULE;
1412 return Instruction::ICmp;
1416 predicate = FCmpInst::FCMP_OGE;
1417 return Instruction::FCmp;
1420 predicate = ICmpInst::ICMP_SGE;
1422 predicate = ICmpInst::ICMP_UGE;
1423 return Instruction::ICmp;
1427 predicate = FCmpInst::FCMP_OLT;
1428 return Instruction::FCmp;
1431 predicate = ICmpInst::ICMP_SLT;
1433 predicate = ICmpInst::ICMP_ULT;
1434 return Instruction::ICmp;
1438 predicate = FCmpInst::FCMP_OGT;
1439 return Instruction::FCmp;
1442 predicate = ICmpInst::ICMP_SGT;
1444 predicate = ICmpInst::ICMP_UGT;
1445 return Instruction::ICmp;
1450 static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
1452 default : assert(0 && "Invalid OldMemoryOps");
1453 case MallocOp : return Instruction::Malloc;
1454 case FreeOp : return Instruction::Free;
1455 case AllocaOp : return Instruction::Alloca;
1456 case LoadOp : return Instruction::Load;
1457 case StoreOp : return Instruction::Store;
1458 case GetElementPtrOp : return Instruction::GetElementPtr;
1462 static inline Instruction::OtherOps
1463 getOtherOp(OtherOps op, Signedness Sign) {
1465 default : assert(0 && "Invalid OldOtherOps");
1466 case PHIOp : return Instruction::PHI;
1467 case CallOp : return Instruction::Call;
1468 case SelectOp : return Instruction::Select;
1469 case UserOp1 : return Instruction::UserOp1;
1470 case UserOp2 : return Instruction::UserOp2;
1471 case VAArg : return Instruction::VAArg;
1472 case ExtractElementOp : return Instruction::ExtractElement;
1473 case InsertElementOp : return Instruction::InsertElement;
1474 case ShuffleVectorOp : return Instruction::ShuffleVector;
1475 case ICmpOp : return Instruction::ICmp;
1476 case FCmpOp : return Instruction::FCmp;
1480 static inline Value*
1481 getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy,
1482 Signedness DstSign, bool ForceInstruction = false) {
1483 Instruction::CastOps Opcode;
1484 const Type* SrcTy = Src->getType();
1486 if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
1487 // fp -> ptr cast is no longer supported but we must upgrade this
1488 // by doing a double cast: fp -> int -> ptr
1489 SrcTy = Type::Int64Ty;
1490 Opcode = Instruction::IntToPtr;
1491 if (isa<Constant>(Src)) {
1492 Src = ConstantExpr::getCast(Instruction::FPToUI,
1493 cast<Constant>(Src), SrcTy);
1495 std::string NewName(makeNameUnique(Src->getName()));
1496 Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
1498 } else if (isa<IntegerType>(DstTy) &&
1499 cast<IntegerType>(DstTy)->getBitWidth() == 1) {
1500 // cast type %x to bool was previously defined as setne type %x, null
1501 // The cast semantic is now to truncate, not compare so we must retain
1502 // the original intent by replacing the cast with a setne
1503 Constant* Null = Constant::getNullValue(SrcTy);
1504 Instruction::OtherOps Opcode = Instruction::ICmp;
1505 unsigned short predicate = ICmpInst::ICMP_NE;
1506 if (SrcTy->isFloatingPoint()) {
1507 Opcode = Instruction::FCmp;
1508 predicate = FCmpInst::FCMP_ONE;
1509 } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
1510 error("Invalid cast to bool");
1512 if (isa<Constant>(Src) && !ForceInstruction)
1513 return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
1515 return CmpInst::create(Opcode, predicate, Src, Null);
1517 // Determine the opcode to use by calling CastInst::getCastOpcode
1519 CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
1521 } else switch (op) {
1522 default: assert(0 && "Invalid cast token");
1523 case TruncOp: Opcode = Instruction::Trunc; break;
1524 case ZExtOp: Opcode = Instruction::ZExt; break;
1525 case SExtOp: Opcode = Instruction::SExt; break;
1526 case FPTruncOp: Opcode = Instruction::FPTrunc; break;
1527 case FPExtOp: Opcode = Instruction::FPExt; break;
1528 case FPToUIOp: Opcode = Instruction::FPToUI; break;
1529 case FPToSIOp: Opcode = Instruction::FPToSI; break;
1530 case UIToFPOp: Opcode = Instruction::UIToFP; break;
1531 case SIToFPOp: Opcode = Instruction::SIToFP; break;
1532 case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
1533 case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
1534 case BitCastOp: Opcode = Instruction::BitCast; break;
1537 if (isa<Constant>(Src) && !ForceInstruction)
1538 return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
1539 return CastInst::create(Opcode, Src, DstTy);
1542 static Instruction *
1543 upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
1544 std::vector<Value*>& Args) {
1546 std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
1547 if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
1548 if (Args.size() != 2)
1549 error("Invalid prototype for " + Name + " prototype");
1550 return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
1552 const Type* PtrTy = PointerType::get(Type::Int8Ty);
1553 std::vector<const Type*> Params;
1554 if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1555 if (Args.size() != 1)
1556 error("Invalid prototype for " + Name + " prototype");
1557 Params.push_back(PtrTy);
1558 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1559 const PointerType *PFTy = PointerType::get(FTy);
1560 Value* Func = getVal(PFTy, ID);
1561 Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1562 return new CallInst(Func, Args);
1563 } else if (Name == "llvm.va_copy") {
1564 if (Args.size() != 2)
1565 error("Invalid prototype for " + Name + " prototype");
1566 Params.push_back(PtrTy);
1567 Params.push_back(PtrTy);
1568 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1569 const PointerType *PFTy = PointerType::get(FTy);
1570 Value* Func = getVal(PFTy, ID);
1571 std::string InstName0(makeNameUnique("va0"));
1572 std::string InstName1(makeNameUnique("va1"));
1573 Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1574 Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1575 return new CallInst(Func, Args);
1581 const Type* upgradeGEPIndices(const Type* PTy,
1582 std::vector<ValueInfo> *Indices,
1583 std::vector<Value*> &VIndices,
1584 std::vector<Constant*> *CIndices = 0) {
1585 // Traverse the indices with a gep_type_iterator so we can build the list
1586 // of constant and value indices for use later. Also perform upgrades
1588 if (CIndices) CIndices->clear();
1589 for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1590 VIndices.push_back((*Indices)[i].V);
1591 generic_gep_type_iterator<std::vector<Value*>::iterator>
1592 GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()),
1593 GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end());
1594 for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1595 Value *Index = VIndices[i];
1596 if (CIndices && !isa<Constant>(Index))
1597 error("Indices to constant getelementptr must be constants");
1598 // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte
1599 // struct indices to i32 struct indices with ZExt for compatibility.
1600 else if (isa<StructType>(*GTI)) { // Only change struct indices
1601 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1602 if (CUI->getType()->getBitWidth() == 8)
1604 ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1606 // Make sure that unsigned SequentialType indices are zext'd to
1607 // 64-bits if they were smaller than that because LLVM 2.0 will sext
1608 // all indices for SequentialType elements. We must retain the same
1609 // semantic (zext) for unsigned types.
1610 if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1611 if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned) {
1613 Index = ConstantExpr::getCast(Instruction::ZExt,
1614 cast<Constant>(Index), Type::Int64Ty);
1616 Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1617 makeNameUnique("gep"), CurBB);
1618 VIndices[i] = Index;
1621 // Add to the CIndices list, if requested.
1623 CIndices->push_back(cast<Constant>(Index));
1627 GetElementPtrInst::getIndexedType(PTy, VIndices, true);
1629 error("Index list invalid for constant getelementptr");
1633 unsigned upgradeCallingConv(unsigned CC) {
1635 case OldCallingConv::C : return CallingConv::C;
1636 case OldCallingConv::CSRet : return CallingConv::C;
1637 case OldCallingConv::Fast : return CallingConv::Fast;
1638 case OldCallingConv::Cold : return CallingConv::Cold;
1639 case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1640 case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1646 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1647 bool debug, bool addAttrs)
1650 CurFilename = infile;
1653 AddAttributes = addAttrs;
1654 ObsoleteVarArgs = false;
1657 CurModule.CurrentModule = new Module(CurFilename);
1659 // Check to make sure the parser succeeded
1662 delete ParserResult;
1663 std::cerr << "llvm-upgrade: parse failed.\n";
1667 // Check to make sure that parsing produced a result
1668 if (!ParserResult) {
1669 std::cerr << "llvm-upgrade: no parse result.\n";
1673 // Reset ParserResult variable while saving its value for the result.
1674 Module *Result = ParserResult;
1677 //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1680 if ((F = Result->getNamedFunction("llvm.va_start"))
1681 && F->getFunctionType()->getNumParams() == 0)
1682 ObsoleteVarArgs = true;
1683 if((F = Result->getNamedFunction("llvm.va_copy"))
1684 && F->getFunctionType()->getNumParams() == 1)
1685 ObsoleteVarArgs = true;
1688 if (ObsoleteVarArgs && NewVarArgs) {
1689 error("This file is corrupt: it uses both new and old style varargs");
1693 if(ObsoleteVarArgs) {
1694 if(Function* F = Result->getNamedFunction("llvm.va_start")) {
1695 if (F->arg_size() != 0) {
1696 error("Obsolete va_start takes 0 argument");
1702 //bar = alloca typeof(foo)
1706 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1707 const Type* ArgTy = F->getFunctionType()->getReturnType();
1708 const Type* ArgTyPtr = PointerType::get(ArgTy);
1709 Function* NF = cast<Function>(Result->getOrInsertFunction(
1710 "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
1712 while (!F->use_empty()) {
1713 CallInst* CI = cast<CallInst>(F->use_back());
1714 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
1715 new CallInst(NF, bar, "", CI);
1716 Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
1717 CI->replaceAllUsesWith(foo);
1718 CI->getParent()->getInstList().erase(CI);
1720 Result->getFunctionList().erase(F);
1723 if(Function* F = Result->getNamedFunction("llvm.va_end")) {
1724 if(F->arg_size() != 1) {
1725 error("Obsolete va_end takes 1 argument");
1731 //bar = alloca 1 of typeof(foo)
1733 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1734 const Type* ArgTy = F->getFunctionType()->getParamType(0);
1735 const Type* ArgTyPtr = PointerType::get(ArgTy);
1736 Function* NF = cast<Function>(Result->getOrInsertFunction(
1737 "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
1739 while (!F->use_empty()) {
1740 CallInst* CI = cast<CallInst>(F->use_back());
1741 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
1742 new StoreInst(CI->getOperand(1), bar, CI);
1743 new CallInst(NF, bar, "", CI);
1744 CI->getParent()->getInstList().erase(CI);
1746 Result->getFunctionList().erase(F);
1749 if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
1750 if(F->arg_size() != 1) {
1751 error("Obsolete va_copy takes 1 argument");
1756 //a = alloca 1 of typeof(foo)
1757 //b = alloca 1 of typeof(foo)
1762 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1763 const Type* ArgTy = F->getFunctionType()->getReturnType();
1764 const Type* ArgTyPtr = PointerType::get(ArgTy);
1765 Function* NF = cast<Function>(Result->getOrInsertFunction(
1766 "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
1768 while (!F->use_empty()) {
1769 CallInst* CI = cast<CallInst>(F->use_back());
1770 AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
1771 AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
1772 new StoreInst(CI->getOperand(1), b, CI);
1773 new CallInst(NF, a, b, "", CI);
1774 Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
1775 CI->replaceAllUsesWith(foo);
1776 CI->getParent()->getInstList().erase(CI);
1778 Result->getFunctionList().erase(F);
1785 } // end llvm namespace
1787 using namespace llvm;
1791 /* Enabling traces. */
1796 /* Enabling verbose error messages. */
1797 #ifdef YYERROR_VERBOSE
1798 # undef YYERROR_VERBOSE
1799 # define YYERROR_VERBOSE 1
1801 # define YYERROR_VERBOSE 0
1804 /* Enabling the token table. */
1805 #ifndef YYTOKEN_TABLE
1806 # define YYTOKEN_TABLE 0
1809 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1810 #line 1431 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
1811 typedef union YYSTYPE {
1812 llvm::Module *ModuleVal;
1813 llvm::Function *FunctionVal;
1814 std::pair<llvm::PATypeInfo, char*> *ArgVal;
1815 llvm::BasicBlock *BasicBlockVal;
1816 llvm::TerminatorInst *TermInstVal;
1817 llvm::InstrInfo InstVal;
1818 llvm::ConstInfo ConstVal;
1819 llvm::ValueInfo ValueVal;
1820 llvm::PATypeInfo TypeVal;
1821 llvm::TypeInfo PrimType;
1822 llvm::PHIListInfo PHIList;
1823 std::list<llvm::PATypeInfo> *TypeList;
1824 std::vector<llvm::ValueInfo> *ValueList;
1825 std::vector<llvm::ConstInfo> *ConstVector;
1828 std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
1829 // Represent the RHS of PHI node
1830 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1832 llvm::GlobalValue::LinkageTypes Linkage;
1840 char *StrVal; // This memory is strdup'd!
1841 llvm::ValID ValIDVal; // strdup'd memory maybe!
1843 llvm::BinaryOps BinaryOpVal;
1844 llvm::TermOps TermOpVal;
1845 llvm::MemoryOps MemOpVal;
1846 llvm::OtherOps OtherOpVal;
1847 llvm::CastOps CastOpVal;
1848 llvm::ICmpInst::Predicate IPred;
1849 llvm::FCmpInst::Predicate FPred;
1850 llvm::Module::Endianness Endianness;
1852 /* Line 196 of yacc.c. */
1853 #line 1854 "UpgradeParser.tab.c"
1854 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1855 # define YYSTYPE_IS_DECLARED 1
1856 # define YYSTYPE_IS_TRIVIAL 1
1861 /* Copy the second part of user declarations. */
1864 /* Line 219 of yacc.c. */
1865 #line 1866 "UpgradeParser.tab.c"
1867 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1868 # define YYSIZE_T __SIZE_TYPE__
1870 #if ! defined (YYSIZE_T) && defined (size_t)
1871 # define YYSIZE_T size_t
1873 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1874 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1875 # define YYSIZE_T size_t
1877 #if ! defined (YYSIZE_T)
1878 # define YYSIZE_T unsigned int
1884 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1885 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1889 # define YY_(msgid) msgid
1893 #if ! defined (yyoverflow) || YYERROR_VERBOSE
1895 /* The parser invokes alloca or malloc; define the necessary symbols. */
1897 # ifdef YYSTACK_USE_ALLOCA
1898 # if YYSTACK_USE_ALLOCA
1900 # define YYSTACK_ALLOC __builtin_alloca
1902 # define YYSTACK_ALLOC alloca
1903 # if defined (__STDC__) || defined (__cplusplus)
1904 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1905 # define YYINCLUDED_STDLIB_H
1911 # ifdef YYSTACK_ALLOC
1912 /* Pacify GCC's `empty if-body' warning. */
1913 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1914 # ifndef YYSTACK_ALLOC_MAXIMUM
1915 /* The OS might guarantee only one guard page at the bottom of the stack,
1916 and a page size can be as small as 4096 bytes. So we cannot safely
1917 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1918 to allow for a few compiler-allocated temporary stack slots. */
1919 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1922 # define YYSTACK_ALLOC YYMALLOC
1923 # define YYSTACK_FREE YYFREE
1924 # ifndef YYSTACK_ALLOC_MAXIMUM
1925 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1931 # define YYMALLOC malloc
1932 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1933 && (defined (__STDC__) || defined (__cplusplus)))
1934 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1938 # define YYFREE free
1939 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1940 && (defined (__STDC__) || defined (__cplusplus)))
1941 void free (void *); /* INFRINGES ON USER NAME SPACE */
1948 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1951 #if (! defined (yyoverflow) \
1952 && (! defined (__cplusplus) \
1953 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1955 /* A type that is properly aligned for any stack member. */
1962 /* The size of the maximum gap between one aligned stack and the next. */
1963 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1965 /* The size of an array large to enough to hold all stacks, each with
1967 # define YYSTACK_BYTES(N) \
1968 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
1969 + YYSTACK_GAP_MAXIMUM)
1971 /* Copy COUNT objects from FROM to TO. The source and destination do
1974 # if defined (__GNUC__) && 1 < __GNUC__
1975 # define YYCOPY(To, From, Count) \
1976 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1978 # define YYCOPY(To, From, Count) \
1982 for (yyi = 0; yyi < (Count); yyi++) \
1983 (To)[yyi] = (From)[yyi]; \
1989 /* Relocate STACK from its old location to the new one. The
1990 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1991 elements in the stack, and YYPTR gives the new location of the
1992 stack. Advance YYPTR to a properly aligned location for the next
1994 # define YYSTACK_RELOCATE(Stack) \
1997 YYSIZE_T yynewbytes; \
1998 YYCOPY (&yyptr->Stack, Stack, yysize); \
1999 Stack = &yyptr->Stack; \
2000 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2001 yyptr += yynewbytes / sizeof (*yyptr); \
2007 #if defined (__STDC__) || defined (__cplusplus)
2008 typedef signed char yysigned_char;
2010 typedef short int yysigned_char;
2013 /* YYFINAL -- State number of the termination state. */
2015 /* YYLAST -- Last index in YYTABLE. */
2018 /* YYNTOKENS -- Number of terminals. */
2019 #define YYNTOKENS 166
2020 /* YYNNTS -- Number of nonterminals. */
2022 /* YYNRULES -- Number of rules. */
2023 #define YYNRULES 308
2024 /* YYNRULES -- Number of states. */
2025 #define YYNSTATES 604
2027 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2028 #define YYUNDEFTOK 2
2029 #define YYMAXUTOK 406
2031 #define YYTRANSLATE(YYX) \
2032 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2034 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2035 static const unsigned char yytranslate[] =
2037 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2038 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2039 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2040 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2041 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2042 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2043 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2044 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2045 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2046 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2047 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2048 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2049 158, 2, 2, 162, 2, 163, 2, 2, 2, 2,
2050 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2051 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2052 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2053 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2054 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2055 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2056 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2057 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2058 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2059 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2060 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2061 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2062 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2063 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2064 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2065 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2066 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2067 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2068 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2069 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2070 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2071 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2072 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2073 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2074 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2075 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2076 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2077 145, 146, 147, 148, 149, 150, 151
2081 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2083 static const unsigned short int yyprhs[] =
2085 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
2086 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
2087 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
2088 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
2089 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
2090 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
2091 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
2092 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
2093 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
2094 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
2095 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
2096 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
2097 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
2098 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
2099 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
2100 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
2101 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
2102 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
2103 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
2104 528, 529, 537, 538, 546, 547, 555, 559, 564, 565,
2105 567, 569, 571, 575, 579, 583, 587, 591, 595, 597,
2106 598, 600, 602, 604, 605, 608, 612, 614, 616, 620,
2107 622, 623, 632, 634, 636, 640, 642, 644, 647, 648,
2108 650, 652, 653, 658, 659, 661, 663, 665, 667, 669,
2109 671, 673, 675, 677, 681, 683, 689, 691, 693, 695,
2110 697, 700, 703, 706, 710, 713, 714, 716, 718, 720,
2111 723, 726, 730, 740, 750, 759, 773, 775, 777, 784,
2112 790, 793, 800, 808, 810, 814, 816, 817, 820, 822,
2113 828, 834, 840, 847, 854, 857, 862, 867, 874, 879,
2114 884, 889, 894, 901, 908, 911, 919, 921, 924, 925,
2115 927, 928, 932, 939, 943, 950, 953, 958, 965
2118 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2119 static const short int yyrhs[] =
2121 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
2122 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
2123 -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
2124 -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
2125 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
2126 -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
2127 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
2128 -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
2129 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
2130 -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
2131 -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
2132 -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
2133 -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
2134 -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
2135 -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
2136 -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
2137 -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
2138 -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
2139 -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
2140 -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
2141 -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
2142 -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
2143 -1, 191, -1, 8, -1, 193, -1, 8, -1, 193,
2144 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
2145 -1, 14, -1, 15, -1, 16, -1, 17, -1, 18,
2146 -1, 19, -1, 21, -1, 192, -1, 48, -1, 227,
2147 -1, 154, 4, -1, 190, 155, 195, 156, -1, 157,
2148 4, 158, 193, 159, -1, 160, 4, 158, 193, 161,
2149 -1, 162, 194, 163, -1, 162, 163, -1, 160, 162,
2150 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
2151 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
2152 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
2153 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
2154 191, 160, 198, 161, -1, 191, 162, 198, 163, -1,
2155 191, 162, 163, -1, 191, 160, 162, 198, 163, 161,
2156 -1, 191, 160, 162, 163, 161, -1, 191, 38, -1,
2157 191, 39, -1, 191, 227, -1, 191, 197, -1, 191,
2158 26, -1, 176, 168, -1, 177, 4, -1, 9, 27,
2159 -1, 9, 28, -1, 179, 7, -1, 175, 155, 196,
2160 36, 191, 156, -1, 110, 155, 196, 242, 156, -1,
2161 112, 155, 196, 153, 196, 153, 196, 156, -1, 169,
2162 155, 196, 153, 196, 156, -1, 170, 155, 196, 153,
2163 196, 156, -1, 171, 155, 196, 153, 196, 156, -1,
2164 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
2165 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
2166 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
2167 115, 155, 196, 153, 196, 153, 196, 156, -1, 116,
2168 155, 196, 153, 196, 153, 196, 156, -1, 198, 153,
2169 196, -1, 196, -1, 32, -1, 33, -1, 201, -1,
2170 201, 221, -1, 201, 223, -1, 201, 62, 61, 207,
2171 -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
2172 -1, 202, 223, -1, 202, 62, 61, 207, -1, -1,
2173 202, 180, 181, 199, 196, 203, 187, -1, -1, 202,
2174 180, 50, 199, 191, 204, 187, -1, -1, 202, 180,
2175 45, 199, 191, 205, 187, -1, -1, 202, 180, 47,
2176 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
2177 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
2178 -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
2179 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
2180 -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
2181 24, -1, 212, -1, -1, 191, 213, -1, 215, 153,
2182 214, -1, 214, -1, 215, -1, 215, 153, 37, -1,
2183 37, -1, -1, 182, 189, 212, 155, 216, 156, 186,
2184 183, -1, 29, -1, 162, -1, 181, 217, 218, -1,
2185 30, -1, 163, -1, 230, 220, -1, -1, 45, -1,
2186 47, -1, -1, 31, 224, 222, 217, -1, -1, 63,
2187 -1, 3, -1, 4, -1, 7, -1, 27, -1, 28,
2188 -1, 38, -1, 39, -1, 26, -1, 160, 198, 161,
2189 -1, 197, -1, 61, 225, 24, 153, 24, -1, 167,
2190 -1, 212, -1, 227, -1, 226, -1, 191, 228, -1,
2191 230, 231, -1, 219, 231, -1, 232, 180, 234, -1,
2192 232, 236, -1, -1, 23, -1, 77, -1, 78, -1,
2193 72, 229, -1, 72, 8, -1, 73, 21, 228, -1,
2194 73, 9, 228, 153, 21, 228, 153, 21, 228, -1,
2195 74, 178, 228, 153, 21, 228, 157, 235, 159, -1,
2196 74, 178, 228, 153, 21, 228, 157, 159, -1, 75,
2197 182, 189, 228, 155, 239, 156, 36, 21, 228, 233,
2198 21, 228, -1, 233, -1, 76, -1, 235, 178, 226,
2199 153, 21, 228, -1, 178, 226, 153, 21, 228, -1,
2200 180, 241, -1, 191, 157, 228, 153, 228, 159, -1,
2201 237, 153, 157, 228, 153, 228, 159, -1, 229, -1,
2202 238, 153, 229, -1, 238, -1, -1, 60, 59, -1,
2203 59, -1, 169, 191, 228, 153, 228, -1, 170, 191,
2204 228, 153, 228, -1, 171, 191, 228, 153, 228, -1,
2205 103, 172, 191, 228, 153, 228, -1, 104, 173, 191,
2206 228, 153, 228, -1, 49, 229, -1, 174, 229, 153,
2207 229, -1, 175, 229, 36, 191, -1, 112, 229, 153,
2208 229, 153, 229, -1, 113, 229, 153, 191, -1, 117,
2209 229, 153, 191, -1, 118, 229, 153, 191, -1, 114,
2210 229, 153, 229, -1, 115, 229, 153, 229, 153, 229,
2211 -1, 116, 229, 153, 229, 153, 229, -1, 111, 237,
2212 -1, 240, 182, 189, 228, 155, 239, 156, -1, 244,
2213 -1, 153, 238, -1, -1, 35, -1, -1, 105, 191,
2214 184, -1, 105, 191, 153, 15, 228, 184, -1, 106,
2215 191, 184, -1, 106, 191, 153, 15, 228, 184, -1,
2216 107, 229, -1, 243, 108, 191, 228, -1, 243, 109,
2217 229, 153, 191, 228, -1, 110, 191, 228, 242, -1
2220 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2221 static const unsigned short int yyrline[] =
2223 0, 1571, 1571, 1572, 1580, 1581, 1591, 1591, 1591, 1591,
2224 1591, 1591, 1591, 1591, 1591, 1591, 1591, 1595, 1595, 1595,
2225 1599, 1599, 1599, 1599, 1599, 1599, 1603, 1603, 1604, 1604,
2226 1605, 1605, 1606, 1606, 1607, 1607, 1611, 1611, 1612, 1612,
2227 1613, 1613, 1614, 1614, 1615, 1615, 1616, 1616, 1617, 1617,
2228 1618, 1619, 1622, 1622, 1622, 1622, 1626, 1626, 1626, 1626,
2229 1626, 1626, 1626, 1627, 1627, 1627, 1627, 1627, 1627, 1633,
2230 1633, 1633, 1633, 1637, 1637, 1637, 1637, 1641, 1641, 1645,
2231 1645, 1650, 1653, 1658, 1659, 1660, 1661, 1662, 1663, 1664,
2232 1665, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1686,
2233 1687, 1695, 1696, 1704, 1713, 1714, 1721, 1722, 1726, 1730,
2234 1746, 1747, 1754, 1755, 1762, 1770, 1770, 1770, 1770, 1770,
2235 1770, 1770, 1771, 1771, 1771, 1771, 1771, 1776, 1780, 1784,
2236 1789, 1798, 1818, 1824, 1837, 1846, 1850, 1861, 1865, 1878,
2237 1882, 1889, 1890, 1896, 1903, 1915, 1945, 1958, 1981, 2009,
2238 2031, 2042, 2064, 2075, 2084, 2089, 2147, 2154, 2162, 2169,
2239 2176, 2180, 2184, 2193, 2208, 2221, 2230, 2258, 2271, 2280,
2240 2286, 2292, 2303, 2309, 2315, 2326, 2327, 2336, 2337, 2349,
2241 2358, 2359, 2360, 2361, 2362, 2378, 2398, 2400, 2402, 2402,
2242 2409, 2409, 2416, 2416, 2423, 2423, 2431, 2433, 2435, 2440,
2243 2454, 2455, 2459, 2462, 2470, 2474, 2481, 2485, 2489, 2493,
2244 2501, 2501, 2505, 2506, 2510, 2518, 2523, 2531, 2532, 2539,
2245 2546, 2550, 2686, 2686, 2690, 2700, 2700, 2704, 2708, 2710,
2246 2711, 2715, 2715, 2727, 2728, 2733, 2734, 2735, 2736, 2737,
2247 2738, 2739, 2740, 2741, 2762, 2765, 2780, 2781, 2786, 2786,
2248 2794, 2803, 2806, 2815, 2825, 2830, 2839, 2850, 2850, 2853,
2249 2856, 2859, 2863, 2869, 2884, 2890, 2946, 2949, 2955, 2965,
2250 2978, 3007, 3015, 3023, 3027, 3034, 3035, 3039, 3042, 3048,
2251 3065, 3081, 3095, 3107, 3119, 3130, 3148, 3157, 3166, 3173,
2252 3194, 3218, 3224, 3230, 3236, 3252, 3330, 3338, 3339, 3343,
2253 3344, 3348, 3354, 3360, 3366, 3372, 3379, 3391, 3405
2257 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2258 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2259 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2260 static const char *const yytname[] =
2262 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2263 "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2264 "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2265 "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2266 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2267 "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2268 "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2269 "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2270 "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2271 "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2272 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2273 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2274 "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2275 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2276 "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2277 "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2278 "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2279 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2280 "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2281 "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2282 "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2283 "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2284 "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2285 "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2286 "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2287 "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2288 "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2289 "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2290 "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2291 "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2292 "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2293 "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2294 "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2295 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2296 "END", "Function", "FnDeclareLinkage", "FunctionProto", "@5",
2297 "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2298 "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2299 "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2300 "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2301 "OptVolatile", "MemoryInst", 0
2306 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2308 static const unsigned short int yytoknum[] =
2310 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2311 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2312 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2313 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2314 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2315 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2316 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2317 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2318 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2319 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2320 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2321 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
2322 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2323 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2324 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2325 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
2326 60, 62, 123, 125, 42, 99
2330 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2331 static const unsigned char yyr1[] =
2333 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2334 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
2335 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
2336 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
2337 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
2338 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
2339 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
2340 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
2341 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
2342 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
2343 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
2344 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
2345 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
2346 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
2347 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
2348 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
2349 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
2350 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
2351 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
2352 204, 202, 205, 202, 206, 202, 202, 202, 202, 207,
2353 208, 208, 209, 209, 209, 209, 210, 211, 211, 211,
2354 212, 212, 213, 213, 214, 215, 215, 216, 216, 216,
2355 216, 217, 218, 218, 219, 220, 220, 221, 222, 222,
2356 222, 224, 223, 225, 225, 226, 226, 226, 226, 226,
2357 226, 226, 226, 226, 226, 226, 227, 227, 228, 228,
2358 229, 230, 230, 231, 232, 232, 232, 233, 233, 234,
2359 234, 234, 234, 234, 234, 234, 234, 234, 235, 235,
2360 236, 237, 237, 238, 238, 239, 239, 240, 240, 241,
2361 241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
2362 241, 241, 241, 241, 241, 241, 241, 242, 242, 243,
2363 243, 244, 244, 244, 244, 244, 244, 244, 244
2366 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2367 static const unsigned char yyr2[] =
2369 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2370 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2374 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2375 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2376 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2377 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
2378 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
2379 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
2380 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2382 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
2383 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
2384 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
2385 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
2386 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
2387 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
2388 0, 7, 0, 7, 0, 7, 3, 4, 0, 1,
2389 1, 1, 3, 3, 3, 3, 3, 3, 1, 0,
2390 1, 1, 1, 0, 2, 3, 1, 1, 3, 1,
2391 0, 8, 1, 1, 3, 1, 1, 2, 0, 1,
2392 1, 0, 4, 0, 1, 1, 1, 1, 1, 1,
2393 1, 1, 1, 3, 1, 5, 1, 1, 1, 1,
2394 2, 2, 2, 3, 2, 0, 1, 1, 1, 2,
2395 2, 3, 9, 9, 8, 13, 1, 1, 6, 5,
2396 2, 6, 7, 1, 3, 1, 0, 2, 1, 5,
2397 5, 5, 6, 6, 2, 4, 4, 6, 4, 4,
2398 4, 4, 6, 6, 2, 7, 1, 2, 0, 1,
2399 0, 3, 6, 3, 6, 2, 4, 6, 4
2402 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2403 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2404 means the default is an error. */
2405 static const unsigned short int yydefact[] =
2407 198, 0, 90, 184, 1, 183, 231, 83, 84, 85,
2408 86, 87, 88, 89, 0, 91, 255, 180, 181, 255,
2409 210, 211, 0, 0, 0, 90, 0, 186, 228, 0,
2410 0, 92, 93, 94, 95, 96, 97, 0, 0, 256,
2411 252, 82, 225, 226, 227, 251, 0, 0, 0, 0,
2412 196, 0, 0, 0, 0, 0, 0, 0, 81, 229,
2413 230, 91, 199, 182, 98, 2, 3, 111, 115, 116,
2414 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2415 128, 0, 0, 0, 0, 246, 0, 0, 110, 127,
2416 114, 247, 129, 222, 223, 224, 300, 254, 0, 0,
2417 0, 0, 209, 197, 187, 185, 177, 178, 0, 0,
2418 0, 0, 232, 130, 0, 0, 0, 113, 135, 139,
2419 0, 0, 144, 138, 299, 0, 278, 0, 0, 0,
2420 0, 91, 267, 257, 258, 6, 7, 8, 9, 10,
2421 11, 12, 13, 14, 15, 16, 17, 18, 19, 52,
2422 53, 54, 55, 20, 21, 22, 23, 24, 25, 0,
2423 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2424 0, 0, 0, 68, 56, 57, 58, 59, 60, 61,
2425 62, 63, 64, 65, 66, 67, 0, 0, 0, 0,
2426 0, 266, 253, 91, 270, 0, 296, 204, 201, 200,
2427 202, 203, 205, 208, 0, 192, 194, 190, 115, 116,
2428 117, 118, 119, 120, 121, 122, 123, 124, 125, 0,
2429 0, 0, 0, 188, 0, 0, 0, 0, 0, 134,
2430 220, 143, 141, 0, 0, 284, 277, 260, 259, 0,
2431 0, 72, 76, 71, 75, 70, 74, 69, 73, 77,
2432 78, 0, 0, 26, 27, 28, 29, 30, 31, 32,
2433 33, 34, 35, 0, 50, 51, 46, 47, 48, 49,
2434 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
2435 0, 101, 101, 305, 0, 0, 294, 0, 0, 0,
2436 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2437 0, 0, 0, 206, 106, 106, 106, 160, 161, 4,
2438 5, 158, 159, 162, 157, 153, 154, 0, 0, 0,
2439 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2440 0, 0, 0, 156, 155, 106, 112, 112, 137, 0,
2441 140, 219, 213, 216, 217, 0, 0, 131, 235, 236,
2442 237, 242, 238, 239, 240, 241, 233, 0, 244, 249,
2443 248, 250, 0, 261, 0, 0, 0, 0, 0, 301,
2444 0, 303, 298, 0, 0, 0, 0, 0, 0, 0,
2445 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2446 207, 0, 193, 195, 191, 0, 0, 0, 0, 0,
2447 0, 0, 146, 176, 0, 0, 0, 150, 0, 147,
2448 0, 0, 0, 0, 0, 189, 132, 133, 136, 212,
2449 214, 0, 104, 142, 234, 0, 0, 0, 0, 0,
2450 0, 0, 0, 0, 0, 0, 308, 0, 0, 0,
2451 288, 291, 0, 0, 289, 290, 0, 0, 0, 285,
2452 286, 0, 306, 0, 0, 0, 108, 106, 0, 0,
2453 298, 0, 0, 0, 0, 0, 145, 135, 114, 0,
2454 148, 149, 0, 0, 0, 0, 0, 218, 215, 105,
2455 99, 0, 243, 0, 0, 276, 0, 0, 101, 102,
2456 101, 273, 297, 0, 0, 0, 0, 0, 279, 280,
2457 281, 276, 0, 103, 109, 107, 0, 0, 0, 0,
2458 0, 0, 0, 175, 152, 0, 0, 0, 0, 0,
2459 0, 0, 221, 0, 0, 0, 275, 0, 282, 283,
2460 0, 302, 304, 0, 0, 0, 287, 292, 293, 0,
2461 307, 0, 0, 164, 0, 0, 0, 0, 151, 0,
2462 0, 0, 0, 0, 100, 245, 0, 0, 0, 274,
2463 271, 0, 295, 0, 0, 0, 172, 0, 0, 166,
2464 167, 168, 171, 163, 0, 264, 0, 0, 0, 272,
2465 169, 170, 0, 0, 0, 262, 0, 263, 0, 0,
2466 165, 173, 174, 0, 0, 0, 0, 0, 0, 269,
2470 /* YYDEFGOTO[NTERM-NUM]. */
2471 static const short int yydefgoto[] =
2473 -1, 85, 311, 328, 329, 330, 263, 280, 331, 332,
2474 219, 220, 251, 221, 25, 15, 37, 522, 369, 456,
2475 480, 392, 457, 86, 87, 222, 89, 90, 120, 233,
2476 403, 358, 404, 108, 1, 2, 3, 335, 306, 304,
2477 305, 63, 200, 50, 103, 204, 91, 420, 343, 344,
2478 345, 38, 95, 16, 44, 17, 61, 18, 28, 425,
2479 359, 92, 361, 491, 19, 40, 41, 191, 192, 577,
2480 97, 286, 526, 527, 193, 194, 436, 195, 196
2483 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2485 #define YYPACT_NINF -541
2486 static const short int yypact[] =
2488 -541, 28, 61, 478, -541, -541, -541, -541, -541, -541,
2489 -541, -541, -541, -541, 23, 152, 45, -541, -541, -9,
2490 -541, -541, -20, -51, 76, 69, 12, -541, 97, 149,
2491 172, -541, -541, -541, -541, -541, -541, 1331, -19, -541,
2492 -541, 137, -541, -541, -541, -541, 49, 58, 60, 62,
2493 -541, 72, 149, 1331, 88, 88, 88, 88, -541, -541,
2494 -541, 152, -541, -541, -541, -541, -541, 75, -541, -541,
2495 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2496 -541, 227, 228, 3, 691, -541, 137, 79, -541, -541,
2497 -46, -541, -541, -541, -541, -541, 1585, -541, 212, 136,
2498 233, 214, 216, -541, -541, -541, -541, -541, 1392, 1392,
2499 1392, 1433, -541, -541, 83, 87, 711, -541, -541, -46,
2500 -70, 89, 777, -541, -541, 1392, -541, 183, 1453, 6,
2501 309, 152, -541, -541, -541, -541, -541, -541, -541, -541,
2502 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2503 -541, -541, -541, -541, -541, -541, -541, -541, -541, 59,
2504 142, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392,
2505 1392, 1392, 1392, -541, -541, -541, -541, -541, -541, -541,
2506 -541, -541, -541, -541, -541, -541, 1392, 1392, 1392, 1392,
2507 1392, -541, -541, 152, -541, 86, -541, -541, -541, -541,
2508 -541, -541, -541, -541, -129, -541, -541, -541, 169, 196,
2509 242, 200, 246, 203, 252, 205, 253, 251, 258, 221,
2510 255, 259, 533, -541, 1392, 1392, 99, -63, 1392, -541,
2511 1173, -541, 128, 126, 894, -541, -541, 75, -541, 894,
2512 894, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2513 -541, 894, 1331, -541, -541, -541, -541, -541, -541, -541,
2514 -541, -541, -541, 1392, -541, -541, -541, -541, -541, -541,
2515 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2516 1392, 130, 133, -541, 894, 132, 138, 139, 143, 144,
2517 151, 155, 156, 157, 894, 894, 894, 163, 254, 1331,
2518 1392, 1392, 271, -541, 164, 164, 164, -541, -541, -541,
2519 -541, -541, -541, -541, -541, -541, -541, 59, 142, 173,
2520 174, 175, 176, 177, 1214, 1494, 732, 281, 178, 179,
2521 180, 182, 190, -541, -541, 164, -42, -135, -541, 166,
2522 -46, -541, 137, -541, 193, 191, 1234, -541, -541, -541,
2523 -541, -541, -541, -541, -541, -541, 290, 1433, -541, -541,
2524 -541, -541, 201, -541, 202, 894, 894, 894, 7, -541,
2525 10, -541, 204, 894, 199, 1392, 1392, 1392, 1392, 1392,
2526 1392, 1392, 211, 215, 217, 1392, 1392, 894, 894, 223,
2527 -541, -21, -541, -541, -541, 210, 219, 1433, 1433, 1433,
2528 1433, 1433, -541, -541, 4, 752, -91, -541, -8, -541,
2529 1433, 1433, 1433, 1433, 1433, -541, -541, -541, -541, -541,
2530 -541, 1275, 324, -541, -541, 343, 37, 348, 356, 224,
2531 225, 229, 894, 376, 894, 1392, -541, 230, 894, 232,
2532 -541, -541, 234, 235, -541, -541, 894, 894, 894, -541,
2533 -541, 226, -541, 1392, 362, 385, -541, 164, 1433, 1433,
2534 204, 238, 239, 240, 241, 1433, -541, 243, -17, -5,
2535 -541, -541, 247, 250, 261, 262, 359, -541, -541, -541,
2536 339, 268, -541, 894, 894, 1392, 894, 894, 269, -541,
2537 269, -541, 270, 894, 272, 1392, 1392, 1392, -541, -541,
2538 -541, 1392, 894, -541, -541, -541, 273, 274, 249, 1433,
2539 1433, 1433, 1433, -541, -541, 245, 1433, 1433, 1433, 1433,
2540 1392, 395, -541, 383, 275, 267, 270, 279, -541, -541,
2541 351, -541, -541, 1392, 277, 894, -541, -541, -541, 282,
2542 -541, 1433, 1433, -541, 278, 283, 284, 288, -541, 289,
2543 291, 295, 296, 297, -541, -541, 423, 43, 410, -541,
2544 -541, 298, -541, 300, 305, 1433, -541, 1433, 1433, -541,
2545 -541, -541, -541, -541, 894, -541, 1020, 64, 441, -541,
2546 -541, -541, 307, 311, 314, -541, 312, -541, 1020, 894,
2547 -541, -541, -541, 450, 319, 150, 894, 452, 453, -541,
2548 894, 894, -541, -541
2551 /* YYPGOTO[NTERM-NUM]. */
2552 static const short int yypgoto[] =
2554 -541, -541, -541, 379, 380, 381, 161, 162, 386, 388,
2555 -128, -127, -540, -541, 438, 456, -111, -541, -277, 63,
2556 -541, -297, -541, -47, -541, -37, -541, -53, 40, -541,
2557 -99, 264, -307, 84, -541, -541, -541, -541, -541, -541,
2558 -541, 435, -541, -541, -541, -541, 8, -541, 68, -541,
2559 -541, 427, -541, -541, -541, -541, -541, 487, -541, -541,
2560 -489, -199, 67, -124, -541, 472, -541, -103, -541, -541,
2561 -541, -541, 71, -7, -541, -541, 33, -541, -541
2564 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2565 positive, shift that token. If negative, reduce the rule which
2566 number is the opposite. If zero, do what YYDEFACT says.
2567 If YYTABLE_NINF, syntax error. */
2568 #define YYTABLE_NINF -180
2569 static const short int yytable[] =
2571 88, 235, 249, 250, 238, 371, 105, 115, 393, 394,
2572 93, 26, 223, 454, 39, 239, 88, 576, 406, 408,
2573 252, 42, 432, 334, 302, 434, 417, 240, 4, 123,
2574 303, 119, 46, 47, 48, 360, 455, 588, 415, 283,
2575 360, 360, 287, 288, 289, 290, 291, 292, 293, 26,
2576 426, 49, 360, 241, 242, 243, 244, 245, 246, 247,
2577 248, -179, 465, 119, 433, 297, 298, 433, 39, 119,
2578 470, 205, 206, 207, 241, 242, 243, 244, 245, 246,
2579 247, 248, 299, 228, 29, 360, 5, 586, 234, 53,
2580 228, 234, 6, 229, 121, 360, 360, 360, 469, 594,
2581 339, 51, 7, 8, 9, 10, 11, 12, 13, -112,
2582 7, 8, 9, 10, 54, 12, 55, 416, 123, 56,
2583 106, 107, 123, 14, 281, 282, 234, 284, 285, 234,
2584 234, 234, 234, 234, 234, 234, -139, 52, -112, 109,
2585 110, 111, 59, 94, 60, 465, -139, 123, 465, 294,
2586 295, 296, 234, 234, 43, 471, 227, 465, 515, 20,
2587 505, 21, 232, 466, 58, 116, 360, 360, 360, 264,
2588 265, 336, 337, 62, 360, 340, 64, 389, 253, 254,
2589 255, 256, 257, 258, 259, 260, 261, 262, 360, 360,
2590 465, 198, 199, 342, 300, 301, 307, 308, 482, -72,
2591 -72, 98, 575, -71, -71, 365, -70, -70, -69, -69,
2592 99, 531, 100, 532, 101, 88, 30, 31, 32, 33,
2593 34, 35, 36, 587, 309, 310, 366, 133, 134, 102,
2594 -113, 113, 114, 360, 122, 360, 197, 201, 202, 360,
2595 203, 224, 236, 367, 230, 225, -76, 360, 360, 360,
2596 -75, 439, 387, 441, 442, 443, -74, -73, -79, 312,
2597 338, 449, 88, 388, 234, -80, 313, 266, 267, 268,
2598 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2599 279, 346, 347, 368, 360, 360, 370, 360, 360, 373,
2600 386, 374, 375, 340, 360, 390, 376, 377, 460, 461,
2601 462, 463, 464, 360, 378, 409, 362, 363, 379, 380,
2602 381, 472, 473, 474, 475, 476, 385, 391, 364, 241,
2603 242, 243, 244, 245, 246, 247, 248, 418, 397, 398,
2604 399, 400, 401, 410, 411, 412, 360, 413, 234, 440,
2605 234, 234, 234, 444, 445, 414, 421, 422, 234, 450,
2606 419, 372, 468, 424, 427, 428, 438, 435, 454, 506,
2607 507, 382, 383, 384, 446, 458, 513, 481, 447, 483,
2608 448, 536, 537, 538, 459, 360, 453, 484, 486, 485,
2609 489, 501, 487, 493, 342, 495, 503, 496, 497, 504,
2610 360, 509, 510, 511, 512, 520, 521, 360, 234, 554,
2611 516, 360, 360, 517, 514, 543, 548, 555, 433, 559,
2612 544, 545, 546, 547, 518, 519, 502, 549, 550, 551,
2613 552, 523, 530, 533, 557, 535, 541, 542, 556, 249,
2614 250, 565, 429, 430, 431, 558, 560, 567, 562, 566,
2615 437, 568, 563, 564, 574, 569, 578, 570, 234, 249,
2616 250, 571, 572, 573, 451, 452, 580, 579, 234, 234,
2617 234, 581, 589, 590, 234, 593, 582, 591, 583, 584,
2618 592, 596, 597, 600, 601, 186, 187, 188, 395, 96,
2619 396, 57, 189, 553, 190, 479, 333, 104, 112, 478,
2620 27, 45, 598, 508, 539, 0, 234, 0, -82, 488,
2621 20, 490, 21, 0, 0, 494, 492, 0, 0, 6,
2622 -82, -82, 0, 498, 499, 500, 0, 0, 0, -82,
2623 -82, -82, -82, -82, -82, -82, 0, 0, -82, 22,
2624 0, 0, 0, 0, 0, 0, 23, 0, 65, 66,
2625 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2626 524, 525, 0, 528, 529, 20, 0, 21, 0, 314,
2627 534, 0, 0, 0, 0, 0, 0, 0, 0, 540,
2628 0, 315, 316, 0, 0, 0, 0, 0, 0, 0,
2629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2630 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2631 0, 0, 561, 0, 0, 0, 0, 0, 0, 0,
2632 0, 0, 135, 136, 137, 138, 139, 140, 141, 142,
2633 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
2634 153, 154, 155, 156, 157, 158, 317, 318, 0, 0,
2635 0, 585, 0, 319, 0, 320, 0, 321, 322, 323,
2636 0, 0, 0, 0, 0, 0, 595, 0, 0, 0,
2637 0, 0, 0, 599, 0, 0, 0, 602, 603, 0,
2638 0, 0, 173, 174, 175, 176, 177, 178, 179, 180,
2639 181, 182, 183, 184, 185, 0, 0, 0, 0, 0,
2640 324, 0, 0, 325, 0, 326, 65, 66, 327, 117,
2641 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2642 78, 0, 79, 20, 0, 21, 65, 66, 0, 117,
2643 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2644 78, 0, 79, 20, 0, 21, 0, 65, 66, 80,
2645 117, 208, 209, 210, 211, 212, 213, 214, 215, 216,
2646 217, 218, 0, 79, 20, 0, 21, 65, 66, 80,
2647 117, 208, 209, 210, 211, 212, 213, 214, 215, 216,
2648 217, 218, 0, 79, 20, 0, 21, 0, 0, 0,
2649 80, 0, 65, 66, 0, 117, 68, 69, 70, 71,
2650 72, 73, 74, 75, 76, 77, 78, 0, 79, 20,
2651 80, 21, 0, 0, 0, 0, 0, 0, 0, 0,
2652 0, 0, 0, 0, 231, 0, 0, 0, 0, 0,
2653 0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
2654 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2655 0, 0, 0, 0, 0, 81, 0, 0, 82, 0,
2656 0, 83, 0, 84, 118, 0, 0, 0, 0, 0,
2657 0, 0, 0, 0, 0, 81, 0, 0, 82, 0,
2658 0, 83, 0, 84, 226, 0, 0, 0, 0, 0,
2659 0, 0, 0, 0, 0, 0, 81, 0, 0, 82,
2660 0, 0, 83, 0, 84, 407, 0, 348, 349, 65,
2661 66, 350, 0, 0, 0, 0, 81, 0, 0, 82,
2662 0, 0, 83, 0, 84, 467, 20, 0, 21, 0,
2663 351, 352, 353, 0, 0, 0, 0, 0, 0, 0,
2664 0, 81, 354, 355, 82, 0, 0, 83, 0, 84,
2665 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2666 0, 0, 0, 0, 0, 356, 0, 0, 0, 0,
2667 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2668 0, 0, 0, 135, 136, 137, 138, 139, 140, 141,
2669 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
2670 152, 153, 154, 155, 156, 157, 158, 317, 318, 0,
2671 0, 0, 0, 0, 319, 0, 320, 0, 321, 322,
2672 323, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2673 0, 0, 0, 348, 349, 0, 0, 350, 0, 0,
2674 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
2675 180, 181, 182, 183, 184, 185, 351, 352, 353, 0,
2676 0, 0, 0, 0, 357, 0, 0, 0, 354, 355,
2677 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2678 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2679 0, 356, 0, 0, 0, 0, 0, 0, 0, 0,
2680 0, 0, 0, 0, 0, 0, 0, 0, 0, 135,
2681 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
2682 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2683 156, 157, 158, 317, 318, 0, 0, 0, 0, 0,
2684 319, 0, 320, 0, 321, 322, 323, 0, 0, 0,
2685 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2686 0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2687 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2688 184, 185, 0, 0, 0, 0, 0, 0, 65, 66,
2689 357, 117, 68, 69, 70, 71, 72, 73, 74, 75,
2690 76, 77, 78, 0, 79, 20, 0, 21, 0, 0,
2691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2692 341, 0, 0, 0, 0, 0, 0, 0, 0, 65,
2693 66, 80, 117, 208, 209, 210, 211, 212, 213, 214,
2694 215, 216, 217, 218, 0, 79, 20, 0, 21, 65,
2695 66, 0, 117, 68, 69, 70, 71, 72, 73, 74,
2696 75, 76, 77, 78, 0, 79, 20, 0, 21, 0,
2697 0, 0, 80, 0, 0, 0, 0, 0, 0, 0,
2698 0, 423, 0, 0, 0, 0, 0, 0, 0, 0,
2699 65, 66, 80, 117, 68, 69, 70, 71, 72, 73,
2700 74, 75, 76, 77, 78, 0, 79, 20, 0, 21,
2701 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2702 0, 0, 477, 0, 0, 0, 0, 0, 0, 0,
2703 0, 0, 0, 80, 0, 0, 0, 81, 0, 0,
2704 82, 0, 0, 83, 0, 84, 65, 66, 0, 67,
2705 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2706 78, 0, 79, 20, 0, 21, 0, 0, 0, 0,
2707 0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
2708 0, 82, 0, 402, 83, 0, 84, 0, 0, 80,
2709 0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
2710 0, 82, 0, 0, 83, 0, 84, 65, 66, 0,
2711 117, 68, 69, 70, 71, 72, 73, 74, 75, 76,
2712 77, 78, 0, 79, 20, 0, 21, 0, 0, 0,
2713 0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
2714 0, 0, 82, 0, 0, 83, 0, 84, 65, 66,
2715 80, 117, 208, 209, 210, 211, 212, 213, 214, 215,
2716 216, 217, 218, 0, 79, 20, 0, 21, 65, 66,
2717 0, 237, 68, 69, 70, 71, 72, 73, 74, 75,
2718 76, 77, 78, 0, 79, 20, 0, 21, 0, 0,
2719 0, 80, 0, 0, 0, 81, 0, 0, 82, 0,
2720 0, 83, 0, 84, 0, 0, 0, 0, 0, 65,
2721 66, 80, 117, 208, 209, 210, 211, 212, 213, 214,
2722 215, 216, 217, 218, 0, 79, 20, 0, 21, 0,
2723 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2724 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2725 0, 0, 80, 0, 0, 0, 81, 0, 0, 82,
2726 0, 0, 83, 0, 84, 0, 0, 0, 0, 0,
2727 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2728 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2729 0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
2730 82, 0, 0, 83, 0, 84, 0, 0, 0, 0,
2731 0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
2732 82, 0, 0, 83, 0, 84, 0, 0, 0, 0,
2733 124, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2734 0, 0, 0, 0, 125, 0, 0, 0, 0, 0,
2735 0, 0, 0, 0, 126, 127, 0, 0, 81, 0,
2736 0, 82, 0, 0, 83, 0, 405, 128, 129, 130,
2737 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
2738 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2739 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
2740 161, 162, 163, 0, 0, 164, 165, 166, 167, 168,
2741 169, 170, 171, 172, 0, 0, 0, 0, 0, 0,
2742 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2743 0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2744 179, 180, 181, 182, 183, 184, 185
2747 static const short int yycheck[] =
2749 37, 125, 130, 130, 128, 282, 53, 4, 305, 306,
2750 29, 3, 111, 34, 23, 9, 53, 557, 325, 326,
2751 131, 30, 15, 222, 153, 15, 161, 21, 0, 164,
2752 159, 84, 52, 53, 54, 234, 57, 577, 335, 163,
2753 239, 240, 166, 167, 168, 169, 170, 171, 172, 41,
2754 357, 71, 251, 10, 11, 12, 13, 14, 15, 16,
2755 17, 0, 153, 116, 57, 189, 190, 57, 23, 122,
2756 161, 108, 109, 110, 10, 11, 12, 13, 14, 15,
2757 16, 17, 193, 153, 61, 284, 25, 576, 125, 20,
2758 153, 128, 31, 163, 86, 294, 295, 296, 405, 588,
2759 163, 152, 41, 42, 43, 44, 45, 46, 47, 155,
2760 41, 42, 43, 44, 45, 46, 47, 159, 164, 50,
2761 32, 33, 164, 62, 161, 162, 163, 164, 165, 166,
2762 167, 168, 169, 170, 171, 172, 153, 61, 155, 55,
2763 56, 57, 45, 162, 47, 153, 163, 164, 153, 186,
2764 187, 188, 189, 190, 163, 163, 116, 153, 163, 22,
2765 457, 24, 122, 159, 152, 162, 365, 366, 367, 27,
2766 28, 224, 225, 24, 373, 228, 4, 301, 119, 120,
2767 121, 122, 123, 124, 125, 126, 127, 128, 387, 388,
2768 153, 55, 56, 230, 108, 109, 27, 28, 161, 3,
2769 4, 152, 159, 3, 4, 252, 3, 4, 3, 4,
2770 152, 488, 152, 490, 152, 252, 64, 65, 66, 67,
2771 68, 69, 70, 159, 3, 4, 263, 77, 78, 157,
2772 155, 4, 4, 432, 155, 434, 24, 4, 24, 438,
2773 24, 158, 59, 280, 155, 158, 4, 446, 447, 448,
2774 4, 375, 299, 377, 378, 379, 4, 4, 7, 4,
2775 161, 385, 299, 300, 301, 7, 7, 125, 126, 127,
2776 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
2777 138, 153, 156, 153, 483, 484, 153, 486, 487, 157,
2778 36, 153, 153, 346, 493, 24, 153, 153, 397, 398,
2779 399, 400, 401, 502, 153, 24, 239, 240, 153, 153,
2780 153, 410, 411, 412, 413, 414, 153, 153, 251, 10,
2781 11, 12, 13, 14, 15, 16, 17, 161, 155, 155,
2782 155, 155, 155, 155, 155, 155, 535, 155, 375, 376,
2783 377, 378, 379, 380, 381, 155, 153, 156, 385, 386,
2784 342, 284, 405, 63, 153, 153, 157, 153, 34, 458,
2785 459, 294, 295, 296, 153, 155, 465, 24, 153, 21,
2786 153, 495, 496, 497, 155, 574, 153, 21, 153, 155,
2787 4, 155, 153, 153, 421, 153, 24, 153, 153, 4,
2788 589, 153, 153, 153, 153, 36, 57, 596, 435, 4,
2789 153, 600, 601, 153, 161, 156, 161, 24, 57, 533,
2790 509, 510, 511, 512, 153, 153, 453, 516, 517, 518,
2791 519, 153, 153, 153, 157, 153, 153, 153, 153, 557,
2792 557, 153, 365, 366, 367, 156, 159, 153, 156, 156,
2793 373, 153, 541, 542, 21, 156, 36, 156, 485, 577,
2794 577, 156, 156, 156, 387, 388, 156, 159, 495, 496,
2795 497, 156, 21, 156, 501, 153, 565, 156, 567, 568,
2796 156, 21, 153, 21, 21, 96, 96, 96, 317, 41,
2797 318, 25, 96, 520, 96, 422, 222, 52, 61, 421,
2798 3, 19, 595, 460, 501, -1, 533, -1, 20, 432,
2799 22, 434, 24, -1, -1, 438, 435, -1, -1, 31,
2800 32, 33, -1, 446, 447, 448, -1, -1, -1, 41,
2801 42, 43, 44, 45, 46, 47, -1, -1, 50, 51,
2802 -1, -1, -1, -1, -1, -1, 58, -1, 5, 6,
2803 62, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2804 483, 484, -1, 486, 487, 22, -1, 24, -1, 26,
2805 493, -1, -1, -1, -1, -1, -1, -1, -1, 502,
2806 -1, 38, 39, -1, -1, -1, -1, -1, -1, -1,
2807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2809 -1, -1, 535, -1, -1, -1, -1, -1, -1, -1,
2810 -1, -1, 79, 80, 81, 82, 83, 84, 85, 86,
2811 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
2812 97, 98, 99, 100, 101, 102, 103, 104, -1, -1,
2813 -1, 574, -1, 110, -1, 112, -1, 114, 115, 116,
2814 -1, -1, -1, -1, -1, -1, 589, -1, -1, -1,
2815 -1, -1, -1, 596, -1, -1, -1, 600, 601, -1,
2816 -1, -1, 139, 140, 141, 142, 143, 144, 145, 146,
2817 147, 148, 149, 150, 151, -1, -1, -1, -1, -1,
2818 157, -1, -1, 160, -1, 162, 5, 6, 165, 8,
2819 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2820 19, -1, 21, 22, -1, 24, 5, 6, -1, 8,
2821 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2822 19, -1, 21, 22, -1, 24, -1, 5, 6, 48,
2823 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2824 18, 19, -1, 21, 22, -1, 24, 5, 6, 48,
2825 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2826 18, 19, -1, 21, 22, -1, 24, -1, -1, -1,
2827 48, -1, 5, 6, -1, 8, 9, 10, 11, 12,
2828 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
2829 48, 24, -1, -1, -1, -1, -1, -1, -1, -1,
2830 -1, -1, -1, -1, 37, -1, -1, -1, -1, -1,
2831 -1, -1, -1, -1, -1, 48, -1, -1, -1, -1,
2832 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2833 -1, -1, -1, -1, -1, 154, -1, -1, 157, -1,
2834 -1, 160, -1, 162, 163, -1, -1, -1, -1, -1,
2835 -1, -1, -1, -1, -1, 154, -1, -1, 157, -1,
2836 -1, 160, -1, 162, 163, -1, -1, -1, -1, -1,
2837 -1, -1, -1, -1, -1, -1, 154, -1, -1, 157,
2838 -1, -1, 160, -1, 162, 163, -1, 3, 4, 5,
2839 6, 7, -1, -1, -1, -1, 154, -1, -1, 157,
2840 -1, -1, 160, -1, 162, 163, 22, -1, 24, -1,
2841 26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
2842 -1, 154, 38, 39, 157, -1, -1, 160, -1, 162,
2843 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2844 -1, -1, -1, -1, -1, 61, -1, -1, -1, -1,
2845 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2846 -1, -1, -1, 79, 80, 81, 82, 83, 84, 85,
2847 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
2848 96, 97, 98, 99, 100, 101, 102, 103, 104, -1,
2849 -1, -1, -1, -1, 110, -1, 112, -1, 114, 115,
2850 116, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2851 -1, -1, -1, 3, 4, -1, -1, 7, -1, -1,
2852 -1, -1, -1, 139, 140, 141, 142, 143, 144, 145,
2853 146, 147, 148, 149, 150, 151, 26, 27, 28, -1,
2854 -1, -1, -1, -1, 160, -1, -1, -1, 38, 39,
2855 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2856 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2857 -1, 61, -1, -1, -1, -1, -1, -1, -1, -1,
2858 -1, -1, -1, -1, -1, -1, -1, -1, -1, 79,
2859 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
2860 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
2861 100, 101, 102, 103, 104, -1, -1, -1, -1, -1,
2862 110, -1, 112, -1, 114, 115, 116, -1, -1, -1,
2863 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2864 -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
2865 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
2866 150, 151, -1, -1, -1, -1, -1, -1, 5, 6,
2867 160, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2868 17, 18, 19, -1, 21, 22, -1, 24, -1, -1,
2869 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2870 37, -1, -1, -1, -1, -1, -1, -1, -1, 5,
2871 6, 48, 8, 9, 10, 11, 12, 13, 14, 15,
2872 16, 17, 18, 19, -1, 21, 22, -1, 24, 5,
2873 6, -1, 8, 9, 10, 11, 12, 13, 14, 15,
2874 16, 17, 18, 19, -1, 21, 22, -1, 24, -1,
2875 -1, -1, 48, -1, -1, -1, -1, -1, -1, -1,
2876 -1, 37, -1, -1, -1, -1, -1, -1, -1, -1,
2877 5, 6, 48, 8, 9, 10, 11, 12, 13, 14,
2878 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
2879 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2880 -1, -1, 37, -1, -1, -1, -1, -1, -1, -1,
2881 -1, -1, -1, 48, -1, -1, -1, 154, -1, -1,
2882 157, -1, -1, 160, -1, 162, 5, 6, -1, 8,
2883 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2884 19, -1, 21, 22, -1, 24, -1, -1, -1, -1,
2885 -1, -1, -1, -1, -1, -1, -1, -1, 154, -1,
2886 -1, 157, -1, 159, 160, -1, 162, -1, -1, 48,
2887 -1, -1, -1, -1, -1, -1, -1, -1, 154, -1,
2888 -1, 157, -1, -1, 160, -1, 162, 5, 6, -1,
2889 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2890 18, 19, -1, 21, 22, -1, 24, -1, -1, -1,
2891 -1, -1, -1, -1, -1, -1, -1, -1, -1, 154,
2892 -1, -1, 157, -1, -1, 160, -1, 162, 5, 6,
2893 48, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2894 17, 18, 19, -1, 21, 22, -1, 24, 5, 6,
2895 -1, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2896 17, 18, 19, -1, 21, 22, -1, 24, -1, -1,
2897 -1, 48, -1, -1, -1, 154, -1, -1, 157, -1,
2898 -1, 160, -1, 162, -1, -1, -1, -1, -1, 5,
2899 6, 48, 8, 9, 10, 11, 12, 13, 14, 15,
2900 16, 17, 18, 19, -1, 21, 22, -1, 24, -1,
2901 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2902 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2903 -1, -1, 48, -1, -1, -1, 154, -1, -1, 157,
2904 -1, -1, 160, -1, 162, -1, -1, -1, -1, -1,
2905 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2906 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2907 -1, -1, -1, -1, -1, -1, -1, 154, -1, -1,
2908 157, -1, -1, 160, -1, 162, -1, -1, -1, -1,
2909 -1, -1, -1, -1, -1, -1, -1, 154, -1, -1,
2910 157, -1, -1, 160, -1, 162, -1, -1, -1, -1,
2911 35, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2912 -1, -1, -1, -1, 49, -1, -1, -1, -1, -1,
2913 -1, -1, -1, -1, 59, 60, -1, -1, 154, -1,
2914 -1, 157, -1, -1, 160, -1, 162, 72, 73, 74,
2915 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2916 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2917 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2918 105, 106, 107, -1, -1, 110, 111, 112, 113, 114,
2919 115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
2920 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2921 -1, -1, -1, -1, 139, 140, 141, 142, 143, 144,
2922 145, 146, 147, 148, 149, 150, 151
2925 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2926 symbol of state STATE-NUM. */
2927 static const unsigned char yystos[] =
2929 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
2930 44, 45, 46, 47, 62, 181, 219, 221, 223, 230,
2931 22, 24, 51, 58, 62, 180, 212, 223, 224, 61,
2932 64, 65, 66, 67, 68, 69, 70, 182, 217, 23,
2933 231, 232, 30, 163, 220, 231, 52, 53, 54, 71,
2934 209, 152, 61, 20, 45, 47, 50, 181, 152, 45,
2935 47, 222, 24, 207, 4, 5, 6, 8, 9, 10,
2936 11, 12, 13, 14, 15, 16, 17, 18, 19, 21,
2937 48, 154, 157, 160, 162, 167, 189, 190, 191, 192,
2938 193, 212, 227, 29, 162, 218, 180, 236, 152, 152,
2939 152, 152, 157, 210, 207, 189, 32, 33, 199, 199,
2940 199, 199, 217, 4, 4, 4, 162, 8, 163, 193,
2941 194, 212, 155, 164, 35, 49, 59, 60, 72, 73,
2942 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2943 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2944 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
2945 104, 105, 106, 107, 110, 111, 112, 113, 114, 115,
2946 116, 117, 118, 139, 140, 141, 142, 143, 144, 145,
2947 146, 147, 148, 149, 150, 151, 169, 170, 171, 174,
2948 175, 233, 234, 240, 241, 243, 244, 24, 55, 56,
2949 208, 4, 24, 24, 211, 191, 191, 191, 9, 10,
2950 11, 12, 13, 14, 15, 16, 17, 18, 19, 176,
2951 177, 179, 191, 196, 158, 158, 163, 194, 153, 163,
2952 155, 37, 194, 195, 191, 229, 59, 8, 229, 9,
2953 21, 10, 11, 12, 13, 14, 15, 16, 17, 176,
2954 177, 178, 182, 119, 120, 121, 122, 123, 124, 125,
2955 126, 127, 128, 172, 27, 28, 125, 126, 127, 128,
2956 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2957 173, 191, 191, 229, 191, 191, 237, 229, 229, 229,
2958 229, 229, 229, 229, 191, 191, 191, 229, 229, 182,
2959 108, 109, 153, 159, 205, 206, 204, 27, 28, 3,
2960 4, 168, 4, 7, 26, 38, 39, 103, 104, 110,
2961 112, 114, 115, 116, 157, 160, 162, 165, 169, 170,
2962 171, 174, 175, 197, 227, 203, 193, 193, 161, 163,
2963 193, 37, 191, 214, 215, 216, 153, 156, 3, 4,
2964 7, 26, 27, 28, 38, 39, 61, 160, 197, 226,
2965 227, 228, 228, 228, 228, 189, 191, 191, 153, 184,
2966 153, 184, 228, 157, 153, 153, 153, 153, 153, 153,
2967 153, 153, 228, 228, 228, 153, 36, 189, 191, 229,
2968 24, 153, 187, 187, 187, 172, 173, 155, 155, 155,
2969 155, 155, 159, 196, 198, 162, 198, 163, 198, 24,
2970 155, 155, 155, 155, 155, 187, 159, 161, 161, 212,
2971 213, 153, 156, 37, 63, 225, 198, 153, 153, 228,
2972 228, 228, 15, 57, 15, 153, 242, 228, 157, 229,
2973 191, 229, 229, 229, 191, 191, 153, 153, 153, 229,
2974 191, 228, 228, 153, 34, 57, 185, 188, 155, 155,
2975 196, 196, 196, 196, 196, 153, 159, 163, 193, 198,
2976 161, 163, 196, 196, 196, 196, 196, 37, 214, 185,
2977 186, 24, 161, 21, 21, 155, 153, 153, 228, 4,
2978 228, 229, 238, 153, 228, 153, 153, 153, 228, 228,
2979 228, 155, 191, 24, 4, 187, 196, 196, 242, 153,
2980 153, 153, 153, 196, 161, 163, 153, 153, 153, 153,
2981 36, 57, 183, 153, 228, 228, 238, 239, 228, 228,
2982 153, 184, 184, 153, 228, 153, 229, 229, 229, 239,
2983 228, 153, 153, 156, 196, 196, 196, 196, 161, 196,
2984 196, 196, 196, 191, 4, 24, 153, 157, 156, 229,
2985 159, 228, 156, 196, 196, 153, 156, 153, 153, 156,
2986 156, 156, 156, 156, 21, 159, 178, 235, 36, 159,
2987 156, 156, 196, 196, 196, 228, 226, 159, 178, 21,
2988 156, 156, 156, 153, 226, 228, 21, 153, 233, 228,
2992 #define yyerrok (yyerrstatus = 0)
2993 #define yyclearin (yychar = YYEMPTY)
2994 #define YYEMPTY (-2)
2997 #define YYACCEPT goto yyacceptlab
2998 #define YYABORT goto yyabortlab
2999 #define YYERROR goto yyerrorlab
3002 /* Like YYERROR except do call yyerror. This remains here temporarily
3003 to ease the transition to the new meaning of YYERROR, for GCC.
3004 Once GCC version 2 has supplanted version 1, this can go. */
3006 #define YYFAIL goto yyerrlab
3008 #define YYRECOVERING() (!!yyerrstatus)
3010 #define YYBACKUP(Token, Value) \
3012 if (yychar == YYEMPTY && yylen == 1) \
3016 yytoken = YYTRANSLATE (yychar); \
3022 yyerror (YY_("syntax error: cannot back up")); \
3029 #define YYERRCODE 256
3032 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3033 If N is 0, then set CURRENT to the empty location which ends
3034 the previous symbol: RHS[0] (always defined). */
3036 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3037 #ifndef YYLLOC_DEFAULT
3038 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3042 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3043 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3044 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3045 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3049 (Current).first_line = (Current).last_line = \
3050 YYRHSLOC (Rhs, 0).last_line; \
3051 (Current).first_column = (Current).last_column = \
3052 YYRHSLOC (Rhs, 0).last_column; \
3058 /* YY_LOCATION_PRINT -- Print the location on the stream.
3059 This macro was not mandated originally: define only if we know
3060 we won't break user code: when these are the locations we know. */
3062 #ifndef YY_LOCATION_PRINT
3063 # if YYLTYPE_IS_TRIVIAL
3064 # define YY_LOCATION_PRINT(File, Loc) \
3065 fprintf (File, "%d.%d-%d.%d", \
3066 (Loc).first_line, (Loc).first_column, \
3067 (Loc).last_line, (Loc).last_column)
3069 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3074 /* YYLEX -- calling `yylex' with the right arguments. */
3077 # define YYLEX yylex (YYLEX_PARAM)
3079 # define YYLEX yylex ()
3082 /* Enable debugging if requested. */
3086 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3087 # define YYFPRINTF fprintf
3090 # define YYDPRINTF(Args) \
3096 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3100 YYFPRINTF (stderr, "%s ", Title); \
3101 yysymprint (stderr, \
3103 YYFPRINTF (stderr, "\n"); \
3107 /*------------------------------------------------------------------.
3108 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3110 `------------------------------------------------------------------*/
3112 #if defined (__STDC__) || defined (__cplusplus)
3114 yy_stack_print (short int *bottom, short int *top)
3117 yy_stack_print (bottom, top)
3122 YYFPRINTF (stderr, "Stack now");
3123 for (/* Nothing. */; bottom <= top; ++bottom)
3124 YYFPRINTF (stderr, " %d", *bottom);
3125 YYFPRINTF (stderr, "\n");
3128 # define YY_STACK_PRINT(Bottom, Top) \
3131 yy_stack_print ((Bottom), (Top)); \
3135 /*------------------------------------------------.
3136 | Report that the YYRULE is going to be reduced. |
3137 `------------------------------------------------*/
3139 #if defined (__STDC__) || defined (__cplusplus)
3141 yy_reduce_print (int yyrule)
3144 yy_reduce_print (yyrule)
3149 unsigned long int yylno = yyrline[yyrule];
3150 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3152 /* Print the symbols being reduced, and their result. */
3153 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3154 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3155 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3158 # define YY_REDUCE_PRINT(Rule) \
3161 yy_reduce_print (Rule); \
3164 /* Nonzero means print parse trace. It is left uninitialized so that
3165 multiple parsers can coexist. */
3167 #else /* !YYDEBUG */
3168 # define YYDPRINTF(Args)
3169 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3170 # define YY_STACK_PRINT(Bottom, Top)
3171 # define YY_REDUCE_PRINT(Rule)
3172 #endif /* !YYDEBUG */
3175 /* YYINITDEPTH -- initial size of the parser's stacks. */
3177 # define YYINITDEPTH 200
3180 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3181 if the built-in stack extension method is used).
3183 Do not make this value too large; the results are undefined if
3184 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3185 evaluated with infinite-precision integer arithmetic. */
3188 # define YYMAXDEPTH 10000
3196 # if defined (__GLIBC__) && defined (_STRING_H)
3197 # define yystrlen strlen
3199 /* Return the length of YYSTR. */
3201 # if defined (__STDC__) || defined (__cplusplus)
3202 yystrlen (const char *yystr)
3208 const char *yys = yystr;
3210 while (*yys++ != '\0')
3213 return yys - yystr - 1;
3219 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3220 # define yystpcpy stpcpy
3222 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3225 # if defined (__STDC__) || defined (__cplusplus)
3226 yystpcpy (char *yydest, const char *yysrc)
3228 yystpcpy (yydest, yysrc)
3234 const char *yys = yysrc;
3236 while ((*yyd++ = *yys++) != '\0')
3245 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3246 quotes and backslashes, so that it's suitable for yyerror. The
3247 heuristic is that double-quoting is unnecessary unless the string
3248 contains an apostrophe, a comma, or backslash (other than
3249 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3250 null, do not copy; instead, return the length of what the result
3253 yytnamerr (char *yyres, const char *yystr)
3258 char const *yyp = yystr;
3265 goto do_not_strip_quotes;
3269 goto do_not_strip_quotes;
3282 do_not_strip_quotes: ;
3286 return yystrlen (yystr);
3288 return yystpcpy (yyres, yystr) - yyres;
3292 #endif /* YYERROR_VERBOSE */
3297 /*--------------------------------.
3298 | Print this symbol on YYOUTPUT. |
3299 `--------------------------------*/
3301 #if defined (__STDC__) || defined (__cplusplus)
3303 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3306 yysymprint (yyoutput, yytype, yyvaluep)
3312 /* Pacify ``unused variable'' warnings. */
3315 if (yytype < YYNTOKENS)
3316 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3318 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3322 if (yytype < YYNTOKENS)
3323 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3330 YYFPRINTF (yyoutput, ")");
3333 #endif /* ! YYDEBUG */
3334 /*-----------------------------------------------.
3335 | Release the memory associated to this symbol. |
3336 `-----------------------------------------------*/
3338 #if defined (__STDC__) || defined (__cplusplus)
3340 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3343 yydestruct (yymsg, yytype, yyvaluep)
3349 /* Pacify ``unused variable'' warnings. */
3354 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3365 /* Prevent warnings from -Wmissing-prototypes. */
3367 #ifdef YYPARSE_PARAM
3368 # if defined (__STDC__) || defined (__cplusplus)
3369 int yyparse (void *YYPARSE_PARAM);
3373 #else /* ! YYPARSE_PARAM */
3374 #if defined (__STDC__) || defined (__cplusplus)
3379 #endif /* ! YYPARSE_PARAM */
3383 /* The look-ahead symbol. */
3386 /* The semantic value of the look-ahead symbol. */
3389 /* Number of syntax errors so far. */
3398 #ifdef YYPARSE_PARAM
3399 # if defined (__STDC__) || defined (__cplusplus)
3400 int yyparse (void *YYPARSE_PARAM)
3402 int yyparse (YYPARSE_PARAM)
3403 void *YYPARSE_PARAM;
3405 #else /* ! YYPARSE_PARAM */
3406 #if defined (__STDC__) || defined (__cplusplus)
3420 /* Number of tokens to shift before error messages enabled. */
3422 /* Look-ahead token as an internal (translated) token number. */
3425 /* Three stacks and their tools:
3426 `yyss': related to states,
3427 `yyvs': related to semantic values,
3428 `yyls': related to locations.
3430 Refer to the stacks thru separate pointers, to allow yyoverflow
3431 to reallocate them elsewhere. */
3433 /* The state stack. */
3434 short int yyssa[YYINITDEPTH];
3435 short int *yyss = yyssa;
3438 /* The semantic value stack. */
3439 YYSTYPE yyvsa[YYINITDEPTH];
3440 YYSTYPE *yyvs = yyvsa;
3445 #define YYPOPSTACK (yyvsp--, yyssp--)
3447 YYSIZE_T yystacksize = YYINITDEPTH;
3449 /* The variables used to return semantic value and location from the
3454 /* When reducing, the number of symbols on the RHS of the reduced
3458 YYDPRINTF ((stderr, "Starting parse\n"));
3463 yychar = YYEMPTY; /* Cause a token to be read. */
3465 /* Initialize stack pointers.
3466 Waste one element of value and location stack
3467 so that they stay on the same level as the state stack.
3468 The wasted elements are never initialized. */
3475 /*------------------------------------------------------------.
3476 | yynewstate -- Push a new state, which is found in yystate. |
3477 `------------------------------------------------------------*/
3479 /* In all cases, when you get here, the value and location stacks
3480 have just been pushed. so pushing a state here evens the stacks.
3487 if (yyss + yystacksize - 1 <= yyssp)
3489 /* Get the current used size of the three stacks, in elements. */
3490 YYSIZE_T yysize = yyssp - yyss + 1;
3494 /* Give user a chance to reallocate the stack. Use copies of
3495 these so that the &'s don't force the real ones into
3497 YYSTYPE *yyvs1 = yyvs;
3498 short int *yyss1 = yyss;
3501 /* Each stack pointer address is followed by the size of the
3502 data in use in that stack, in bytes. This used to be a
3503 conditional around just the two extra args, but that might
3504 be undefined if yyoverflow is a macro. */
3505 yyoverflow (YY_("memory exhausted"),
3506 &yyss1, yysize * sizeof (*yyssp),
3507 &yyvs1, yysize * sizeof (*yyvsp),
3514 #else /* no yyoverflow */
3515 # ifndef YYSTACK_RELOCATE
3516 goto yyexhaustedlab;
3518 /* Extend the stack our own way. */
3519 if (YYMAXDEPTH <= yystacksize)
3520 goto yyexhaustedlab;
3522 if (YYMAXDEPTH < yystacksize)
3523 yystacksize = YYMAXDEPTH;
3526 short int *yyss1 = yyss;
3527 union yyalloc *yyptr =
3528 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3530 goto yyexhaustedlab;
3531 YYSTACK_RELOCATE (yyss);
3532 YYSTACK_RELOCATE (yyvs);
3534 # undef YYSTACK_RELOCATE
3536 YYSTACK_FREE (yyss1);
3539 #endif /* no yyoverflow */
3541 yyssp = yyss + yysize - 1;
3542 yyvsp = yyvs + yysize - 1;
3545 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3546 (unsigned long int) yystacksize));
3548 if (yyss + yystacksize - 1 <= yyssp)
3552 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3561 /* Do appropriate processing given the current state. */
3562 /* Read a look-ahead token if we need one and don't already have one. */
3565 /* First try to decide what to do without reference to look-ahead token. */
3567 yyn = yypact[yystate];
3568 if (yyn == YYPACT_NINF)
3571 /* Not known => get a look-ahead token if don't already have one. */
3573 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3574 if (yychar == YYEMPTY)
3576 YYDPRINTF ((stderr, "Reading a token: "));
3580 if (yychar <= YYEOF)
3582 yychar = yytoken = YYEOF;
3583 YYDPRINTF ((stderr, "Now at end of input.\n"));
3587 yytoken = YYTRANSLATE (yychar);
3588 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3591 /* If the proper action on seeing token YYTOKEN is to reduce or to
3592 detect an error, take that action. */
3594 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3599 if (yyn == 0 || yyn == YYTABLE_NINF)
3608 /* Shift the look-ahead token. */
3609 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3611 /* Discard the token being shifted unless it is eof. */
3612 if (yychar != YYEOF)
3618 /* Count tokens shifted since error; after three, turn off error
3627 /*-----------------------------------------------------------.
3628 | yydefault -- do the default action for the current state. |
3629 `-----------------------------------------------------------*/
3631 yyn = yydefact[yystate];
3637 /*-----------------------------.
3638 | yyreduce -- Do a reduction. |
3639 `-----------------------------*/
3641 /* yyn is the number of a rule to reduce with. */
3644 /* If YYLEN is nonzero, implement the default value of the action:
3647 Otherwise, the following line sets YYVAL to garbage.
3648 This behavior is undocumented and Bison
3649 users should not rely upon it. Assigning to YYVAL
3650 unconditionally makes the parser a bit smaller, and it avoids a
3651 GCC warning that YYVAL may be used uninitialized. */
3652 yyval = yyvsp[1-yylen];
3655 YY_REDUCE_PRINT (yyn);
3659 #line 1572 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3661 if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
3662 error("Value too large for type");
3663 (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3668 #line 1581 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3670 if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
3671 error("Value too large for type");
3672 (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3677 #line 1603 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3678 { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3682 #line 1603 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3683 { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3687 #line 1604 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3688 { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3692 #line 1604 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3693 { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3697 #line 1605 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3698 { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3702 #line 1605 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3703 { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3707 #line 1606 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3708 { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3712 #line 1606 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3713 { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
3717 #line 1607 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3718 { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
3722 #line 1607 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3723 { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
3727 #line 1611 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3728 { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
3732 #line 1611 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3733 { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
3737 #line 1612 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3738 { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
3742 #line 1612 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3743 { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
3747 #line 1613 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3748 { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
3752 #line 1613 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3753 { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
3757 #line 1614 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3758 { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
3762 #line 1614 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3763 { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
3767 #line 1615 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3768 { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
3772 #line 1615 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3773 { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
3777 #line 1616 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3778 { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
3782 #line 1616 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3783 { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
3787 #line 1617 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3788 { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
3792 #line 1617 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3793 { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
3797 #line 1618 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3798 { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
3802 #line 1619 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3803 { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
3807 #line 1650 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3809 (yyval.StrVal) = (yyvsp[-1].StrVal);
3814 #line 1653 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3821 #line 1658 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3822 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3826 #line 1659 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3827 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3831 #line 1660 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3832 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3836 #line 1661 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3837 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3841 #line 1662 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3842 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3846 #line 1663 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3847 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3851 #line 1664 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3852 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3856 #line 1665 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3857 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3861 #line 1669 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3862 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3866 #line 1670 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3867 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3871 #line 1671 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3872 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::CSRet; ;}
3876 #line 1672 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3877 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Fast; ;}
3881 #line 1673 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3882 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Cold; ;}
3886 #line 1674 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3887 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
3891 #line 1675 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3892 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
3896 #line 1676 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3898 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
3899 error("Calling conv too large");
3900 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3905 #line 1686 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3906 { (yyval.UIntVal) = 0; ;}
3910 #line 1687 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3912 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3913 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3914 error("Alignment must be a power of two");
3919 #line 1695 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3920 { (yyval.UIntVal) = 0; ;}
3924 #line 1696 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3926 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3927 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3928 error("Alignment must be a power of two");
3933 #line 1704 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3935 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
3936 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
3937 error("Invalid character in section name");
3938 (yyval.StrVal) = (yyvsp[0].StrVal);
3943 #line 1713 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3944 { (yyval.StrVal) = 0; ;}
3948 #line 1714 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3949 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
3953 #line 1721 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3958 #line 1722 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3963 #line 1726 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3965 CurGV->setSection((yyvsp[0].StrVal));
3966 free((yyvsp[0].StrVal));
3971 #line 1730 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3973 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
3974 error("Alignment must be a power of two");
3975 CurGV->setAlignment((yyvsp[0].UInt64Val));
3981 #line 1747 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3983 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3984 (yyval.TypeVal).S = Signless;
3989 #line 1755 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3991 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3992 (yyval.TypeVal).S = Signless;
3997 #line 1762 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
3999 if (!UpRefs.empty())
4000 error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).T)->getDescription());
4001 (yyval.TypeVal) = (yyvsp[0].TypeVal);
4006 #line 1776 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4008 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
4009 (yyval.TypeVal).S = (yyvsp[0].PrimType).S;
4014 #line 1780 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4016 (yyval.TypeVal).T = new PATypeHolder(OpaqueType::get());
4017 (yyval.TypeVal).S = Signless;
4022 #line 1784 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4023 { // Named types are also simple types...
4024 const Type* tmp = getType((yyvsp[0].ValIDVal));
4025 (yyval.TypeVal).T = new PATypeHolder(tmp);
4026 (yyval.TypeVal).S = Signless; // FIXME: what if its signed?
4031 #line 1789 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4032 { // Type UpReference
4033 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4034 error("Value out of range");
4035 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4036 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
4037 (yyval.TypeVal).T = new PATypeHolder(OT);
4038 (yyval.TypeVal).S = Signless;
4039 UR_OUT("New Upreference!\n");
4044 #line 1798 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4045 { // Function derived type?
4046 std::vector<const Type*> Params;
4047 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4048 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4049 Params.push_back(I->T->get());
4051 FunctionType::ParamAttrsList ParamAttrs;
4052 if (CurFun.LastCC == OldCallingConv::CSRet) {
4053 ParamAttrs.push_back(FunctionType::NoAttributeSet);
4054 ParamAttrs.push_back(FunctionType::StructRetAttribute);
4056 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4057 if (isVarArg) Params.pop_back();
4059 (yyval.TypeVal).T = new PATypeHolder(
4060 HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).T->get(),Params,isVarArg, ParamAttrs)));
4061 (yyval.TypeVal).S = (yyvsp[-3].TypeVal).S;
4062 delete (yyvsp[-3].TypeVal).T; // Delete the return type handle
4063 delete (yyvsp[-1].TypeList); // Delete the argument list
4068 #line 1818 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4069 { // Sized array type?
4070 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).T->get(),
4071 (unsigned)(yyvsp[-3].UInt64Val))));
4072 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4073 delete (yyvsp[-1].TypeVal).T;
4078 #line 1824 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4079 { // Packed array type?
4080 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).T->get();
4081 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4082 error("Unsigned result not equal to signed result");
4083 if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4084 error("Elements of a PackedType must be integer or floating point");
4085 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4086 error("PackedType length should be a power of 2");
4087 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy,
4088 (unsigned)(yyvsp[-3].UInt64Val))));
4089 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4090 delete (yyvsp[-1].TypeVal).T;
4095 #line 1837 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4096 { // Structure type?
4097 std::vector<const Type*> Elements;
4098 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4099 E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
4100 Elements.push_back(I->T->get());
4101 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
4102 (yyval.TypeVal).S = Signless;
4103 delete (yyvsp[-1].TypeList);
4108 #line 1846 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4109 { // Empty structure type?
4110 (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4111 (yyval.TypeVal).S = Signless;
4116 #line 1850 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4117 { // Packed Structure type?
4118 std::vector<const Type*> Elements;
4119 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4120 E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4121 Elements.push_back(I->T->get());
4124 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
4125 (yyval.TypeVal).S = Signless;
4126 delete (yyvsp[-2].TypeList);
4131 #line 1861 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4132 { // Empty packed structure type?
4133 (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4134 (yyval.TypeVal).S = Signless;
4139 #line 1865 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4141 if ((yyvsp[-1].TypeVal).T->get() == Type::LabelTy)
4142 error("Cannot form a pointer to a basic block");
4143 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).T->get())));
4144 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4145 delete (yyvsp[-1].TypeVal).T;
4150 #line 1878 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4152 (yyval.TypeList) = new std::list<PATypeInfo>();
4153 (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4158 #line 1882 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4160 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4165 #line 1890 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4168 VoidTI.T = new PATypeHolder(Type::VoidTy);
4169 VoidTI.S = Signless;
4170 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4175 #line 1896 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4177 (yyval.TypeList) = new std::list<PATypeInfo>();
4179 VoidTI.T = new PATypeHolder(Type::VoidTy);
4180 VoidTI.S = Signless;
4181 (yyval.TypeList)->push_back(VoidTI);
4186 #line 1903 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4188 (yyval.TypeList) = new std::list<PATypeInfo>();
4193 #line 1915 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4194 { // Nonempty unsized arr
4195 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).T->get());
4197 error("Cannot make array constant with type: '" +
4198 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4199 const Type *ETy = ATy->getElementType();
4200 int NumElements = ATy->getNumElements();
4202 // Verify that we have the correct size...
4203 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4204 error("Type mismatch: constant sized array initialized with " +
4205 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4206 itostr(NumElements) + "");
4208 // Verify all elements are correct type!
4209 std::vector<Constant*> Elems;
4210 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4211 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4212 const Type* ValTy = C->getType();
4214 error("Element #" + utostr(i) + " is not of type '" +
4215 ETy->getDescription() +"' as required!\nIt is of type '"+
4216 ValTy->getDescription() + "'");
4219 (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4220 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4221 delete (yyvsp[-3].TypeVal).T;
4222 delete (yyvsp[-1].ConstVector);
4227 #line 1945 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4229 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4231 error("Cannot make array constant with type: '" +
4232 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4233 int NumElements = ATy->getNumElements();
4234 if (NumElements != -1 && NumElements != 0)
4235 error("Type mismatch: constant sized array initialized with 0"
4236 " arguments, but has size of " + itostr(NumElements) +"");
4237 (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4238 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4239 delete (yyvsp[-2].TypeVal).T;
4244 #line 1958 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4246 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4248 error("Cannot make array constant with type: '" +
4249 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4250 int NumElements = ATy->getNumElements();
4251 const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4252 if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4253 error("String arrays require type i8, not '" + ETy->getDescription() +
4255 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4256 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4257 error("Can't build string constant of size " +
4258 itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4259 itostr(NumElements) + "");
4260 std::vector<Constant*> Vals;
4261 for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4262 Vals.push_back(ConstantInt::get(ETy, *C));
4263 free((yyvsp[0].StrVal));
4264 (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4265 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4266 delete (yyvsp[-2].TypeVal).T;
4271 #line 1981 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4272 { // Nonempty unsized arr
4273 const PackedType *PTy = dyn_cast<PackedType>((yyvsp[-3].TypeVal).T->get());
4275 error("Cannot make packed constant with type: '" +
4276 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4277 const Type *ETy = PTy->getElementType();
4278 int NumElements = PTy->getNumElements();
4279 // Verify that we have the correct size...
4280 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4281 error("Type mismatch: constant sized packed initialized with " +
4282 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4283 itostr(NumElements) + "");
4284 // Verify all elements are correct type!
4285 std::vector<Constant*> Elems;
4286 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4287 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4288 const Type* ValTy = C->getType();
4290 error("Element #" + utostr(i) + " is not of type '" +
4291 ETy->getDescription() +"' as required!\nIt is of type '"+
4292 ValTy->getDescription() + "'");
4295 (yyval.ConstVal).C = ConstantPacked::get(PTy, Elems);
4296 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4297 delete (yyvsp[-3].TypeVal).T;
4298 delete (yyvsp[-1].ConstVector);
4303 #line 2009 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4305 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).T->get());
4307 error("Cannot make struct constant with type: '" +
4308 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4309 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4310 error("Illegal number of initializers for structure type");
4312 // Check to ensure that constants are compatible with the type initializer!
4313 std::vector<Constant*> Fields;
4314 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4315 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4316 if (C->getType() != STy->getElementType(i))
4317 error("Expected type '" + STy->getElementType(i)->getDescription() +
4318 "' for element #" + utostr(i) + " of structure initializer");
4319 Fields.push_back(C);
4321 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4322 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4323 delete (yyvsp[-3].TypeVal).T;
4324 delete (yyvsp[-1].ConstVector);
4329 #line 2031 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4331 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).T->get());
4333 error("Cannot make struct constant with type: '" +
4334 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4335 if (STy->getNumContainedTypes() != 0)
4336 error("Illegal number of initializers for structure type");
4337 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4338 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4339 delete (yyvsp[-2].TypeVal).T;
4344 #line 2042 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4346 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).T->get());
4348 error("Cannot make packed struct constant with type: '" +
4349 (yyvsp[-5].TypeVal).T->get()->getDescription() + "'");
4350 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4351 error("Illegal number of initializers for packed structure type");
4353 // Check to ensure that constants are compatible with the type initializer!
4354 std::vector<Constant*> Fields;
4355 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4356 Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4357 if (C->getType() != STy->getElementType(i))
4358 error("Expected type '" + STy->getElementType(i)->getDescription() +
4359 "' for element #" + utostr(i) + " of packed struct initializer");
4360 Fields.push_back(C);
4362 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4363 (yyval.ConstVal).S = (yyvsp[-5].TypeVal).S;
4364 delete (yyvsp[-5].TypeVal).T;
4365 delete (yyvsp[-2].ConstVector);
4370 #line 2064 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4372 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).T->get());
4374 error("Cannot make packed struct constant with type: '" +
4375 (yyvsp[-4].TypeVal).T->get()->getDescription() + "'");
4376 if (STy->getNumContainedTypes() != 0)
4377 error("Illegal number of initializers for packed structure type");
4378 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4379 (yyval.ConstVal).S = (yyvsp[-4].TypeVal).S;
4380 delete (yyvsp[-4].TypeVal).T;
4385 #line 2075 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4387 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4389 error("Cannot make null pointer constant with type: '" +
4390 (yyvsp[-1].TypeVal).T->get()->getDescription() + "'");
4391 (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4392 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4393 delete (yyvsp[-1].TypeVal).T;
4398 #line 2084 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4400 (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).T->get());
4401 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4402 delete (yyvsp[-1].TypeVal).T;
4407 #line 2089 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4409 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4411 error("Global const reference must be a pointer type, not" +
4412 (yyvsp[-1].TypeVal).T->get()->getDescription());
4414 // ConstExprs can exist in the body of a function, thus creating
4415 // GlobalValues whenever they refer to a variable. Because we are in
4416 // the context of a function, getExistingValue will search the functions
4417 // symbol table instead of the module symbol table for the global symbol,
4418 // which throws things all off. To get around this, we just tell
4419 // getExistingValue that we are at global scope here.
4421 Function *SavedCurFn = CurFun.CurrentFunction;
4422 CurFun.CurrentFunction = 0;
4423 Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4424 CurFun.CurrentFunction = SavedCurFn;
4426 // If this is an initializer for a constant pointer, which is referencing a
4427 // (currently) undefined variable, create a stub now that shall be replaced
4428 // in the future with the right type of variable.
4431 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4432 const PointerType *PT = cast<PointerType>(Ty);
4434 // First check to see if the forward references value is already created!
4435 PerModuleInfo::GlobalRefsType::iterator I =
4436 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4438 if (I != CurModule.GlobalRefs.end()) {
4439 V = I->second; // Placeholder already exists, use it...
4440 (yyvsp[0].ValIDVal).destroy();
4443 if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4445 // Create the forward referenced global.
4447 if (const FunctionType *FTy =
4448 dyn_cast<FunctionType>(PT->getElementType())) {
4449 GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4450 CurModule.CurrentModule);
4452 GV = new GlobalVariable(PT->getElementType(), false,
4453 GlobalValue::ExternalLinkage, 0,
4454 Name, CurModule.CurrentModule);
4457 // Keep track of the fact that we have a forward ref to recycle it
4458 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4462 (yyval.ConstVal).C = cast<GlobalValue>(V);
4463 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4464 delete (yyvsp[-1].TypeVal).T; // Free the type handle
4469 #line 2147 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4471 if ((yyvsp[-1].TypeVal).T->get() != (yyvsp[0].ConstVal).C->getType())
4472 error("Mismatched types for constant expression");
4473 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4474 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4475 delete (yyvsp[-1].TypeVal).T;
4480 #line 2154 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4482 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
4483 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4484 error("Cannot create a null initialized value of this type");
4485 (yyval.ConstVal).C = Constant::getNullValue(Ty);
4486 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4487 delete (yyvsp[-1].TypeVal).T;
4492 #line 2162 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4493 { // integral constants
4494 const Type *Ty = (yyvsp[-1].PrimType).T;
4495 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4496 error("Constant value doesn't fit in type");
4497 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4498 (yyval.ConstVal).S = Signed;
4503 #line 2169 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4504 { // integral constants
4505 const Type *Ty = (yyvsp[-1].PrimType).T;
4506 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4507 error("Constant value doesn't fit in type");
4508 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4509 (yyval.ConstVal).S = Unsigned;
4514 #line 2176 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4515 { // Boolean constants
4516 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4517 (yyval.ConstVal).S = Unsigned;
4522 #line 2180 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4523 { // Boolean constants
4524 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4525 (yyval.ConstVal).S = Unsigned;
4530 #line 2184 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4531 { // Float & Double constants
4532 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4533 error("Floating point constant invalid for type");
4534 (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4535 (yyval.ConstVal).S = Signless;
4540 #line 2193 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4542 const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4543 const Type* DstTy = (yyvsp[-1].TypeVal).T->get();
4544 Signedness SrcSign = (yyvsp[-3].ConstVal).S;
4545 Signedness DstSign = (yyvsp[-1].TypeVal).S;
4546 if (!SrcTy->isFirstClassType())
4547 error("cast constant expression from a non-primitive type: '" +
4548 SrcTy->getDescription() + "'");
4549 if (!DstTy->isFirstClassType())
4550 error("cast constant expression to a non-primitive type: '" +
4551 DstTy->getDescription() + "'");
4552 (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4553 (yyval.ConstVal).S = DstSign;
4554 delete (yyvsp[-1].TypeVal).T;
4559 #line 2208 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4561 const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4562 if (!isa<PointerType>(Ty))
4563 error("GetElementPtr requires a pointer operand");
4565 std::vector<Value*> VIndices;
4566 std::vector<Constant*> CIndices;
4567 upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4569 delete (yyvsp[-1].ValueList);
4570 (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, CIndices);
4571 (yyval.ConstVal).S = Signless;
4576 #line 2221 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4578 if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4579 cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4580 error("Select condition must be bool type");
4581 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4582 error("Select operand types must match");
4583 (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4584 (yyval.ConstVal).S = Unsigned;
4589 #line 2230 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4591 const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4592 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4593 error("Binary operator types must match");
4594 // First, make sure we're dealing with the right opcode by upgrading from
4595 // obsolete versions.
4596 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4598 // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4599 // To retain backward compatibility with these early compilers, we emit a
4600 // cast to the appropriate integer type automatically if we are in the
4601 // broken case. See PR424 for more information.
4602 if (!isa<PointerType>(Ty)) {
4603 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4605 const Type *IntPtrTy = 0;
4606 switch (CurModule.CurrentModule->getPointerSize()) {
4607 case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4608 case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4609 default: error("invalid pointer binary constant expr");
4611 (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4612 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4613 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4614 (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4616 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4621 #line 2258 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4623 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4624 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4625 error("Logical operator types must match");
4626 if (!Ty->isInteger()) {
4627 if (!isa<PackedType>(Ty) ||
4628 !cast<PackedType>(Ty)->getElementType()->isInteger())
4629 error("Logical operator requires integer operands");
4631 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4632 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4633 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4638 #line 2271 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4640 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4641 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4642 error("setcc operand types must match");
4643 unsigned short pred;
4644 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4645 (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4646 (yyval.ConstVal).S = Unsigned;
4651 #line 2280 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4653 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4654 error("icmp operand types must match");
4655 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4656 (yyval.ConstVal).S = Unsigned;
4661 #line 2286 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4663 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4664 error("fcmp operand types must match");
4665 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4666 (yyval.ConstVal).S = Unsigned;
4671 #line 2292 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4673 if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4674 cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4675 error("Shift count for shift constant must be unsigned byte");
4676 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4677 if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4678 error("Shift constant expression requires integer operand");
4679 Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4680 (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4681 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4686 #line 2303 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4688 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4689 error("Invalid extractelement operands");
4690 (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4691 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4696 #line 2309 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4698 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4699 error("Invalid insertelement operands");
4700 (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4701 (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4706 #line 2315 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4708 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4709 error("Invalid shufflevector operands");
4710 (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4711 (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4716 #line 2326 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4717 { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
4721 #line 2327 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4723 (yyval.ConstVector) = new std::vector<ConstInfo>();
4724 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4729 #line 2336 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4730 { (yyval.BoolVal) = false; ;}
4734 #line 2337 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4735 { (yyval.BoolVal) = true; ;}
4739 #line 2349 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4741 (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
4742 CurModule.ModuleDone();
4747 #line 2358 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4748 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
4752 #line 2359 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4753 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4757 #line 2360 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4758 { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
4762 #line 2361 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4763 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4767 #line 2362 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4769 (yyval.ModuleVal) = CurModule.CurrentModule;
4770 // Emit an error if there are any unresolved types left.
4771 if (!CurModule.LateResolveTypes.empty()) {
4772 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
4773 if (DID.Type == ValID::NameVal) {
4774 error("Reference to an undefined type: '"+DID.getName() + "'");
4776 error("Reference to an undefined type: #" + itostr(DID.Num));
4783 #line 2378 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4785 // Eagerly resolve types. This is not an optimization, this is a
4786 // requirement that is due to the fact that we could have this:
4788 // %list = type { %list * }
4789 // %list = type { %list * } ; repeated type decl
4791 // If types are not resolved eagerly, then the two types will not be
4792 // determined to be the same type!
4794 const Type* Ty = (yyvsp[0].TypeVal).T->get();
4795 ResolveTypeTo((yyvsp[-2].StrVal), Ty);
4797 if (!setTypeName(Ty, (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4798 // If this is a named type that is not a redefinition, add it to the slot
4800 CurModule.Types.push_back(Ty);
4802 delete (yyvsp[0].TypeVal).T;
4807 #line 2398 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4808 { // Function prototypes can be in const pool
4813 #line 2400 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4814 { // Asm blocks can be in the const pool
4819 #line 2402 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4821 if ((yyvsp[0].ConstVal).C == 0)
4822 error("Global value initializer is not a constant");
4823 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C);
4828 #line 2406 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4835 #line 2409 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4837 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4838 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4839 delete (yyvsp[0].TypeVal).T;
4844 #line 2413 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4851 #line 2416 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4853 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4854 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4855 delete (yyvsp[0].TypeVal).T;
4860 #line 2420 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4867 #line 2423 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4869 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4871 ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4872 delete (yyvsp[0].TypeVal).T;
4877 #line 2428 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4884 #line 2431 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4890 #line 2433 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4896 #line 2435 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4902 #line 2440 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4904 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
4905 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4906 std::string NewAsm((yyvsp[0].StrVal), EndStr);
4907 free((yyvsp[0].StrVal));
4909 if (AsmSoFar.empty())
4910 CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
4912 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
4917 #line 2454 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4918 { (yyval.Endianness) = Module::BigEndian; ;}
4922 #line 2455 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4923 { (yyval.Endianness) = Module::LittleEndian; ;}
4927 #line 2459 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4929 CurModule.setEndianness((yyvsp[0].Endianness));
4934 #line 2462 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4936 if ((yyvsp[0].UInt64Val) == 32)
4937 CurModule.setPointerSize(Module::Pointer32);
4938 else if ((yyvsp[0].UInt64Val) == 64)
4939 CurModule.setPointerSize(Module::Pointer64);
4941 error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
4946 #line 2470 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4948 CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
4949 free((yyvsp[0].StrVal));
4954 #line 2474 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4956 CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
4957 free((yyvsp[0].StrVal));
4962 #line 2485 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4964 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4965 free((yyvsp[0].StrVal));
4970 #line 2489 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4972 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4973 free((yyvsp[0].StrVal));
4978 #line 2493 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4983 #line 2506 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4984 { (yyval.StrVal) = 0; ;}
4988 #line 2510 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4990 if ((yyvsp[-1].TypeVal).T->get() == Type::VoidTy)
4991 error("void typed arguments are invalid");
4992 (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
4997 #line 2518 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
4999 (yyval.ArgList) = (yyvsp[-2].ArgList);
5000 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5001 delete (yyvsp[0].ArgVal);
5006 #line 2523 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5008 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5009 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5010 delete (yyvsp[0].ArgVal);
5015 #line 2531 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5016 { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5020 #line 2532 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5022 (yyval.ArgList) = (yyvsp[-2].ArgList);
5024 VoidTI.T = new PATypeHolder(Type::VoidTy);
5025 VoidTI.S = Signless;
5026 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5031 #line 2539 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5033 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5035 VoidTI.T = new PATypeHolder(Type::VoidTy);
5036 VoidTI.S = Signless;
5037 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5042 #line 2546 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5043 { (yyval.ArgList) = 0; ;}
5047 #line 2550 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5049 UnEscapeLexed((yyvsp[-5].StrVal));
5050 std::string FunctionName((yyvsp[-5].StrVal));
5051 free((yyvsp[-5].StrVal)); // Free strdup'd memory!
5053 const Type* RetTy = (yyvsp[-6].TypeVal).T->get();
5055 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5056 error("LLVM functions cannot return aggregate types");
5058 std::vector<const Type*> ParamTyList;
5060 // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5061 // i8*. We check here for those names and override the parameter list
5062 // types to ensure the prototype is correct.
5063 if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5064 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5065 } else if (FunctionName == "llvm.va_copy") {
5066 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5067 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5068 } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
5069 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5070 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5071 const Type *Ty = I->first.T->get();
5072 ParamTyList.push_back(Ty);
5076 bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy;
5078 ParamTyList.pop_back();
5080 // Convert the CSRet calling convention into the corresponding parameter
5082 FunctionType::ParamAttrsList ParamAttrs;
5083 if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5084 ParamAttrs.push_back(FunctionType::NoAttributeSet); // result
5085 ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5088 const FunctionType *FT = FunctionType::get(RetTy, ParamTyList, isVarArg,
5090 const PointerType *PFT = PointerType::get(FT);
5091 delete (yyvsp[-6].TypeVal).T;
5094 if (!FunctionName.empty()) {
5095 ID = ValID::create((char*)FunctionName.c_str());
5097 ID = ValID::create((int)CurModule.Values[PFT].size());
5101 // See if this function was forward referenced. If so, recycle the object.
5102 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5103 // Move the function to the end of the list, from whereever it was
5104 // previously inserted.
5105 Fn = cast<Function>(FWRef);
5106 CurModule.CurrentModule->getFunctionList().remove(Fn);
5107 CurModule.CurrentModule->getFunctionList().push_back(Fn);
5108 } else if (!FunctionName.empty() && // Merge with an earlier prototype?
5109 (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
5110 if (Fn->getFunctionType() != FT ) {
5111 // The existing function doesn't have the same type. Previously this was
5112 // permitted because the symbol tables had "type planes" and names were
5113 // distinct within a type plane. After PR411 was fixed, this is no
5114 // longer the case. To resolve this we must rename this function.
5115 // However, renaming it can cause problems if its linkage is external
5116 // because it could cause a link failure. We warn about this.
5117 std::string NewName = makeNameUnique(FunctionName);
5118 warning("Renaming function '" + FunctionName + "' as '" + NewName +
5119 "' may cause linkage errors");
5121 Fn = new Function(FT, GlobalValue::ExternalLinkage, NewName,
5122 CurModule.CurrentModule);
5123 InsertValue(Fn, CurModule.Values);
5124 RenameMapKey Key = std::make_pair(FunctionName,PFT);
5125 CurModule.RenameMap[Key] = NewName;
5127 // The types are the same. Either the existing or the current function
5128 // needs to be a forward declaration. If not, they're attempting to
5129 // redefine a function.
5130 if (!CurFun.isDeclare && !Fn->isDeclaration())
5131 error("Redefinition of function '" + FunctionName + "'");
5133 // Make sure to strip off any argument names so we can't get conflicts.
5134 if (Fn->isDeclaration())
5135 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
5139 } else { // Not already defined?
5140 Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
5141 CurModule.CurrentModule);
5143 InsertValue(Fn, CurModule.Values);
5146 CurFun.FunctionStart(Fn);
5148 if (CurFun.isDeclare) {
5149 // If we have declaration, always overwrite linkage. This will allow us
5150 // to correctly handle cases, when pointer to function is passed as
5151 // argument to another function.
5152 Fn->setLinkage(CurFun.Linkage);
5154 Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5155 Fn->setAlignment((yyvsp[0].UIntVal));
5156 if ((yyvsp[-1].StrVal)) {
5157 Fn->setSection((yyvsp[-1].StrVal));
5158 free((yyvsp[-1].StrVal));
5161 // Add all of the arguments we parsed to the function...
5162 if ((yyvsp[-3].ArgList)) { // Is null if empty...
5163 if (isVarArg) { // Nuke the last entry
5164 assert((yyvsp[-3].ArgList)->back().first.T->get() == Type::VoidTy &&
5165 (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5166 delete (yyvsp[-3].ArgList)->back().first.T;
5167 (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
5169 Function::arg_iterator ArgIt = Fn->arg_begin();
5170 Function::arg_iterator ArgEnd = Fn->arg_end();
5171 std::vector<std::pair<PATypeInfo,char*> >::iterator I = (yyvsp[-3].ArgList)->begin();
5172 std::vector<std::pair<PATypeInfo,char*> >::iterator E = (yyvsp[-3].ArgList)->end();
5173 for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) {
5174 delete I->first.T; // Delete the typeholder...
5175 setValueName(ArgIt, I->second); // Insert arg into symtab...
5178 delete (yyvsp[-3].ArgList); // We're now done with the argument list
5184 #line 2690 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5186 (yyval.FunctionVal) = CurFun.CurrentFunction;
5188 // Make sure that we keep track of the linkage type even if there was a
5189 // previous "declare".
5190 (yyval.FunctionVal)->setLinkage((yyvsp[-2].Linkage));
5195 #line 2704 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5197 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5202 #line 2710 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5203 { CurFun.Linkage = GlobalValue::DLLImportLinkage; ;}
5207 #line 2711 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5208 { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; ;}
5212 #line 2715 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5213 { CurFun.isDeclare = true; ;}
5217 #line 2715 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5219 (yyval.FunctionVal) = CurFun.CurrentFunction;
5220 CurFun.FunctionDone();
5226 #line 2727 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5227 { (yyval.BoolVal) = false; ;}
5231 #line 2728 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5232 { (yyval.BoolVal) = true; ;}
5236 #line 2733 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5237 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5241 #line 2734 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5242 { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5246 #line 2735 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5247 { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5251 #line 2736 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5252 { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); ;}
5256 #line 2737 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5257 { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); ;}
5261 #line 2738 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5262 { (yyval.ValIDVal) = ValID::createNull(); ;}
5266 #line 2739 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5267 { (yyval.ValIDVal) = ValID::createUndef(); ;}
5271 #line 2740 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5272 { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5276 #line 2741 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5277 { // Nonempty unsized packed vector
5278 const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5279 int NumElements = (yyvsp[-1].ConstVector)->size();
5280 PackedType* pt = PackedType::get(ETy, NumElements);
5281 PATypeHolder* PTy = new PATypeHolder(
5282 HandleUpRefs(PackedType::get(ETy, NumElements)));
5284 // Verify all elements are correct type!
5285 std::vector<Constant*> Elems;
5286 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5287 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5288 const Type *CTy = C->getType();
5290 error("Element #" + utostr(i) + " is not of type '" +
5291 ETy->getDescription() +"' as required!\nIt is of type '" +
5292 CTy->getDescription() + "'");
5295 (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, Elems));
5296 delete PTy; delete (yyvsp[-1].ConstVector);
5301 #line 2762 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5303 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5308 #line 2765 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5310 char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5311 std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5312 End = UnEscapeLexed((yyvsp[0].StrVal), true);
5313 std::string Constraints = std::string((yyvsp[0].StrVal), End);
5314 (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5315 free((yyvsp[-2].StrVal));
5316 free((yyvsp[0].StrVal));
5321 #line 2780 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5322 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); ;}
5326 #line 2781 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5327 { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); ;}
5331 #line 2794 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5333 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
5334 (yyval.ValueVal).S = (yyvsp[-1].TypeVal).S;
5335 (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5336 delete (yyvsp[-1].TypeVal).T;
5341 #line 2803 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5343 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5348 #line 2806 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5349 { // Do not allow functions with 0 basic blocks
5350 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5355 #line 2815 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5357 setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
5358 InsertValue((yyvsp[0].TermInstVal));
5359 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
5360 InsertValue((yyvsp[-2].BasicBlockVal));
5361 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5366 #line 2825 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5368 if ((yyvsp[0].InstVal).I)
5369 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5370 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5375 #line 2830 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5377 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
5378 // Make sure to move the basic block to the correct location in the
5379 // function, instead of leaving it inserted wherever it was first
5381 Function::BasicBlockListType &BBL =
5382 CurFun.CurrentFunction->getBasicBlockList();
5383 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5388 #line 2839 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5390 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5391 // Make sure to move the basic block to the correct location in the
5392 // function, instead of leaving it inserted wherever it was first
5394 Function::BasicBlockListType &BBL =
5395 CurFun.CurrentFunction->getBasicBlockList();
5396 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5401 #line 2853 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5402 { // Return with a result...
5403 (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal).V);
5408 #line 2856 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5409 { // Return with no result...
5410 (yyval.TermInstVal) = new ReturnInst();
5415 #line 2859 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5416 { // Unconditional Branch...
5417 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5418 (yyval.TermInstVal) = new BranchInst(tmpBB);
5423 #line 2863 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5425 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5426 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5427 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5428 (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5433 #line 2869 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5435 Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5436 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5437 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5438 (yyval.TermInstVal) = S;
5439 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5440 E = (yyvsp[-1].JumpTable)->end();
5441 for (; I != E; ++I) {
5442 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5443 S->addCase(CI, I->second);
5445 error("Switch case is constant, but not a simple integer");
5447 delete (yyvsp[-1].JumpTable);
5452 #line 2884 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5454 Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5455 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5456 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5457 (yyval.TermInstVal) = S;
5462 #line 2891 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5464 const PointerType *PFTy;
5465 const FunctionType *Ty;
5467 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).T->get())) ||
5468 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5469 // Pull out the types of all of the arguments...
5470 std::vector<const Type*> ParamTypes;
5471 if ((yyvsp[-7].ValueList)) {
5472 for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5474 ParamTypes.push_back((*I).V->getType());
5476 FunctionType::ParamAttrsList ParamAttrs;
5477 if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5478 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5479 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5481 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5482 if (isVarArg) ParamTypes.pop_back();
5483 Ty = FunctionType::get((yyvsp[-10].TypeVal).T->get(), ParamTypes, isVarArg, ParamAttrs);
5484 PFTy = PointerType::get(Ty);
5486 Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling...
5487 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5488 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5490 // Create the call node...
5491 if (!(yyvsp[-7].ValueList)) { // Has no arguments?
5492 (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, std::vector<Value*>());
5493 } else { // Has arguments?
5494 // Loop through FunctionType's arguments and ensure they are specified
5497 FunctionType::param_iterator I = Ty->param_begin();
5498 FunctionType::param_iterator E = Ty->param_end();
5499 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5501 std::vector<Value*> Args;
5502 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5503 if ((*ArgI).V->getType() != *I)
5504 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5505 (*I)->getDescription() + "'");
5506 Args.push_back((*ArgI).V);
5509 if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5510 error("Invalid number of parameters detected");
5512 (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, Args);
5514 cast<InvokeInst>((yyval.TermInstVal))->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5515 delete (yyvsp[-10].TypeVal).T;
5516 delete (yyvsp[-7].ValueList);
5521 #line 2946 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5523 (yyval.TermInstVal) = new UnwindInst();
5528 #line 2949 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5530 (yyval.TermInstVal) = new UnreachableInst();
5535 #line 2955 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5537 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5538 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5541 error("May only switch on a constant pool value");
5543 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5544 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5549 #line 2965 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5551 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5552 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5555 error("May only switch on a constant pool value");
5557 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5558 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5563 #line 2978 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5566 if ((yyvsp[-1].StrVal))
5567 if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5568 if (BCI->getSrcTy() == BCI->getDestTy() &&
5569 BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5570 // This is a useless bit cast causing a name redefinition. It is
5571 // a bit cast from a type to the same type of an operand with the
5572 // same name as the name we would give this instruction. Since this
5573 // instruction results in no code generation, it is safe to omit
5574 // the instruction. This situation can occur because of collapsed
5575 // type planes. For example:
5576 // %X = add int %Y, %Z
5577 // %X = cast int %Y to uint
5578 // After upgrade, this looks like:
5579 // %X = add i32 %Y, %Z
5580 // %X = bitcast i32 to i32
5581 // The bitcast is clearly useless so we omit it.
5584 (yyval.InstVal).I = 0;
5585 (yyval.InstVal).S = Signless;
5587 setValueName((yyvsp[0].InstVal).I, (yyvsp[-1].StrVal));
5588 InsertValue((yyvsp[0].InstVal).I);
5589 (yyval.InstVal) = (yyvsp[0].InstVal);
5595 #line 3007 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5596 { // Used for PHI nodes
5597 (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5598 (yyval.PHIList).S = (yyvsp[-5].TypeVal).S;
5599 Value* tmpVal = getVal((yyvsp[-5].TypeVal).T->get(), (yyvsp[-3].ValIDVal));
5600 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5601 (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5602 delete (yyvsp[-5].TypeVal).T;
5607 #line 3015 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5609 (yyval.PHIList) = (yyvsp[-6].PHIList);
5610 Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
5611 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5612 (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5617 #line 3023 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5618 { // Used for call statements, and memory insts...
5619 (yyval.ValueList) = new std::vector<ValueInfo>();
5620 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
5625 #line 3027 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5627 (yyval.ValueList) = (yyvsp[-2].ValueList);
5628 (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
5633 #line 3035 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5634 { (yyval.ValueList) = 0; ;}
5638 #line 3039 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5640 (yyval.BoolVal) = true;
5645 #line 3042 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5647 (yyval.BoolVal) = false;
5652 #line 3048 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5654 const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5655 if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<PackedType>(Ty))
5656 error("Arithmetic operator requires integer, FP, or packed operands");
5657 if (isa<PackedType>(Ty) &&
5658 ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
5659 error("Remainder not supported on packed types");
5660 // Upgrade the opcode from obsolete versions before we do anything with it.
5661 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5662 Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5663 Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
5664 (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
5665 if ((yyval.InstVal).I == 0)
5666 error("binary operator returned null");
5667 (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5668 delete (yyvsp[-3].TypeVal).T;
5673 #line 3065 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5675 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5676 if (!Ty->isInteger()) {
5677 if (!isa<PackedType>(Ty) ||
5678 !cast<PackedType>(Ty)->getElementType()->isInteger())
5679 error("Logical operator requires integral operands");
5681 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5682 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5683 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5684 (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
5685 if ((yyval.InstVal).I == 0)
5686 error("binary operator returned null");
5687 (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5688 delete (yyvsp[-3].TypeVal).T;
5693 #line 3081 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5695 const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5696 if(isa<PackedType>(Ty))
5697 error("PackedTypes currently not supported in setcc instructions");
5698 unsigned short pred;
5699 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
5700 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5701 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5702 (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
5703 if ((yyval.InstVal).I == 0)
5704 error("binary operator returned null");
5705 (yyval.InstVal).S = Unsigned;
5706 delete (yyvsp[-3].TypeVal).T;
5711 #line 3095 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5713 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5714 if (isa<PackedType>(Ty))
5715 error("PackedTypes currently not supported in icmp instructions");
5716 else if (!Ty->isInteger() && !isa<PointerType>(Ty))
5717 error("icmp requires integer or pointer typed operands");
5718 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5719 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5720 (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
5721 (yyval.InstVal).S = Unsigned;
5722 delete (yyvsp[-3].TypeVal).T;
5727 #line 3107 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5729 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5730 if (isa<PackedType>(Ty))
5731 error("PackedTypes currently not supported in fcmp instructions");
5732 else if (!Ty->isFloatingPoint())
5733 error("fcmp instruction requires floating point operands");
5734 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5735 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5736 (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
5737 (yyval.InstVal).S = Unsigned;
5738 delete (yyvsp[-3].TypeVal).T;
5743 #line 3119 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5745 warning("Use of obsolete 'not' instruction: Replacing with 'xor");
5746 const Type *Ty = (yyvsp[0].ValueVal).V->getType();
5747 Value *Ones = ConstantInt::getAllOnesValue(Ty);
5749 error("Expected integral type for not instruction");
5750 (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
5751 if ((yyval.InstVal).I == 0)
5752 error("Could not create a xor instruction");
5753 (yyval.InstVal).S = (yyvsp[0].ValueVal).S
5758 #line 3130 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5760 if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
5761 cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
5762 error("Shift amount must be int8");
5763 const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
5764 if (!Ty->isInteger())
5765 error("Shift constant expression requires integer operand");
5766 Value* ShiftAmt = 0;
5767 if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
5768 if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
5769 ShiftAmt = ConstantExpr::getZExt(C, Ty);
5771 ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
5773 ShiftAmt = (yyvsp[0].ValueVal).V;
5774 (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
5775 (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5780 #line 3148 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5782 const Type *DstTy = (yyvsp[0].TypeVal).T->get();
5783 if (!DstTy->isFirstClassType())
5784 error("cast instruction to a non-primitive type: '" +
5785 DstTy->getDescription() + "'");
5786 (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
5787 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5788 delete (yyvsp[0].TypeVal).T;
5793 #line 3157 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5795 if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
5796 cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
5797 error("select condition must be bool");
5798 if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
5799 error("select value types should match");
5800 (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5801 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5806 #line 3166 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5808 const Type *Ty = (yyvsp[0].TypeVal).T->get();
5810 (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
5811 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5812 delete (yyvsp[0].TypeVal).T;
5817 #line 3173 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5819 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5820 const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5821 ObsoleteVarArgs = true;
5822 Function* NF = cast<Function>(CurModule.CurrentModule->
5823 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5826 //foo = alloca 1 of t
5830 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
5831 CurBB->getInstList().push_back(foo);
5832 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5833 CurBB->getInstList().push_back(bar);
5834 CurBB->getInstList().push_back(new StoreInst(bar, foo));
5835 (yyval.InstVal).I = new VAArgInst(foo, DstTy);
5836 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5837 delete (yyvsp[0].TypeVal).T;
5842 #line 3194 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5844 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5845 const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5846 ObsoleteVarArgs = true;
5847 Function* NF = cast<Function>(CurModule.CurrentModule->
5848 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5850 //b = vanext a, t ->
5851 //foo = alloca 1 of t
5854 //tmp = vaarg foo, t
5856 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
5857 CurBB->getInstList().push_back(foo);
5858 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5859 CurBB->getInstList().push_back(bar);
5860 CurBB->getInstList().push_back(new StoreInst(bar, foo));
5861 Instruction* tmp = new VAArgInst(foo, DstTy);
5862 CurBB->getInstList().push_back(tmp);
5863 (yyval.InstVal).I = new LoadInst(foo);
5864 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5865 delete (yyvsp[0].TypeVal).T;
5870 #line 3218 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5872 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5873 error("Invalid extractelement operands");
5874 (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5875 (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5880 #line 3224 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5882 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5883 error("Invalid insertelement operands");
5884 (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5885 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5890 #line 3230 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5892 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5893 error("Invalid shufflevector operands");
5894 (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5895 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5900 #line 3236 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5902 const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
5903 if (!Ty->isFirstClassType())
5904 error("PHI node operands must be of first class type");
5905 PHINode *PHI = new PHINode(Ty);
5906 PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
5907 while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
5908 if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
5909 error("All elements of a PHI node must be of the same type");
5910 PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
5911 (yyvsp[0].PHIList).P->pop_front();
5913 (yyval.InstVal).I = PHI;
5914 (yyval.InstVal).S = (yyvsp[0].PHIList).S;
5915 delete (yyvsp[0].PHIList).P; // Free the list...
5920 #line 3252 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
5923 // Handle the short call syntax
5924 const PointerType *PFTy;
5925 const FunctionType *FTy;
5926 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).T->get())) ||
5927 !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5928 // Pull out the types of all of the arguments...
5929 std::vector<const Type*> ParamTypes;
5930 if ((yyvsp[-1].ValueList)) {
5931 for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
5933 ParamTypes.push_back((*I).V->getType());
5936 FunctionType::ParamAttrsList ParamAttrs;
5937 if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
5938 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5939 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5941 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5942 if (isVarArg) ParamTypes.pop_back();
5944 const Type *RetTy = (yyvsp[-4].TypeVal).T->get();
5945 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5946 error("Functions cannot return aggregate types");
5948 FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
5949 PFTy = PointerType::get(FTy);
5952 // First upgrade any intrinsic calls.
5953 std::vector<Value*> Args;
5954 if ((yyvsp[-1].ValueList))
5955 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
5956 Args.push_back((*(yyvsp[-1].ValueList))[i].V);
5957 Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args);
5959 // If we got an upgraded intrinsic
5961 (yyval.InstVal).I = Inst;
5962 (yyval.InstVal).S = Signless;
5964 // Get the function we're calling
5965 Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
5967 // Check the argument values match
5968 if (!(yyvsp[-1].ValueList)) { // Has no arguments?
5969 // Make sure no arguments is a good thing!
5970 if (FTy->getNumParams() != 0)
5971 error("No arguments passed to a function that expects arguments");
5972 } else { // Has arguments?
5973 // Loop through FunctionType's arguments and ensure they are specified
5976 FunctionType::param_iterator I = FTy->param_begin();
5977 FunctionType::param_iterator E = FTy->param_end();
5978 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
5980 for (; ArgI != ArgE && I != E; ++ArgI, ++I)
5981 if ((*ArgI).V->getType() != *I)
5982 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5983 (*I)->getDescription() + "'");
5985 if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
5986 error("Invalid number of parameters detected");
5989 // Create the call instruction
5990 CallInst *CI = new CallInst(V, Args);
5991 CI->setTailCall((yyvsp[-6].BoolVal));
5992 CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
5993 (yyval.InstVal).I = CI;
5994 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
5996 delete (yyvsp[-4].TypeVal).T;
5997 delete (yyvsp[-1].ValueList);
6002 #line 3330 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6004 (yyval.InstVal) = (yyvsp[0].InstVal);
6009 #line 3338 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6010 { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
6014 #line 3339 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6015 { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6019 #line 3343 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6020 { (yyval.BoolVal) = true; ;}
6024 #line 3344 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6025 { (yyval.BoolVal) = false; ;}
6029 #line 3348 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6031 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6032 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6033 (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6034 delete (yyvsp[-1].TypeVal).T;
6039 #line 3354 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6041 const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6042 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6043 (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6044 delete (yyvsp[-4].TypeVal).T;
6049 #line 3360 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6051 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6052 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6053 (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6054 delete (yyvsp[-1].TypeVal).T;
6059 #line 3366 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6061 const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6062 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6063 (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6064 delete (yyvsp[-4].TypeVal).T;
6069 #line 3372 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6071 const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6072 if (!isa<PointerType>(PTy))
6073 error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6074 (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6075 (yyval.InstVal).S = Signless;
6080 #line 3379 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6082 const Type* Ty = (yyvsp[-1].TypeVal).T->get();
6083 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6084 if (!isa<PointerType>(Ty))
6085 error("Can't load from nonpointer type: " + Ty->getDescription());
6086 if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6087 error("Can't load from pointer of non-first-class type: " +
6088 Ty->getDescription());
6089 Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6090 (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6091 delete (yyvsp[-1].TypeVal).T;
6096 #line 3391 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6098 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
6100 error("Can't store to a nonpointer type: " +
6101 (yyvsp[-1].TypeVal).T->get()->getDescription());
6102 const Type *ElTy = PTy->getElementType();
6103 if (ElTy != (yyvsp[-3].ValueVal).V->getType())
6104 error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6105 "' into space of type '" + ElTy->getDescription() + "'");
6106 Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6107 (yyval.InstVal).I = new StoreInst((yyvsp[-3].ValueVal).V, tmpVal, (yyvsp[-5].BoolVal));
6108 (yyval.InstVal).S = Signless;
6109 delete (yyvsp[-1].TypeVal).T;
6114 #line 3405 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6116 const Type* Ty = (yyvsp[-2].TypeVal).T->get();
6117 if (!isa<PointerType>(Ty))
6118 error("getelementptr insn requires pointer operand");
6120 std::vector<Value*> VIndices;
6121 upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6123 Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6124 (yyval.InstVal).I = new GetElementPtrInst(tmpVal, VIndices);
6125 (yyval.InstVal).S = Signless;
6126 delete (yyvsp[-2].TypeVal).T;
6127 delete (yyvsp[0].ValueList);
6135 /* Line 1126 of yacc.c. */
6136 #line 6137 "UpgradeParser.tab.c"
6142 YY_STACK_PRINT (yyss, yyssp);
6147 /* Now `shift' the result of the reduction. Determine what state
6148 that goes to, based on the state we popped back to and the rule
6149 number reduced by. */
6153 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6154 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6155 yystate = yytable[yystate];
6157 yystate = yydefgoto[yyn - YYNTOKENS];
6162 /*------------------------------------.
6163 | yyerrlab -- here on detecting error |
6164 `------------------------------------*/
6166 /* If not already recovering from an error, report this error. */
6171 yyn = yypact[yystate];
6173 if (YYPACT_NINF < yyn && yyn < YYLAST)
6175 int yytype = YYTRANSLATE (yychar);
6176 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6177 YYSIZE_T yysize = yysize0;
6179 int yysize_overflow = 0;
6181 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6182 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6186 /* This is so xgettext sees the translatable formats that are
6187 constructed on the fly. */
6188 YY_("syntax error, unexpected %s");
6189 YY_("syntax error, unexpected %s, expecting %s");
6190 YY_("syntax error, unexpected %s, expecting %s or %s");
6191 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6192 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6196 static char const yyunexpected[] = "syntax error, unexpected %s";
6197 static char const yyexpecting[] = ", expecting %s";
6198 static char const yyor[] = " or %s";
6199 char yyformat[sizeof yyunexpected
6200 + sizeof yyexpecting - 1
6201 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6202 * (sizeof yyor - 1))];
6203 char const *yyprefix = yyexpecting;
6205 /* Start YYX at -YYN if negative to avoid negative indexes in
6207 int yyxbegin = yyn < 0 ? -yyn : 0;
6209 /* Stay within bounds of both yycheck and yytname. */
6210 int yychecklim = YYLAST - yyn;
6211 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6214 yyarg[0] = yytname[yytype];
6215 yyfmt = yystpcpy (yyformat, yyunexpected);
6217 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6218 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6220 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6224 yyformat[sizeof yyunexpected - 1] = '\0';
6227 yyarg[yycount++] = yytname[yyx];
6228 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6229 yysize_overflow |= yysize1 < yysize;
6231 yyfmt = yystpcpy (yyfmt, yyprefix);
6235 yyf = YY_(yyformat);
6236 yysize1 = yysize + yystrlen (yyf);
6237 yysize_overflow |= yysize1 < yysize;
6240 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6241 yymsg = (char *) YYSTACK_ALLOC (yysize);
6244 /* Avoid sprintf, as that infringes on the user's name space.
6245 Don't have undefined behavior even if the translation
6246 produced a string with the wrong number of "%s"s. */
6249 while ((*yyp = *yyf))
6251 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6253 yyp += yytnamerr (yyp, yyarg[yyi++]);
6263 YYSTACK_FREE (yymsg);
6267 yyerror (YY_("syntax error"));
6268 goto yyexhaustedlab;
6272 #endif /* YYERROR_VERBOSE */
6273 yyerror (YY_("syntax error"));
6278 if (yyerrstatus == 3)
6280 /* If just tried and failed to reuse look-ahead token after an
6281 error, discard it. */
6283 if (yychar <= YYEOF)
6285 /* Return failure if at end of input. */
6286 if (yychar == YYEOF)
6291 yydestruct ("Error: discarding", yytoken, &yylval);
6296 /* Else will try to reuse look-ahead token after shifting the error
6301 /*---------------------------------------------------.
6302 | yyerrorlab -- error raised explicitly by YYERROR. |
6303 `---------------------------------------------------*/
6306 /* Pacify compilers like GCC when the user code never invokes
6307 YYERROR and the label yyerrorlab therefore never appears in user
6318 /*-------------------------------------------------------------.
6319 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6320 `-------------------------------------------------------------*/
6322 yyerrstatus = 3; /* Each real token shifted decrements this. */
6326 yyn = yypact[yystate];
6327 if (yyn != YYPACT_NINF)
6330 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6338 /* Pop the current state because it cannot handle the error token. */
6343 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6346 YY_STACK_PRINT (yyss, yyssp);
6355 /* Shift the error token. */
6356 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6362 /*-------------------------------------.
6363 | yyacceptlab -- YYACCEPT comes here. |
6364 `-------------------------------------*/
6369 /*-----------------------------------.
6370 | yyabortlab -- YYABORT comes here. |
6371 `-----------------------------------*/
6377 /*-------------------------------------------------.
6378 | yyexhaustedlab -- memory exhaustion comes here. |
6379 `-------------------------------------------------*/
6381 yyerror (YY_("memory exhausted"));
6387 if (yychar != YYEOF && yychar != YYEMPTY)
6388 yydestruct ("Cleanup: discarding lookahead",
6390 while (yyssp != yyss)
6392 yydestruct ("Cleanup: popping",
6393 yystos[*yyssp], yyvsp);
6398 YYSTACK_FREE (yyss);
6404 #line 3421 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
6407 int yyerror(const char *ErrorMsg) {
6409 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6410 + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6411 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6412 if (yychar != YYEMPTY && yychar != 0)
6413 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6415 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6416 std::cout << "llvm-upgrade: parse failed.\n";
6420 void warning(const std::string& ErrorMsg) {
6422 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6423 + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6424 std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6425 if (yychar != YYEMPTY && yychar != 0)
6426 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6428 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6431 void error(const std::string& ErrorMsg, int LineNo) {
6432 if (LineNo == -1) LineNo = Upgradelineno;
6433 Upgradelineno = LineNo;
6434 yyerror(ErrorMsg.c_str());