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-1/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/SymbolTable.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 SymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
676 V = SymTab.lookup(Ty, LookupName);
679 RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
680 std::string LookupName;
681 if (I != CurModule.RenameMap.end())
682 LookupName = I->second;
685 V = CurModule.CurrentModule->getValueSymbolTable().lookup(Ty, LookupName);
690 D.destroy(); // Free old strdup'd memory...
694 // Check to make sure that "Ty" is an integral type, and that our
695 // value will fit into the specified type...
696 case ValID::ConstSIntVal: // Is it a constant pool reference??
697 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
698 error("Signed integral constant '" + itostr(D.ConstPool64) +
699 "' is invalid for type '" + Ty->getDescription() + "'");
701 return ConstantInt::get(Ty, D.ConstPool64);
703 case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
704 if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
705 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
706 error("Integral constant '" + utostr(D.UConstPool64) +
707 "' is invalid or out of range");
708 else // This is really a signed reference. Transmogrify.
709 return ConstantInt::get(Ty, D.ConstPool64);
711 return ConstantInt::get(Ty, D.UConstPool64);
713 case ValID::ConstFPVal: // Is it a floating point const pool reference?
714 if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
715 error("FP constant invalid for type");
716 return ConstantFP::get(Ty, D.ConstPoolFP);
718 case ValID::ConstNullVal: // Is it a null value?
719 if (!isa<PointerType>(Ty))
720 error("Cannot create a a non pointer null");
721 return ConstantPointerNull::get(cast<PointerType>(Ty));
723 case ValID::ConstUndefVal: // Is it an undef value?
724 return UndefValue::get(Ty);
726 case ValID::ConstZeroVal: // Is it a zero value?
727 return Constant::getNullValue(Ty);
729 case ValID::ConstantVal: // Fully resolved constant?
730 if (D.ConstantValue->getType() != Ty)
731 error("Constant expression type different from required type");
732 return D.ConstantValue;
734 case ValID::InlineAsmVal: { // Inline asm expression
735 const PointerType *PTy = dyn_cast<PointerType>(Ty);
736 const FunctionType *FTy =
737 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
738 if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
739 error("Invalid type for asm constraint string");
740 InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
741 D.IAD->HasSideEffects);
742 D.destroy(); // Free InlineAsmDescriptor.
746 assert(0 && "Unhandled case");
750 assert(0 && "Unhandled case");
754 // getVal - This function is identical to getExistingValue, except that if a
755 // value is not already defined, it "improvises" by creating a placeholder var
756 // that looks and acts just like the requested variable. When the value is
757 // defined later, all uses of the placeholder variable are replaced with the
760 static Value *getVal(const Type *Ty, const ValID &ID) {
761 if (Ty == Type::LabelTy)
762 error("Cannot use a basic block here");
764 // See if the value has already been defined.
765 Value *V = getExistingValue(Ty, ID);
768 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
769 error("Invalid use of a composite type");
771 // If we reached here, we referenced either a symbol that we don't know about
772 // or an id number that hasn't been read yet. We may be referencing something
773 // forward, so just create an entry to be resolved later and get to it...
774 V = new Argument(Ty);
776 // Remember where this forward reference came from. FIXME, shouldn't we try
777 // to recycle these things??
778 CurModule.PlaceHolderInfo.insert(
779 std::make_pair(V, std::make_pair(ID, Upgradelineno-1)));
781 if (inFunctionScope())
782 InsertValue(V, CurFun.LateResolveValues);
784 InsertValue(V, CurModule.LateResolveValues);
788 /// getBBVal - This is used for two purposes:
789 /// * If isDefinition is true, a new basic block with the specified ID is being
791 /// * If isDefinition is true, this is a reference to a basic block, which may
792 /// or may not be a forward reference.
794 static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
795 assert(inFunctionScope() && "Can't get basic block at global scope");
801 error("Illegal label reference " + ID.getName());
803 case ValID::NumberVal: // Is it a numbered definition?
804 if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
805 CurFun.NumberedBlocks.resize(ID.Num+1);
806 BB = CurFun.NumberedBlocks[ID.Num];
808 case ValID::NameVal: // Is it a named definition?
810 if (Value *N = CurFun.CurrentFunction->
811 getValueSymbolTable().lookup(Type::LabelTy, Name)) {
812 if (N->getType() != Type::LabelTy)
813 error("Name '" + Name + "' does not refer to a BasicBlock");
814 BB = cast<BasicBlock>(N);
819 // See if the block has already been defined.
821 // If this is the definition of the block, make sure the existing value was
822 // just a forward reference. If it was a forward reference, there will be
823 // an entry for it in the PlaceHolderInfo map.
824 if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
825 // The existing value was a definition, not a forward reference.
826 error("Redefinition of label " + ID.getName());
828 ID.destroy(); // Free strdup'd memory.
832 // Otherwise this block has not been seen before.
833 BB = new BasicBlock("", CurFun.CurrentFunction);
834 if (ID.Type == ValID::NameVal) {
835 BB->setName(ID.Name);
837 CurFun.NumberedBlocks[ID.Num] = BB;
840 // If this is not a definition, keep track of it so we can use it as a forward
843 // Remember where this forward reference came from.
844 CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
846 // The forward declaration could have been inserted anywhere in the
847 // function: insert it into the correct place now.
848 CurFun.CurrentFunction->getBasicBlockList().remove(BB);
849 CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
856 //===----------------------------------------------------------------------===//
857 // Code to handle forward references in instructions
858 //===----------------------------------------------------------------------===//
860 // This code handles the late binding needed with statements that reference
861 // values not defined yet... for example, a forward branch, or the PHI node for
864 // This keeps a table (CurFun.LateResolveValues) of all such forward references
865 // and back patchs after we are done.
868 /// This function determines if two function types differ only in their use of
869 /// the sret parameter attribute in the first argument. If they are identical
870 /// in all other respects, it returns true. Otherwise, it returns false.
871 bool FuncTysDifferOnlyBySRet(const FunctionType *F1,
872 const FunctionType *F2) {
873 if (F1->getReturnType() != F2->getReturnType() ||
874 F1->getNumParams() != F2->getNumParams() ||
875 F1->getParamAttrs(0) != F2->getParamAttrs(0))
877 unsigned SRetMask = ~unsigned(FunctionType::StructRetAttribute);
878 for (unsigned i = 0; i < F1->getNumParams(); ++i) {
879 if (F1->getParamType(i) != F2->getParamType(i) ||
880 unsigned(F1->getParamAttrs(i+1)) & SRetMask !=
881 unsigned(F2->getParamAttrs(i+1)) & SRetMask)
887 // ResolveDefinitions - If we could not resolve some defs at parsing
888 // time (forward branches, phi functions for loops, etc...) resolve the
892 ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
893 std::map<const Type*,ValueList> *FutureLateResolvers) {
894 // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
895 for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
896 E = LateResolvers.end(); LRI != E; ++LRI) {
897 ValueList &List = LRI->second;
898 while (!List.empty()) {
899 Value *V = List.back();
902 std::map<Value*, std::pair<ValID, int> >::iterator PHI =
903 CurModule.PlaceHolderInfo.find(V);
904 assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
906 ValID &DID = PHI->second.first;
908 Value *TheRealValue = getExistingValue(LRI->first, DID);
910 V->replaceAllUsesWith(TheRealValue);
912 CurModule.PlaceHolderInfo.erase(PHI);
913 } else if (FutureLateResolvers) {
914 // Functions have their unresolved items forwarded to the module late
916 InsertValue(V, *FutureLateResolvers);
918 if (DID.Type == ValID::NameVal) {
919 // The upgrade of csretcc to sret param attribute may have caused a
920 // function to not be found because the param attribute changed the
921 // type of the called function. Detect this situation and insert a
922 // cast as necessary.
924 if (const PointerType *PTy = dyn_cast<PointerType>(V->getType()))
925 if (const FunctionType *FTy =
926 dyn_cast<FunctionType>(PTy->getElementType()))
927 if (Function *OtherF =
928 CurModule.CurrentModule->getNamedFunction(DID.getName()))
929 if (FuncTysDifferOnlyBySRet(FTy,OtherF->getFunctionType())) {
930 V->replaceAllUsesWith(ConstantExpr::getBitCast(OtherF, PTy));
934 error("Reference to an invalid definition: '" +DID.getName()+
935 "' of type '" + V->getType()->getDescription() + "'",
940 error("Reference to an invalid definition: #" +
941 itostr(DID.Num) + " of type '" +
942 V->getType()->getDescription() + "'", PHI->second.second);
949 LateResolvers.clear();
952 // ResolveTypeTo - A brand new type was just declared. This means that (if
953 // name is not null) things referencing Name can be resolved. Otherwise, things
954 // refering to the number can be resolved. Do this now.
956 static void ResolveTypeTo(char *Name, const Type *ToTy) {
958 if (Name) D = ValID::create(Name);
959 else D = ValID::create((int)CurModule.Types.size());
961 std::map<ValID, PATypeHolder>::iterator I =
962 CurModule.LateResolveTypes.find(D);
963 if (I != CurModule.LateResolveTypes.end()) {
964 ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
965 CurModule.LateResolveTypes.erase(I);
969 /// @brief This just makes any name given to it unique, up to MAX_UINT times.
970 static std::string makeNameUnique(const std::string& Name) {
971 static unsigned UniqueNameCounter = 1;
972 std::string Result(Name);
973 Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
977 /// This is the implementation portion of TypeHasInteger. It traverses the
978 /// type given, avoiding recursive types, and returns true as soon as it finds
979 /// an integer type. If no integer type is found, it returns false.
980 static bool TypeHasIntegerI(const Type *Ty, std::vector<const Type*> Stack) {
981 // Handle some easy cases
982 if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID))
986 if (const SequentialType *STy = dyn_cast<SequentialType>(Ty))
987 return STy->getElementType()->isInteger();
989 // Avoid type structure recursion
990 for (std::vector<const Type*>::iterator I = Stack.begin(), E = Stack.end();
995 // Push us on the type stack
998 if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
999 if (TypeHasIntegerI(FTy->getReturnType(), Stack))
1001 FunctionType::param_iterator I = FTy->param_begin();
1002 FunctionType::param_iterator E = FTy->param_end();
1004 if (TypeHasIntegerI(*I, Stack))
1007 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1008 StructType::element_iterator I = STy->element_begin();
1009 StructType::element_iterator E = STy->element_end();
1010 for (; I != E; ++I) {
1011 if (TypeHasIntegerI(*I, Stack))
1016 // There shouldn't be anything else, but its definitely not integer
1017 assert(0 && "What type is this?");
1021 /// This is the interface to TypeHasIntegerI. It just provides the type stack,
1022 /// to avoid recursion, and then calls TypeHasIntegerI.
1023 static inline bool TypeHasInteger(const Type *Ty) {
1024 std::vector<const Type*> TyStack;
1025 return TypeHasIntegerI(Ty, TyStack);
1028 // setValueName - Set the specified value to the name given. The name may be
1029 // null potentially, in which case this is a noop. The string passed in is
1030 // assumed to be a malloc'd string buffer, and is free'd by this function.
1032 static void setValueName(Value *V, char *NameStr) {
1034 std::string Name(NameStr); // Copy string
1035 free(NameStr); // Free old string
1037 if (V->getType() == Type::VoidTy) {
1038 error("Can't assign name '" + Name + "' to value with void type");
1042 assert(inFunctionScope() && "Must be in function scope");
1044 // Search the function's symbol table for an existing value of this name
1045 Value* Existing = 0;
1046 SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1047 SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE =ST.plane_end();
1048 for ( ; PI != PE; ++PI) {
1049 SymbolTable::value_const_iterator VI = PI->second.find(Name);
1050 if (VI != PI->second.end()) {
1051 Existing = VI->second;
1056 // An existing value of the same name was found. This might have happened
1057 // because of the integer type planes collapsing in LLVM 2.0.
1058 if (Existing->getType() == V->getType() &&
1059 !TypeHasInteger(Existing->getType())) {
1060 // If the type does not contain any integers in them then this can't be
1061 // a type plane collapsing issue. It truly is a redefinition and we
1062 // should error out as the assembly is invalid.
1063 error("Redefinition of value named '" + Name + "' of type '" +
1064 V->getType()->getDescription() + "'");
1067 // In LLVM 2.0 we don't allow names to be re-used for any values in a
1068 // function, regardless of Type. Previously re-use of names was okay as
1069 // long as they were distinct types. With type planes collapsing because
1070 // of the signedness change and because of PR411, this can no longer be
1071 // supported. We must search the entire symbol table for a conflicting
1072 // name and make the name unique. No warning is needed as this can't
1074 std::string NewName = makeNameUnique(Name);
1075 // We're changing the name but it will probably be used by other
1076 // instructions as operands later on. Consequently we have to retain
1077 // a mapping of the renaming that we're doing.
1078 RenameMapKey Key = std::make_pair(Name,V->getType());
1079 CurFun.RenameMap[Key] = NewName;
1088 /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
1089 /// this is a declaration, otherwise it is a definition.
1090 static GlobalVariable *
1091 ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
1092 bool isConstantGlobal, const Type *Ty,
1093 Constant *Initializer) {
1094 if (isa<FunctionType>(Ty))
1095 error("Cannot declare global vars of function type");
1097 const PointerType *PTy = PointerType::get(Ty);
1101 Name = NameStr; // Copy string
1102 free(NameStr); // Free old string
1105 // See if this global value was forward referenced. If so, recycle the
1108 if (!Name.empty()) {
1109 ID = ValID::create((char*)Name.c_str());
1111 ID = ValID::create((int)CurModule.Values[PTy].size());
1114 if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1115 // Move the global to the end of the list, from whereever it was
1116 // previously inserted.
1117 GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1118 CurModule.CurrentModule->getGlobalList().remove(GV);
1119 CurModule.CurrentModule->getGlobalList().push_back(GV);
1120 GV->setInitializer(Initializer);
1121 GV->setLinkage(Linkage);
1122 GV->setConstant(isConstantGlobal);
1123 InsertValue(GV, CurModule.Values);
1127 // If this global has a name, check to see if there is already a definition
1128 // of this global in the module and emit warnings if there are conflicts.
1129 if (!Name.empty()) {
1130 // The global has a name. See if there's an existing one of the same name.
1131 if (CurModule.CurrentModule->getNamedGlobal(Name)) {
1132 // We found an existing global ov the same name. This isn't allowed
1133 // in LLVM 2.0. Consequently, we must alter the name of the global so it
1134 // can at least compile. This can happen because of type planes
1135 // There is alread a global of the same name which means there is a
1136 // conflict. Let's see what we can do about it.
1137 std::string NewName(makeNameUnique(Name));
1138 if (Linkage == GlobalValue::InternalLinkage) {
1139 // The linkage type is internal so just warn about the rename without
1140 // invoking "scarey language" about linkage failures. GVars with
1141 // InternalLinkage can be renamed at will.
1142 warning("Global variable '" + Name + "' was renamed to '"+
1145 // The linkage of this gval is external so we can't reliably rename
1146 // it because it could potentially create a linking problem.
1147 // However, we can't leave the name conflict in the output either or
1148 // it won't assemble with LLVM 2.0. So, all we can do is rename
1149 // this one to something unique and emit a warning about the problem.
1150 warning("Renaming global variable '" + Name + "' to '" + NewName +
1151 "' may cause linkage errors");
1154 // Put the renaming in the global rename map
1155 RenameMapKey Key = std::make_pair(Name,PointerType::get(Ty));
1156 CurModule.RenameMap[Key] = NewName;
1163 // Otherwise there is no existing GV to use, create one now.
1164 GlobalVariable *GV =
1165 new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1166 CurModule.CurrentModule);
1167 InsertValue(GV, CurModule.Values);
1171 // setTypeName - Set the specified type to the name given. The name may be
1172 // null potentially, in which case this is a noop. The string passed in is
1173 // assumed to be a malloc'd string buffer, and is freed by this function.
1175 // This function returns true if the type has already been defined, but is
1176 // allowed to be redefined in the specified context. If the name is a new name
1177 // for the type plane, it is inserted and false is returned.
1178 static bool setTypeName(const Type *T, char *NameStr) {
1179 assert(!inFunctionScope() && "Can't give types function-local names");
1180 if (NameStr == 0) return false;
1182 std::string Name(NameStr); // Copy string
1183 free(NameStr); // Free old string
1185 // We don't allow assigning names to void type
1186 if (T == Type::VoidTy) {
1187 error("Can't assign name '" + Name + "' to the void type");
1191 // Set the type name, checking for conflicts as we do so.
1192 bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1194 if (AlreadyExists) { // Inserting a name that is already defined???
1195 const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1196 assert(Existing && "Conflict but no matching type?");
1198 // There is only one case where this is allowed: when we are refining an
1199 // opaque type. In this case, Existing will be an opaque type.
1200 if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1201 // We ARE replacing an opaque type!
1202 const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1206 // Otherwise, this is an attempt to redefine a type. That's okay if
1207 // the redefinition is identical to the original. This will be so if
1208 // Existing and T point to the same Type object. In this one case we
1209 // allow the equivalent redefinition.
1210 if (Existing == T) return true; // Yes, it's equal.
1212 // Any other kind of (non-equivalent) redefinition is an error.
1213 error("Redefinition of type named '" + Name + "' in the '" +
1214 T->getDescription() + "' type plane");
1220 //===----------------------------------------------------------------------===//
1221 // Code for handling upreferences in type names...
1224 // TypeContains - Returns true if Ty directly contains E in it.
1226 static bool TypeContains(const Type *Ty, const Type *E) {
1227 return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1228 E) != Ty->subtype_end();
1232 struct UpRefRecord {
1233 // NestingLevel - The number of nesting levels that need to be popped before
1234 // this type is resolved.
1235 unsigned NestingLevel;
1237 // LastContainedTy - This is the type at the current binding level for the
1238 // type. Every time we reduce the nesting level, this gets updated.
1239 const Type *LastContainedTy;
1241 // UpRefTy - This is the actual opaque type that the upreference is
1242 // represented with.
1243 OpaqueType *UpRefTy;
1245 UpRefRecord(unsigned NL, OpaqueType *URTy)
1246 : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1250 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1251 static std::vector<UpRefRecord> UpRefs;
1253 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1254 /// called. It loops through the UpRefs vector, which is a list of the
1255 /// currently active types. For each type, if the up reference is contained in
1256 /// the newly completed type, we decrement the level count. When the level
1257 /// count reaches zero, the upreferenced type is the type that is passed in:
1258 /// thus we can complete the cycle.
1260 static PATypeHolder HandleUpRefs(const Type *ty) {
1261 // If Ty isn't abstract, or if there are no up-references in it, then there is
1262 // nothing to resolve here.
1263 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1265 PATypeHolder Ty(ty);
1266 UR_OUT("Type '" << Ty->getDescription() <<
1267 "' newly formed. Resolving upreferences.\n" <<
1268 UpRefs.size() << " upreferences active!\n");
1270 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1271 // to zero), we resolve them all together before we resolve them to Ty. At
1272 // the end of the loop, if there is anything to resolve to Ty, it will be in
1274 OpaqueType *TypeToResolve = 0;
1276 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1277 UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1278 << UpRefs[i].second->getDescription() << ") = "
1279 << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1280 if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1281 // Decrement level of upreference
1282 unsigned Level = --UpRefs[i].NestingLevel;
1283 UpRefs[i].LastContainedTy = Ty;
1284 UR_OUT(" Uplevel Ref Level = " << Level << "\n");
1285 if (Level == 0) { // Upreference should be resolved!
1286 if (!TypeToResolve) {
1287 TypeToResolve = UpRefs[i].UpRefTy;
1289 UR_OUT(" * Resolving upreference for "
1290 << UpRefs[i].second->getDescription() << "\n";
1291 std::string OldName = UpRefs[i].UpRefTy->getDescription());
1292 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1293 UR_OUT(" * Type '" << OldName << "' refined upreference to: "
1294 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1296 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
1297 --i; // Do not skip the next element...
1302 if (TypeToResolve) {
1303 UR_OUT(" * Resolving upreference for "
1304 << UpRefs[i].second->getDescription() << "\n";
1305 std::string OldName = TypeToResolve->getDescription());
1306 TypeToResolve->refineAbstractTypeTo(Ty);
1312 static inline Instruction::TermOps
1313 getTermOp(TermOps op) {
1315 default : assert(0 && "Invalid OldTermOp");
1316 case RetOp : return Instruction::Ret;
1317 case BrOp : return Instruction::Br;
1318 case SwitchOp : return Instruction::Switch;
1319 case InvokeOp : return Instruction::Invoke;
1320 case UnwindOp : return Instruction::Unwind;
1321 case UnreachableOp: return Instruction::Unreachable;
1325 static inline Instruction::BinaryOps
1326 getBinaryOp(BinaryOps op, const Type *Ty, Signedness Sign) {
1328 default : assert(0 && "Invalid OldBinaryOps");
1334 case SetGT : assert(0 && "Should use getCompareOp");
1335 case AddOp : return Instruction::Add;
1336 case SubOp : return Instruction::Sub;
1337 case MulOp : return Instruction::Mul;
1339 // This is an obsolete instruction so we must upgrade it based on the
1340 // types of its operands.
1341 bool isFP = Ty->isFloatingPoint();
1342 if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1343 // If its a packed type we want to use the element type
1344 isFP = PTy->getElementType()->isFloatingPoint();
1346 return Instruction::FDiv;
1347 else if (Sign == Signed)
1348 return Instruction::SDiv;
1349 return Instruction::UDiv;
1351 case UDivOp : return Instruction::UDiv;
1352 case SDivOp : return Instruction::SDiv;
1353 case FDivOp : return Instruction::FDiv;
1355 // This is an obsolete instruction so we must upgrade it based on the
1356 // types of its operands.
1357 bool isFP = Ty->isFloatingPoint();
1358 if (const PackedType* PTy = dyn_cast<PackedType>(Ty))
1359 // If its a packed type we want to use the element type
1360 isFP = PTy->getElementType()->isFloatingPoint();
1361 // Select correct opcode
1363 return Instruction::FRem;
1364 else if (Sign == Signed)
1365 return Instruction::SRem;
1366 return Instruction::URem;
1368 case URemOp : return Instruction::URem;
1369 case SRemOp : return Instruction::SRem;
1370 case FRemOp : return Instruction::FRem;
1371 case LShrOp : return Instruction::LShr;
1372 case AShrOp : return Instruction::AShr;
1373 case ShlOp : return Instruction::Shl;
1376 return Instruction::AShr;
1377 return Instruction::LShr;
1378 case AndOp : return Instruction::And;
1379 case OrOp : return Instruction::Or;
1380 case XorOp : return Instruction::Xor;
1384 static inline Instruction::OtherOps
1385 getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
1387 bool isSigned = Sign == Signed;
1388 bool isFP = Ty->isFloatingPoint();
1390 default : assert(0 && "Invalid OldSetCC");
1393 predicate = FCmpInst::FCMP_OEQ;
1394 return Instruction::FCmp;
1396 predicate = ICmpInst::ICMP_EQ;
1397 return Instruction::ICmp;
1401 predicate = FCmpInst::FCMP_UNE;
1402 return Instruction::FCmp;
1404 predicate = ICmpInst::ICMP_NE;
1405 return Instruction::ICmp;
1409 predicate = FCmpInst::FCMP_OLE;
1410 return Instruction::FCmp;
1413 predicate = ICmpInst::ICMP_SLE;
1415 predicate = ICmpInst::ICMP_ULE;
1416 return Instruction::ICmp;
1420 predicate = FCmpInst::FCMP_OGE;
1421 return Instruction::FCmp;
1424 predicate = ICmpInst::ICMP_SGE;
1426 predicate = ICmpInst::ICMP_UGE;
1427 return Instruction::ICmp;
1431 predicate = FCmpInst::FCMP_OLT;
1432 return Instruction::FCmp;
1435 predicate = ICmpInst::ICMP_SLT;
1437 predicate = ICmpInst::ICMP_ULT;
1438 return Instruction::ICmp;
1442 predicate = FCmpInst::FCMP_OGT;
1443 return Instruction::FCmp;
1446 predicate = ICmpInst::ICMP_SGT;
1448 predicate = ICmpInst::ICMP_UGT;
1449 return Instruction::ICmp;
1454 static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
1456 default : assert(0 && "Invalid OldMemoryOps");
1457 case MallocOp : return Instruction::Malloc;
1458 case FreeOp : return Instruction::Free;
1459 case AllocaOp : return Instruction::Alloca;
1460 case LoadOp : return Instruction::Load;
1461 case StoreOp : return Instruction::Store;
1462 case GetElementPtrOp : return Instruction::GetElementPtr;
1466 static inline Instruction::OtherOps
1467 getOtherOp(OtherOps op, Signedness Sign) {
1469 default : assert(0 && "Invalid OldOtherOps");
1470 case PHIOp : return Instruction::PHI;
1471 case CallOp : return Instruction::Call;
1472 case SelectOp : return Instruction::Select;
1473 case UserOp1 : return Instruction::UserOp1;
1474 case UserOp2 : return Instruction::UserOp2;
1475 case VAArg : return Instruction::VAArg;
1476 case ExtractElementOp : return Instruction::ExtractElement;
1477 case InsertElementOp : return Instruction::InsertElement;
1478 case ShuffleVectorOp : return Instruction::ShuffleVector;
1479 case ICmpOp : return Instruction::ICmp;
1480 case FCmpOp : return Instruction::FCmp;
1484 static inline Value*
1485 getCast(CastOps op, Value *Src, Signedness SrcSign, const Type *DstTy,
1486 Signedness DstSign, bool ForceInstruction = false) {
1487 Instruction::CastOps Opcode;
1488 const Type* SrcTy = Src->getType();
1490 if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
1491 // fp -> ptr cast is no longer supported but we must upgrade this
1492 // by doing a double cast: fp -> int -> ptr
1493 SrcTy = Type::Int64Ty;
1494 Opcode = Instruction::IntToPtr;
1495 if (isa<Constant>(Src)) {
1496 Src = ConstantExpr::getCast(Instruction::FPToUI,
1497 cast<Constant>(Src), SrcTy);
1499 std::string NewName(makeNameUnique(Src->getName()));
1500 Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
1502 } else if (isa<IntegerType>(DstTy) &&
1503 cast<IntegerType>(DstTy)->getBitWidth() == 1) {
1504 // cast type %x to bool was previously defined as setne type %x, null
1505 // The cast semantic is now to truncate, not compare so we must retain
1506 // the original intent by replacing the cast with a setne
1507 Constant* Null = Constant::getNullValue(SrcTy);
1508 Instruction::OtherOps Opcode = Instruction::ICmp;
1509 unsigned short predicate = ICmpInst::ICMP_NE;
1510 if (SrcTy->isFloatingPoint()) {
1511 Opcode = Instruction::FCmp;
1512 predicate = FCmpInst::FCMP_ONE;
1513 } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
1514 error("Invalid cast to bool");
1516 if (isa<Constant>(Src) && !ForceInstruction)
1517 return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
1519 return CmpInst::create(Opcode, predicate, Src, Null);
1521 // Determine the opcode to use by calling CastInst::getCastOpcode
1523 CastInst::getCastOpcode(Src, SrcSign == Signed, DstTy, DstSign == Signed);
1525 } else switch (op) {
1526 default: assert(0 && "Invalid cast token");
1527 case TruncOp: Opcode = Instruction::Trunc; break;
1528 case ZExtOp: Opcode = Instruction::ZExt; break;
1529 case SExtOp: Opcode = Instruction::SExt; break;
1530 case FPTruncOp: Opcode = Instruction::FPTrunc; break;
1531 case FPExtOp: Opcode = Instruction::FPExt; break;
1532 case FPToUIOp: Opcode = Instruction::FPToUI; break;
1533 case FPToSIOp: Opcode = Instruction::FPToSI; break;
1534 case UIToFPOp: Opcode = Instruction::UIToFP; break;
1535 case SIToFPOp: Opcode = Instruction::SIToFP; break;
1536 case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
1537 case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
1538 case BitCastOp: Opcode = Instruction::BitCast; break;
1541 if (isa<Constant>(Src) && !ForceInstruction)
1542 return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
1543 return CastInst::create(Opcode, Src, DstTy);
1546 static Instruction *
1547 upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
1548 std::vector<Value*>& Args) {
1550 std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
1551 if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
1552 if (Args.size() != 2)
1553 error("Invalid prototype for " + Name + " prototype");
1554 return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
1556 const Type* PtrTy = PointerType::get(Type::Int8Ty);
1557 std::vector<const Type*> Params;
1558 if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1559 if (Args.size() != 1)
1560 error("Invalid prototype for " + Name + " prototype");
1561 Params.push_back(PtrTy);
1562 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1563 const PointerType *PFTy = PointerType::get(FTy);
1564 Value* Func = getVal(PFTy, ID);
1565 Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1566 return new CallInst(Func, Args);
1567 } else if (Name == "llvm.va_copy") {
1568 if (Args.size() != 2)
1569 error("Invalid prototype for " + Name + " prototype");
1570 Params.push_back(PtrTy);
1571 Params.push_back(PtrTy);
1572 const FunctionType *FTy = FunctionType::get(Type::VoidTy, Params, false);
1573 const PointerType *PFTy = PointerType::get(FTy);
1574 Value* Func = getVal(PFTy, ID);
1575 std::string InstName0(makeNameUnique("va0"));
1576 std::string InstName1(makeNameUnique("va1"));
1577 Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1578 Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1579 return new CallInst(Func, Args);
1585 const Type* upgradeGEPIndices(const Type* PTy,
1586 std::vector<ValueInfo> *Indices,
1587 std::vector<Value*> &VIndices,
1588 std::vector<Constant*> *CIndices = 0) {
1589 // Traverse the indices with a gep_type_iterator so we can build the list
1590 // of constant and value indices for use later. Also perform upgrades
1592 if (CIndices) CIndices->clear();
1593 for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1594 VIndices.push_back((*Indices)[i].V);
1595 generic_gep_type_iterator<std::vector<Value*>::iterator>
1596 GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()),
1597 GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end());
1598 for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1599 Value *Index = VIndices[i];
1600 if (CIndices && !isa<Constant>(Index))
1601 error("Indices to constant getelementptr must be constants");
1602 // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte
1603 // struct indices to i32 struct indices with ZExt for compatibility.
1604 else if (isa<StructType>(*GTI)) { // Only change struct indices
1605 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1606 if (CUI->getType()->getBitWidth() == 8)
1608 ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1610 // Make sure that unsigned SequentialType indices are zext'd to
1611 // 64-bits if they were smaller than that because LLVM 2.0 will sext
1612 // all indices for SequentialType elements. We must retain the same
1613 // semantic (zext) for unsigned types.
1614 if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1615 if (Ity->getBitWidth() < 64 && (*Indices)[i].S == Unsigned) {
1617 Index = ConstantExpr::getCast(Instruction::ZExt,
1618 cast<Constant>(Index), Type::Int64Ty);
1620 Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1621 makeNameUnique("gep"), CurBB);
1622 VIndices[i] = Index;
1625 // Add to the CIndices list, if requested.
1627 CIndices->push_back(cast<Constant>(Index));
1631 GetElementPtrInst::getIndexedType(PTy, VIndices, true);
1633 error("Index list invalid for constant getelementptr");
1637 unsigned upgradeCallingConv(unsigned CC) {
1639 case OldCallingConv::C : return CallingConv::C;
1640 case OldCallingConv::CSRet : return CallingConv::C;
1641 case OldCallingConv::Fast : return CallingConv::Fast;
1642 case OldCallingConv::Cold : return CallingConv::Cold;
1643 case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1644 case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1650 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1651 bool debug, bool addAttrs)
1654 CurFilename = infile;
1657 AddAttributes = addAttrs;
1658 ObsoleteVarArgs = false;
1661 CurModule.CurrentModule = new Module(CurFilename);
1663 // Check to make sure the parser succeeded
1666 delete ParserResult;
1667 std::cerr << "llvm-upgrade: parse failed.\n";
1671 // Check to make sure that parsing produced a result
1672 if (!ParserResult) {
1673 std::cerr << "llvm-upgrade: no parse result.\n";
1677 // Reset ParserResult variable while saving its value for the result.
1678 Module *Result = ParserResult;
1681 //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1684 if ((F = Result->getNamedFunction("llvm.va_start"))
1685 && F->getFunctionType()->getNumParams() == 0)
1686 ObsoleteVarArgs = true;
1687 if((F = Result->getNamedFunction("llvm.va_copy"))
1688 && F->getFunctionType()->getNumParams() == 1)
1689 ObsoleteVarArgs = true;
1692 if (ObsoleteVarArgs && NewVarArgs) {
1693 error("This file is corrupt: it uses both new and old style varargs");
1697 if(ObsoleteVarArgs) {
1698 if(Function* F = Result->getNamedFunction("llvm.va_start")) {
1699 if (F->arg_size() != 0) {
1700 error("Obsolete va_start takes 0 argument");
1706 //bar = alloca typeof(foo)
1710 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1711 const Type* ArgTy = F->getFunctionType()->getReturnType();
1712 const Type* ArgTyPtr = PointerType::get(ArgTy);
1713 Function* NF = cast<Function>(Result->getOrInsertFunction(
1714 "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
1716 while (!F->use_empty()) {
1717 CallInst* CI = cast<CallInst>(F->use_back());
1718 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
1719 new CallInst(NF, bar, "", CI);
1720 Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
1721 CI->replaceAllUsesWith(foo);
1722 CI->getParent()->getInstList().erase(CI);
1724 Result->getFunctionList().erase(F);
1727 if(Function* F = Result->getNamedFunction("llvm.va_end")) {
1728 if(F->arg_size() != 1) {
1729 error("Obsolete va_end takes 1 argument");
1735 //bar = alloca 1 of typeof(foo)
1737 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1738 const Type* ArgTy = F->getFunctionType()->getParamType(0);
1739 const Type* ArgTyPtr = PointerType::get(ArgTy);
1740 Function* NF = cast<Function>(Result->getOrInsertFunction(
1741 "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
1743 while (!F->use_empty()) {
1744 CallInst* CI = cast<CallInst>(F->use_back());
1745 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
1746 new StoreInst(CI->getOperand(1), bar, CI);
1747 new CallInst(NF, bar, "", CI);
1748 CI->getParent()->getInstList().erase(CI);
1750 Result->getFunctionList().erase(F);
1753 if(Function* F = Result->getNamedFunction("llvm.va_copy")) {
1754 if(F->arg_size() != 1) {
1755 error("Obsolete va_copy takes 1 argument");
1760 //a = alloca 1 of typeof(foo)
1761 //b = alloca 1 of typeof(foo)
1766 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
1767 const Type* ArgTy = F->getFunctionType()->getReturnType();
1768 const Type* ArgTyPtr = PointerType::get(ArgTy);
1769 Function* NF = cast<Function>(Result->getOrInsertFunction(
1770 "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
1772 while (!F->use_empty()) {
1773 CallInst* CI = cast<CallInst>(F->use_back());
1774 AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
1775 AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
1776 new StoreInst(CI->getOperand(1), b, CI);
1777 new CallInst(NF, a, b, "", CI);
1778 Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
1779 CI->replaceAllUsesWith(foo);
1780 CI->getParent()->getInstList().erase(CI);
1782 Result->getFunctionList().erase(F);
1789 } // end llvm namespace
1791 using namespace llvm;
1795 /* Enabling traces. */
1800 /* Enabling verbose error messages. */
1801 #ifdef YYERROR_VERBOSE
1802 # undef YYERROR_VERBOSE
1803 # define YYERROR_VERBOSE 1
1805 # define YYERROR_VERBOSE 0
1808 /* Enabling the token table. */
1809 #ifndef YYTOKEN_TABLE
1810 # define YYTOKEN_TABLE 0
1813 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1814 #line 1435 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
1815 typedef union YYSTYPE {
1816 llvm::Module *ModuleVal;
1817 llvm::Function *FunctionVal;
1818 std::pair<llvm::PATypeInfo, char*> *ArgVal;
1819 llvm::BasicBlock *BasicBlockVal;
1820 llvm::TerminatorInst *TermInstVal;
1821 llvm::InstrInfo InstVal;
1822 llvm::ConstInfo ConstVal;
1823 llvm::ValueInfo ValueVal;
1824 llvm::PATypeInfo TypeVal;
1825 llvm::TypeInfo PrimType;
1826 llvm::PHIListInfo PHIList;
1827 std::list<llvm::PATypeInfo> *TypeList;
1828 std::vector<llvm::ValueInfo> *ValueList;
1829 std::vector<llvm::ConstInfo> *ConstVector;
1832 std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
1833 // Represent the RHS of PHI node
1834 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1836 llvm::GlobalValue::LinkageTypes Linkage;
1844 char *StrVal; // This memory is strdup'd!
1845 llvm::ValID ValIDVal; // strdup'd memory maybe!
1847 llvm::BinaryOps BinaryOpVal;
1848 llvm::TermOps TermOpVal;
1849 llvm::MemoryOps MemOpVal;
1850 llvm::OtherOps OtherOpVal;
1851 llvm::CastOps CastOpVal;
1852 llvm::ICmpInst::Predicate IPred;
1853 llvm::FCmpInst::Predicate FPred;
1854 llvm::Module::Endianness Endianness;
1856 /* Line 196 of yacc.c. */
1857 #line 1858 "UpgradeParser.tab.c"
1858 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1859 # define YYSTYPE_IS_DECLARED 1
1860 # define YYSTYPE_IS_TRIVIAL 1
1865 /* Copy the second part of user declarations. */
1868 /* Line 219 of yacc.c. */
1869 #line 1870 "UpgradeParser.tab.c"
1871 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1872 # define YYSIZE_T __SIZE_TYPE__
1874 #if ! defined (YYSIZE_T) && defined (size_t)
1875 # define YYSIZE_T size_t
1877 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1878 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1879 # define YYSIZE_T size_t
1881 #if ! defined (YYSIZE_T)
1882 # define YYSIZE_T unsigned int
1888 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1889 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1893 # define YY_(msgid) msgid
1897 #if ! defined (yyoverflow) || YYERROR_VERBOSE
1899 /* The parser invokes alloca or malloc; define the necessary symbols. */
1901 # ifdef YYSTACK_USE_ALLOCA
1902 # if YYSTACK_USE_ALLOCA
1904 # define YYSTACK_ALLOC __builtin_alloca
1906 # define YYSTACK_ALLOC alloca
1907 # if defined (__STDC__) || defined (__cplusplus)
1908 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1909 # define YYINCLUDED_STDLIB_H
1915 # ifdef YYSTACK_ALLOC
1916 /* Pacify GCC's `empty if-body' warning. */
1917 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1918 # ifndef YYSTACK_ALLOC_MAXIMUM
1919 /* The OS might guarantee only one guard page at the bottom of the stack,
1920 and a page size can be as small as 4096 bytes. So we cannot safely
1921 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1922 to allow for a few compiler-allocated temporary stack slots. */
1923 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1926 # define YYSTACK_ALLOC YYMALLOC
1927 # define YYSTACK_FREE YYFREE
1928 # ifndef YYSTACK_ALLOC_MAXIMUM
1929 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1935 # define YYMALLOC malloc
1936 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1937 && (defined (__STDC__) || defined (__cplusplus)))
1938 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1942 # define YYFREE free
1943 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1944 && (defined (__STDC__) || defined (__cplusplus)))
1945 void free (void *); /* INFRINGES ON USER NAME SPACE */
1952 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1955 #if (! defined (yyoverflow) \
1956 && (! defined (__cplusplus) \
1957 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1959 /* A type that is properly aligned for any stack member. */
1966 /* The size of the maximum gap between one aligned stack and the next. */
1967 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1969 /* The size of an array large to enough to hold all stacks, each with
1971 # define YYSTACK_BYTES(N) \
1972 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
1973 + YYSTACK_GAP_MAXIMUM)
1975 /* Copy COUNT objects from FROM to TO. The source and destination do
1978 # if defined (__GNUC__) && 1 < __GNUC__
1979 # define YYCOPY(To, From, Count) \
1980 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1982 # define YYCOPY(To, From, Count) \
1986 for (yyi = 0; yyi < (Count); yyi++) \
1987 (To)[yyi] = (From)[yyi]; \
1993 /* Relocate STACK from its old location to the new one. The
1994 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1995 elements in the stack, and YYPTR gives the new location of the
1996 stack. Advance YYPTR to a properly aligned location for the next
1998 # define YYSTACK_RELOCATE(Stack) \
2001 YYSIZE_T yynewbytes; \
2002 YYCOPY (&yyptr->Stack, Stack, yysize); \
2003 Stack = &yyptr->Stack; \
2004 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2005 yyptr += yynewbytes / sizeof (*yyptr); \
2011 #if defined (__STDC__) || defined (__cplusplus)
2012 typedef signed char yysigned_char;
2014 typedef short int yysigned_char;
2017 /* YYFINAL -- State number of the termination state. */
2019 /* YYLAST -- Last index in YYTABLE. */
2022 /* YYNTOKENS -- Number of terminals. */
2023 #define YYNTOKENS 166
2024 /* YYNNTS -- Number of nonterminals. */
2026 /* YYNRULES -- Number of rules. */
2027 #define YYNRULES 308
2028 /* YYNRULES -- Number of states. */
2029 #define YYNSTATES 604
2031 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2032 #define YYUNDEFTOK 2
2033 #define YYMAXUTOK 406
2035 #define YYTRANSLATE(YYX) \
2036 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2038 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2039 static const unsigned char yytranslate[] =
2041 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2042 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2043 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2044 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2045 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2046 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2047 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2048 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2049 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2050 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2051 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2052 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2053 158, 2, 2, 162, 2, 163, 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, 2, 2, 2, 2,
2063 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2064 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2065 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2066 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2067 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2068 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2069 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2070 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2071 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2072 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2073 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2074 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2075 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2076 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2077 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2078 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2079 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2080 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2081 145, 146, 147, 148, 149, 150, 151
2085 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2087 static const unsigned short int yyprhs[] =
2089 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
2090 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
2091 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
2092 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
2093 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
2094 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
2095 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
2096 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
2097 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
2098 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
2099 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
2100 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
2101 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
2102 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
2103 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
2104 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
2105 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
2106 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
2107 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
2108 528, 529, 537, 538, 546, 547, 555, 559, 564, 565,
2109 567, 569, 571, 575, 579, 583, 587, 591, 595, 597,
2110 598, 600, 602, 604, 605, 608, 612, 614, 616, 620,
2111 622, 623, 632, 634, 636, 640, 642, 644, 647, 648,
2112 650, 652, 653, 658, 659, 661, 663, 665, 667, 669,
2113 671, 673, 675, 677, 681, 683, 689, 691, 693, 695,
2114 697, 700, 703, 706, 710, 713, 714, 716, 718, 720,
2115 723, 726, 730, 740, 750, 759, 773, 775, 777, 784,
2116 790, 793, 800, 808, 810, 814, 816, 817, 820, 822,
2117 828, 834, 840, 847, 854, 857, 862, 867, 874, 879,
2118 884, 889, 894, 901, 908, 911, 919, 921, 924, 925,
2119 927, 928, 932, 939, 943, 950, 953, 958, 965
2122 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2123 static const short int yyrhs[] =
2125 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
2126 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
2127 -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
2128 -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
2129 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
2130 -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
2131 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
2132 -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
2133 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
2134 -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
2135 -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
2136 -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
2137 -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
2138 -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
2139 -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
2140 -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
2141 -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
2142 -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
2143 -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
2144 -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
2145 -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
2146 -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
2147 -1, 191, -1, 8, -1, 193, -1, 8, -1, 193,
2148 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
2149 -1, 14, -1, 15, -1, 16, -1, 17, -1, 18,
2150 -1, 19, -1, 21, -1, 192, -1, 48, -1, 227,
2151 -1, 154, 4, -1, 190, 155, 195, 156, -1, 157,
2152 4, 158, 193, 159, -1, 160, 4, 158, 193, 161,
2153 -1, 162, 194, 163, -1, 162, 163, -1, 160, 162,
2154 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
2155 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
2156 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
2157 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
2158 191, 160, 198, 161, -1, 191, 162, 198, 163, -1,
2159 191, 162, 163, -1, 191, 160, 162, 198, 163, 161,
2160 -1, 191, 160, 162, 163, 161, -1, 191, 38, -1,
2161 191, 39, -1, 191, 227, -1, 191, 197, -1, 191,
2162 26, -1, 176, 168, -1, 177, 4, -1, 9, 27,
2163 -1, 9, 28, -1, 179, 7, -1, 175, 155, 196,
2164 36, 191, 156, -1, 110, 155, 196, 242, 156, -1,
2165 112, 155, 196, 153, 196, 153, 196, 156, -1, 169,
2166 155, 196, 153, 196, 156, -1, 170, 155, 196, 153,
2167 196, 156, -1, 171, 155, 196, 153, 196, 156, -1,
2168 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
2169 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
2170 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
2171 115, 155, 196, 153, 196, 153, 196, 156, -1, 116,
2172 155, 196, 153, 196, 153, 196, 156, -1, 198, 153,
2173 196, -1, 196, -1, 32, -1, 33, -1, 201, -1,
2174 201, 221, -1, 201, 223, -1, 201, 62, 61, 207,
2175 -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
2176 -1, 202, 223, -1, 202, 62, 61, 207, -1, -1,
2177 202, 180, 181, 199, 196, 203, 187, -1, -1, 202,
2178 180, 50, 199, 191, 204, 187, -1, -1, 202, 180,
2179 45, 199, 191, 205, 187, -1, -1, 202, 180, 47,
2180 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
2181 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
2182 -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
2183 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
2184 -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
2185 24, -1, 212, -1, -1, 191, 213, -1, 215, 153,
2186 214, -1, 214, -1, 215, -1, 215, 153, 37, -1,
2187 37, -1, -1, 182, 189, 212, 155, 216, 156, 186,
2188 183, -1, 29, -1, 162, -1, 181, 217, 218, -1,
2189 30, -1, 163, -1, 230, 220, -1, -1, 45, -1,
2190 47, -1, -1, 31, 224, 222, 217, -1, -1, 63,
2191 -1, 3, -1, 4, -1, 7, -1, 27, -1, 28,
2192 -1, 38, -1, 39, -1, 26, -1, 160, 198, 161,
2193 -1, 197, -1, 61, 225, 24, 153, 24, -1, 167,
2194 -1, 212, -1, 227, -1, 226, -1, 191, 228, -1,
2195 230, 231, -1, 219, 231, -1, 232, 180, 234, -1,
2196 232, 236, -1, -1, 23, -1, 77, -1, 78, -1,
2197 72, 229, -1, 72, 8, -1, 73, 21, 228, -1,
2198 73, 9, 228, 153, 21, 228, 153, 21, 228, -1,
2199 74, 178, 228, 153, 21, 228, 157, 235, 159, -1,
2200 74, 178, 228, 153, 21, 228, 157, 159, -1, 75,
2201 182, 189, 228, 155, 239, 156, 36, 21, 228, 233,
2202 21, 228, -1, 233, -1, 76, -1, 235, 178, 226,
2203 153, 21, 228, -1, 178, 226, 153, 21, 228, -1,
2204 180, 241, -1, 191, 157, 228, 153, 228, 159, -1,
2205 237, 153, 157, 228, 153, 228, 159, -1, 229, -1,
2206 238, 153, 229, -1, 238, -1, -1, 60, 59, -1,
2207 59, -1, 169, 191, 228, 153, 228, -1, 170, 191,
2208 228, 153, 228, -1, 171, 191, 228, 153, 228, -1,
2209 103, 172, 191, 228, 153, 228, -1, 104, 173, 191,
2210 228, 153, 228, -1, 49, 229, -1, 174, 229, 153,
2211 229, -1, 175, 229, 36, 191, -1, 112, 229, 153,
2212 229, 153, 229, -1, 113, 229, 153, 191, -1, 117,
2213 229, 153, 191, -1, 118, 229, 153, 191, -1, 114,
2214 229, 153, 229, -1, 115, 229, 153, 229, 153, 229,
2215 -1, 116, 229, 153, 229, 153, 229, -1, 111, 237,
2216 -1, 240, 182, 189, 228, 155, 239, 156, -1, 244,
2217 -1, 153, 238, -1, -1, 35, -1, -1, 105, 191,
2218 184, -1, 105, 191, 153, 15, 228, 184, -1, 106,
2219 191, 184, -1, 106, 191, 153, 15, 228, 184, -1,
2220 107, 229, -1, 243, 108, 191, 228, -1, 243, 109,
2221 229, 153, 191, 228, -1, 110, 191, 228, 242, -1
2224 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2225 static const unsigned short int yyrline[] =
2227 0, 1575, 1575, 1576, 1584, 1585, 1595, 1595, 1595, 1595,
2228 1595, 1595, 1595, 1595, 1595, 1595, 1595, 1599, 1599, 1599,
2229 1603, 1603, 1603, 1603, 1603, 1603, 1607, 1607, 1608, 1608,
2230 1609, 1609, 1610, 1610, 1611, 1611, 1615, 1615, 1616, 1616,
2231 1617, 1617, 1618, 1618, 1619, 1619, 1620, 1620, 1621, 1621,
2232 1622, 1623, 1626, 1626, 1626, 1626, 1630, 1630, 1630, 1630,
2233 1630, 1630, 1630, 1631, 1631, 1631, 1631, 1631, 1631, 1637,
2234 1637, 1637, 1637, 1641, 1641, 1641, 1641, 1645, 1645, 1649,
2235 1649, 1654, 1657, 1662, 1663, 1664, 1665, 1666, 1667, 1668,
2236 1669, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1690,
2237 1691, 1699, 1700, 1708, 1717, 1718, 1725, 1726, 1730, 1734,
2238 1750, 1751, 1758, 1759, 1766, 1774, 1774, 1774, 1774, 1774,
2239 1774, 1774, 1775, 1775, 1775, 1775, 1775, 1780, 1784, 1788,
2240 1793, 1802, 1822, 1828, 1841, 1850, 1854, 1865, 1869, 1882,
2241 1886, 1893, 1894, 1900, 1907, 1919, 1949, 1962, 1985, 2013,
2242 2035, 2046, 2068, 2079, 2088, 2093, 2151, 2158, 2166, 2173,
2243 2180, 2184, 2188, 2197, 2212, 2225, 2234, 2262, 2275, 2284,
2244 2290, 2296, 2307, 2313, 2319, 2330, 2331, 2340, 2341, 2353,
2245 2362, 2363, 2364, 2365, 2366, 2382, 2402, 2404, 2406, 2406,
2246 2413, 2413, 2420, 2420, 2427, 2427, 2435, 2437, 2439, 2444,
2247 2458, 2459, 2463, 2466, 2474, 2478, 2485, 2489, 2493, 2497,
2248 2505, 2505, 2509, 2510, 2514, 2522, 2527, 2535, 2536, 2543,
2249 2550, 2554, 2669, 2669, 2673, 2683, 2683, 2687, 2691, 2693,
2250 2694, 2698, 2698, 2710, 2711, 2716, 2717, 2718, 2719, 2720,
2251 2721, 2722, 2723, 2724, 2745, 2748, 2763, 2764, 2769, 2769,
2252 2777, 2786, 2789, 2798, 2808, 2813, 2822, 2833, 2833, 2836,
2253 2839, 2842, 2846, 2852, 2867, 2873, 2929, 2932, 2938, 2948,
2254 2961, 2990, 2998, 3006, 3010, 3017, 3018, 3022, 3025, 3031,
2255 3048, 3064, 3078, 3090, 3102, 3113, 3131, 3140, 3149, 3156,
2256 3177, 3201, 3207, 3213, 3219, 3235, 3313, 3321, 3322, 3326,
2257 3327, 3331, 3337, 3343, 3349, 3355, 3362, 3374, 3388
2261 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2262 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2263 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2264 static const char *const yytname[] =
2266 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2267 "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2268 "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2269 "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2270 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2271 "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2272 "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2273 "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2274 "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2275 "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2276 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2277 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2278 "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2279 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2280 "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2281 "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2282 "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2283 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2284 "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2285 "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2286 "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2287 "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2288 "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2289 "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2290 "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2291 "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2292 "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2293 "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2294 "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2295 "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2296 "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2297 "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2298 "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2299 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2300 "END", "Function", "FnDeclareLinkage", "FunctionProto", "@5",
2301 "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2302 "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2303 "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2304 "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2305 "OptVolatile", "MemoryInst", 0
2310 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2312 static const unsigned short int yytoknum[] =
2314 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2315 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2316 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2317 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2318 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2319 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2320 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2321 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2322 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2323 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2324 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2325 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
2326 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2327 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2328 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2329 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
2330 60, 62, 123, 125, 42, 99
2334 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2335 static const unsigned char yyr1[] =
2337 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2338 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
2339 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
2340 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
2341 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
2342 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
2343 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
2344 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
2345 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
2346 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
2347 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
2348 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
2349 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
2350 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
2351 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
2352 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
2353 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
2354 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
2355 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
2356 204, 202, 205, 202, 206, 202, 202, 202, 202, 207,
2357 208, 208, 209, 209, 209, 209, 210, 211, 211, 211,
2358 212, 212, 213, 213, 214, 215, 215, 216, 216, 216,
2359 216, 217, 218, 218, 219, 220, 220, 221, 222, 222,
2360 222, 224, 223, 225, 225, 226, 226, 226, 226, 226,
2361 226, 226, 226, 226, 226, 226, 227, 227, 228, 228,
2362 229, 230, 230, 231, 232, 232, 232, 233, 233, 234,
2363 234, 234, 234, 234, 234, 234, 234, 234, 235, 235,
2364 236, 237, 237, 238, 238, 239, 239, 240, 240, 241,
2365 241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
2366 241, 241, 241, 241, 241, 241, 241, 242, 242, 243,
2367 243, 244, 244, 244, 244, 244, 244, 244, 244
2370 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2371 static const unsigned char yyr2[] =
2373 0, 2, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2378 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2379 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2380 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2381 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
2382 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
2383 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
2384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2386 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
2387 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
2388 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
2389 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
2390 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
2391 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
2392 0, 7, 0, 7, 0, 7, 3, 4, 0, 1,
2393 1, 1, 3, 3, 3, 3, 3, 3, 1, 0,
2394 1, 1, 1, 0, 2, 3, 1, 1, 3, 1,
2395 0, 8, 1, 1, 3, 1, 1, 2, 0, 1,
2396 1, 0, 4, 0, 1, 1, 1, 1, 1, 1,
2397 1, 1, 1, 3, 1, 5, 1, 1, 1, 1,
2398 2, 2, 2, 3, 2, 0, 1, 1, 1, 2,
2399 2, 3, 9, 9, 8, 13, 1, 1, 6, 5,
2400 2, 6, 7, 1, 3, 1, 0, 2, 1, 5,
2401 5, 5, 6, 6, 2, 4, 4, 6, 4, 4,
2402 4, 4, 6, 6, 2, 7, 1, 2, 0, 1,
2403 0, 3, 6, 3, 6, 2, 4, 6, 4
2406 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2407 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2408 means the default is an error. */
2409 static const unsigned short int yydefact[] =
2411 198, 0, 90, 184, 1, 183, 231, 83, 84, 85,
2412 86, 87, 88, 89, 0, 91, 255, 180, 181, 255,
2413 210, 211, 0, 0, 0, 90, 0, 186, 228, 0,
2414 0, 92, 93, 94, 95, 96, 97, 0, 0, 256,
2415 252, 82, 225, 226, 227, 251, 0, 0, 0, 0,
2416 196, 0, 0, 0, 0, 0, 0, 0, 81, 229,
2417 230, 91, 199, 182, 98, 2, 3, 111, 115, 116,
2418 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2419 128, 0, 0, 0, 0, 246, 0, 0, 110, 127,
2420 114, 247, 129, 222, 223, 224, 300, 254, 0, 0,
2421 0, 0, 209, 197, 187, 185, 177, 178, 0, 0,
2422 0, 0, 232, 130, 0, 0, 0, 113, 135, 139,
2423 0, 0, 144, 138, 299, 0, 278, 0, 0, 0,
2424 0, 91, 267, 257, 258, 6, 7, 8, 9, 10,
2425 11, 12, 13, 14, 15, 16, 17, 18, 19, 52,
2426 53, 54, 55, 20, 21, 22, 23, 24, 25, 0,
2427 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2428 0, 0, 0, 68, 56, 57, 58, 59, 60, 61,
2429 62, 63, 64, 65, 66, 67, 0, 0, 0, 0,
2430 0, 266, 253, 91, 270, 0, 296, 204, 201, 200,
2431 202, 203, 205, 208, 0, 192, 194, 190, 115, 116,
2432 117, 118, 119, 120, 121, 122, 123, 124, 125, 0,
2433 0, 0, 0, 188, 0, 0, 0, 0, 0, 134,
2434 220, 143, 141, 0, 0, 284, 277, 260, 259, 0,
2435 0, 72, 76, 71, 75, 70, 74, 69, 73, 77,
2436 78, 0, 0, 26, 27, 28, 29, 30, 31, 32,
2437 33, 34, 35, 0, 50, 51, 46, 47, 48, 49,
2438 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
2439 0, 101, 101, 305, 0, 0, 294, 0, 0, 0,
2440 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2441 0, 0, 0, 206, 106, 106, 106, 160, 161, 4,
2442 5, 158, 159, 162, 157, 153, 154, 0, 0, 0,
2443 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2444 0, 0, 0, 156, 155, 106, 112, 112, 137, 0,
2445 140, 219, 213, 216, 217, 0, 0, 131, 235, 236,
2446 237, 242, 238, 239, 240, 241, 233, 0, 244, 249,
2447 248, 250, 0, 261, 0, 0, 0, 0, 0, 301,
2448 0, 303, 298, 0, 0, 0, 0, 0, 0, 0,
2449 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2450 207, 0, 193, 195, 191, 0, 0, 0, 0, 0,
2451 0, 0, 146, 176, 0, 0, 0, 150, 0, 147,
2452 0, 0, 0, 0, 0, 189, 132, 133, 136, 212,
2453 214, 0, 104, 142, 234, 0, 0, 0, 0, 0,
2454 0, 0, 0, 0, 0, 0, 308, 0, 0, 0,
2455 288, 291, 0, 0, 289, 290, 0, 0, 0, 285,
2456 286, 0, 306, 0, 0, 0, 108, 106, 0, 0,
2457 298, 0, 0, 0, 0, 0, 145, 135, 114, 0,
2458 148, 149, 0, 0, 0, 0, 0, 218, 215, 105,
2459 99, 0, 243, 0, 0, 276, 0, 0, 101, 102,
2460 101, 273, 297, 0, 0, 0, 0, 0, 279, 280,
2461 281, 276, 0, 103, 109, 107, 0, 0, 0, 0,
2462 0, 0, 0, 175, 152, 0, 0, 0, 0, 0,
2463 0, 0, 221, 0, 0, 0, 275, 0, 282, 283,
2464 0, 302, 304, 0, 0, 0, 287, 292, 293, 0,
2465 307, 0, 0, 164, 0, 0, 0, 0, 151, 0,
2466 0, 0, 0, 0, 100, 245, 0, 0, 0, 274,
2467 271, 0, 295, 0, 0, 0, 172, 0, 0, 166,
2468 167, 168, 171, 163, 0, 264, 0, 0, 0, 272,
2469 169, 170, 0, 0, 0, 262, 0, 263, 0, 0,
2470 165, 173, 174, 0, 0, 0, 0, 0, 0, 269,
2474 /* YYDEFGOTO[NTERM-NUM]. */
2475 static const short int yydefgoto[] =
2477 -1, 85, 311, 328, 329, 330, 263, 280, 331, 332,
2478 219, 220, 251, 221, 25, 15, 37, 522, 369, 456,
2479 480, 392, 457, 86, 87, 222, 89, 90, 120, 233,
2480 403, 358, 404, 108, 1, 2, 3, 335, 306, 304,
2481 305, 63, 200, 50, 103, 204, 91, 420, 343, 344,
2482 345, 38, 95, 16, 44, 17, 61, 18, 28, 425,
2483 359, 92, 361, 491, 19, 40, 41, 191, 192, 577,
2484 97, 286, 526, 527, 193, 194, 436, 195, 196
2487 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2489 #define YYPACT_NINF -541
2490 static const short int yypact[] =
2492 -541, 28, 61, 478, -541, -541, -541, -541, -541, -541,
2493 -541, -541, -541, -541, 23, 152, 45, -541, -541, -9,
2494 -541, -541, -20, -51, 76, 69, 12, -541, 97, 149,
2495 172, -541, -541, -541, -541, -541, -541, 1331, -19, -541,
2496 -541, 137, -541, -541, -541, -541, 49, 58, 60, 62,
2497 -541, 72, 149, 1331, 88, 88, 88, 88, -541, -541,
2498 -541, 152, -541, -541, -541, -541, -541, 75, -541, -541,
2499 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2500 -541, 227, 228, 3, 691, -541, 137, 79, -541, -541,
2501 -46, -541, -541, -541, -541, -541, 1585, -541, 212, 136,
2502 233, 214, 216, -541, -541, -541, -541, -541, 1392, 1392,
2503 1392, 1433, -541, -541, 83, 87, 711, -541, -541, -46,
2504 -70, 89, 777, -541, -541, 1392, -541, 183, 1453, 6,
2505 309, 152, -541, -541, -541, -541, -541, -541, -541, -541,
2506 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2507 -541, -541, -541, -541, -541, -541, -541, -541, -541, 59,
2508 142, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392, 1392,
2509 1392, 1392, 1392, -541, -541, -541, -541, -541, -541, -541,
2510 -541, -541, -541, -541, -541, -541, 1392, 1392, 1392, 1392,
2511 1392, -541, -541, 152, -541, 86, -541, -541, -541, -541,
2512 -541, -541, -541, -541, -129, -541, -541, -541, 169, 196,
2513 242, 200, 246, 203, 252, 205, 253, 251, 258, 221,
2514 255, 259, 533, -541, 1392, 1392, 99, -63, 1392, -541,
2515 1173, -541, 128, 126, 894, -541, -541, 75, -541, 894,
2516 894, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2517 -541, 894, 1331, -541, -541, -541, -541, -541, -541, -541,
2518 -541, -541, -541, 1392, -541, -541, -541, -541, -541, -541,
2519 -541, -541, -541, -541, -541, -541, -541, -541, -541, -541,
2520 1392, 130, 133, -541, 894, 132, 138, 139, 143, 144,
2521 151, 155, 156, 157, 894, 894, 894, 163, 254, 1331,
2522 1392, 1392, 271, -541, 164, 164, 164, -541, -541, -541,
2523 -541, -541, -541, -541, -541, -541, -541, 59, 142, 173,
2524 174, 175, 176, 177, 1214, 1494, 732, 281, 178, 179,
2525 180, 182, 190, -541, -541, 164, -42, -135, -541, 166,
2526 -46, -541, 137, -541, 193, 191, 1234, -541, -541, -541,
2527 -541, -541, -541, -541, -541, -541, 290, 1433, -541, -541,
2528 -541, -541, 201, -541, 202, 894, 894, 894, 7, -541,
2529 10, -541, 204, 894, 199, 1392, 1392, 1392, 1392, 1392,
2530 1392, 1392, 211, 215, 217, 1392, 1392, 894, 894, 223,
2531 -541, -21, -541, -541, -541, 210, 219, 1433, 1433, 1433,
2532 1433, 1433, -541, -541, 4, 752, -91, -541, -8, -541,
2533 1433, 1433, 1433, 1433, 1433, -541, -541, -541, -541, -541,
2534 -541, 1275, 324, -541, -541, 343, 37, 348, 356, 224,
2535 225, 229, 894, 376, 894, 1392, -541, 230, 894, 232,
2536 -541, -541, 234, 235, -541, -541, 894, 894, 894, -541,
2537 -541, 226, -541, 1392, 362, 385, -541, 164, 1433, 1433,
2538 204, 238, 239, 240, 241, 1433, -541, 243, -17, -5,
2539 -541, -541, 247, 250, 261, 262, 359, -541, -541, -541,
2540 339, 268, -541, 894, 894, 1392, 894, 894, 269, -541,
2541 269, -541, 270, 894, 272, 1392, 1392, 1392, -541, -541,
2542 -541, 1392, 894, -541, -541, -541, 273, 274, 249, 1433,
2543 1433, 1433, 1433, -541, -541, 245, 1433, 1433, 1433, 1433,
2544 1392, 395, -541, 383, 275, 267, 270, 279, -541, -541,
2545 351, -541, -541, 1392, 277, 894, -541, -541, -541, 282,
2546 -541, 1433, 1433, -541, 278, 283, 284, 288, -541, 289,
2547 291, 295, 296, 297, -541, -541, 423, 43, 410, -541,
2548 -541, 298, -541, 300, 305, 1433, -541, 1433, 1433, -541,
2549 -541, -541, -541, -541, 894, -541, 1020, 64, 441, -541,
2550 -541, -541, 307, 311, 314, -541, 312, -541, 1020, 894,
2551 -541, -541, -541, 450, 319, 150, 894, 452, 453, -541,
2552 894, 894, -541, -541
2555 /* YYPGOTO[NTERM-NUM]. */
2556 static const short int yypgoto[] =
2558 -541, -541, -541, 379, 380, 381, 161, 162, 386, 388,
2559 -128, -127, -540, -541, 438, 456, -111, -541, -277, 63,
2560 -541, -297, -541, -47, -541, -37, -541, -53, 40, -541,
2561 -99, 264, -307, 84, -541, -541, -541, -541, -541, -541,
2562 -541, 435, -541, -541, -541, -541, 8, -541, 68, -541,
2563 -541, 427, -541, -541, -541, -541, -541, 487, -541, -541,
2564 -489, -199, 67, -124, -541, 472, -541, -103, -541, -541,
2565 -541, -541, 71, -7, -541, -541, 33, -541, -541
2568 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2569 positive, shift that token. If negative, reduce the rule which
2570 number is the opposite. If zero, do what YYDEFACT says.
2571 If YYTABLE_NINF, syntax error. */
2572 #define YYTABLE_NINF -180
2573 static const short int yytable[] =
2575 88, 235, 249, 250, 238, 371, 105, 115, 393, 394,
2576 93, 26, 223, 454, 39, 239, 88, 576, 406, 408,
2577 252, 42, 432, 334, 302, 434, 417, 240, 4, 123,
2578 303, 119, 46, 47, 48, 360, 455, 588, 415, 283,
2579 360, 360, 287, 288, 289, 290, 291, 292, 293, 26,
2580 426, 49, 360, 241, 242, 243, 244, 245, 246, 247,
2581 248, -179, 465, 119, 433, 297, 298, 433, 39, 119,
2582 470, 205, 206, 207, 241, 242, 243, 244, 245, 246,
2583 247, 248, 299, 228, 29, 360, 5, 586, 234, 53,
2584 228, 234, 6, 229, 121, 360, 360, 360, 469, 594,
2585 339, 51, 7, 8, 9, 10, 11, 12, 13, -112,
2586 7, 8, 9, 10, 54, 12, 55, 416, 123, 56,
2587 106, 107, 123, 14, 281, 282, 234, 284, 285, 234,
2588 234, 234, 234, 234, 234, 234, -139, 52, -112, 109,
2589 110, 111, 59, 94, 60, 465, -139, 123, 465, 294,
2590 295, 296, 234, 234, 43, 471, 227, 465, 515, 20,
2591 505, 21, 232, 466, 58, 116, 360, 360, 360, 264,
2592 265, 336, 337, 62, 360, 340, 64, 389, 253, 254,
2593 255, 256, 257, 258, 259, 260, 261, 262, 360, 360,
2594 465, 198, 199, 342, 300, 301, 307, 308, 482, -72,
2595 -72, 98, 575, -71, -71, 365, -70, -70, -69, -69,
2596 99, 531, 100, 532, 101, 88, 30, 31, 32, 33,
2597 34, 35, 36, 587, 309, 310, 366, 133, 134, 102,
2598 -113, 113, 114, 360, 122, 360, 197, 201, 202, 360,
2599 203, 224, 236, 367, 230, 225, -76, 360, 360, 360,
2600 -75, 439, 387, 441, 442, 443, -74, -73, -79, 312,
2601 338, 449, 88, 388, 234, -80, 313, 266, 267, 268,
2602 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2603 279, 346, 347, 368, 360, 360, 370, 360, 360, 373,
2604 386, 374, 375, 340, 360, 390, 376, 377, 460, 461,
2605 462, 463, 464, 360, 378, 409, 362, 363, 379, 380,
2606 381, 472, 473, 474, 475, 476, 385, 391, 364, 241,
2607 242, 243, 244, 245, 246, 247, 248, 418, 397, 398,
2608 399, 400, 401, 410, 411, 412, 360, 413, 234, 440,
2609 234, 234, 234, 444, 445, 414, 421, 422, 234, 450,
2610 419, 372, 468, 424, 427, 428, 438, 435, 454, 506,
2611 507, 382, 383, 384, 446, 458, 513, 481, 447, 483,
2612 448, 536, 537, 538, 459, 360, 453, 484, 486, 485,
2613 489, 501, 487, 493, 342, 495, 503, 496, 497, 504,
2614 360, 509, 510, 511, 512, 520, 521, 360, 234, 554,
2615 516, 360, 360, 517, 514, 543, 548, 555, 433, 559,
2616 544, 545, 546, 547, 518, 519, 502, 549, 550, 551,
2617 552, 523, 530, 533, 557, 535, 541, 542, 556, 249,
2618 250, 565, 429, 430, 431, 558, 560, 567, 562, 566,
2619 437, 568, 563, 564, 574, 569, 578, 570, 234, 249,
2620 250, 571, 572, 573, 451, 452, 580, 579, 234, 234,
2621 234, 581, 589, 590, 234, 593, 582, 591, 583, 584,
2622 592, 596, 597, 600, 601, 186, 187, 188, 395, 96,
2623 396, 57, 189, 553, 190, 479, 333, 104, 112, 478,
2624 27, 45, 598, 508, 539, 0, 234, 0, -82, 488,
2625 20, 490, 21, 0, 0, 494, 492, 0, 0, 6,
2626 -82, -82, 0, 498, 499, 500, 0, 0, 0, -82,
2627 -82, -82, -82, -82, -82, -82, 0, 0, -82, 22,
2628 0, 0, 0, 0, 0, 0, 23, 0, 65, 66,
2629 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2630 524, 525, 0, 528, 529, 20, 0, 21, 0, 314,
2631 534, 0, 0, 0, 0, 0, 0, 0, 0, 540,
2632 0, 315, 316, 0, 0, 0, 0, 0, 0, 0,
2633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2635 0, 0, 561, 0, 0, 0, 0, 0, 0, 0,
2636 0, 0, 135, 136, 137, 138, 139, 140, 141, 142,
2637 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
2638 153, 154, 155, 156, 157, 158, 317, 318, 0, 0,
2639 0, 585, 0, 319, 0, 320, 0, 321, 322, 323,
2640 0, 0, 0, 0, 0, 0, 595, 0, 0, 0,
2641 0, 0, 0, 599, 0, 0, 0, 602, 603, 0,
2642 0, 0, 173, 174, 175, 176, 177, 178, 179, 180,
2643 181, 182, 183, 184, 185, 0, 0, 0, 0, 0,
2644 324, 0, 0, 325, 0, 326, 65, 66, 327, 117,
2645 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2646 78, 0, 79, 20, 0, 21, 65, 66, 0, 117,
2647 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2648 78, 0, 79, 20, 0, 21, 0, 65, 66, 80,
2649 117, 208, 209, 210, 211, 212, 213, 214, 215, 216,
2650 217, 218, 0, 79, 20, 0, 21, 65, 66, 80,
2651 117, 208, 209, 210, 211, 212, 213, 214, 215, 216,
2652 217, 218, 0, 79, 20, 0, 21, 0, 0, 0,
2653 80, 0, 65, 66, 0, 117, 68, 69, 70, 71,
2654 72, 73, 74, 75, 76, 77, 78, 0, 79, 20,
2655 80, 21, 0, 0, 0, 0, 0, 0, 0, 0,
2656 0, 0, 0, 0, 231, 0, 0, 0, 0, 0,
2657 0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
2658 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2659 0, 0, 0, 0, 0, 81, 0, 0, 82, 0,
2660 0, 83, 0, 84, 118, 0, 0, 0, 0, 0,
2661 0, 0, 0, 0, 0, 81, 0, 0, 82, 0,
2662 0, 83, 0, 84, 226, 0, 0, 0, 0, 0,
2663 0, 0, 0, 0, 0, 0, 81, 0, 0, 82,
2664 0, 0, 83, 0, 84, 407, 0, 348, 349, 65,
2665 66, 350, 0, 0, 0, 0, 81, 0, 0, 82,
2666 0, 0, 83, 0, 84, 467, 20, 0, 21, 0,
2667 351, 352, 353, 0, 0, 0, 0, 0, 0, 0,
2668 0, 81, 354, 355, 82, 0, 0, 83, 0, 84,
2669 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2670 0, 0, 0, 0, 0, 356, 0, 0, 0, 0,
2671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2672 0, 0, 0, 135, 136, 137, 138, 139, 140, 141,
2673 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
2674 152, 153, 154, 155, 156, 157, 158, 317, 318, 0,
2675 0, 0, 0, 0, 319, 0, 320, 0, 321, 322,
2676 323, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2677 0, 0, 0, 348, 349, 0, 0, 350, 0, 0,
2678 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
2679 180, 181, 182, 183, 184, 185, 351, 352, 353, 0,
2680 0, 0, 0, 0, 357, 0, 0, 0, 354, 355,
2681 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2682 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2683 0, 356, 0, 0, 0, 0, 0, 0, 0, 0,
2684 0, 0, 0, 0, 0, 0, 0, 0, 0, 135,
2685 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
2686 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2687 156, 157, 158, 317, 318, 0, 0, 0, 0, 0,
2688 319, 0, 320, 0, 321, 322, 323, 0, 0, 0,
2689 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2690 0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2691 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2692 184, 185, 0, 0, 0, 0, 0, 0, 65, 66,
2693 357, 117, 68, 69, 70, 71, 72, 73, 74, 75,
2694 76, 77, 78, 0, 79, 20, 0, 21, 0, 0,
2695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2696 341, 0, 0, 0, 0, 0, 0, 0, 0, 65,
2697 66, 80, 117, 208, 209, 210, 211, 212, 213, 214,
2698 215, 216, 217, 218, 0, 79, 20, 0, 21, 65,
2699 66, 0, 117, 68, 69, 70, 71, 72, 73, 74,
2700 75, 76, 77, 78, 0, 79, 20, 0, 21, 0,
2701 0, 0, 80, 0, 0, 0, 0, 0, 0, 0,
2702 0, 423, 0, 0, 0, 0, 0, 0, 0, 0,
2703 65, 66, 80, 117, 68, 69, 70, 71, 72, 73,
2704 74, 75, 76, 77, 78, 0, 79, 20, 0, 21,
2705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2706 0, 0, 477, 0, 0, 0, 0, 0, 0, 0,
2707 0, 0, 0, 80, 0, 0, 0, 81, 0, 0,
2708 82, 0, 0, 83, 0, 84, 65, 66, 0, 67,
2709 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2710 78, 0, 79, 20, 0, 21, 0, 0, 0, 0,
2711 0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
2712 0, 82, 0, 402, 83, 0, 84, 0, 0, 80,
2713 0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
2714 0, 82, 0, 0, 83, 0, 84, 65, 66, 0,
2715 117, 68, 69, 70, 71, 72, 73, 74, 75, 76,
2716 77, 78, 0, 79, 20, 0, 21, 0, 0, 0,
2717 0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
2718 0, 0, 82, 0, 0, 83, 0, 84, 65, 66,
2719 80, 117, 208, 209, 210, 211, 212, 213, 214, 215,
2720 216, 217, 218, 0, 79, 20, 0, 21, 65, 66,
2721 0, 237, 68, 69, 70, 71, 72, 73, 74, 75,
2722 76, 77, 78, 0, 79, 20, 0, 21, 0, 0,
2723 0, 80, 0, 0, 0, 81, 0, 0, 82, 0,
2724 0, 83, 0, 84, 0, 0, 0, 0, 0, 65,
2725 66, 80, 117, 208, 209, 210, 211, 212, 213, 214,
2726 215, 216, 217, 218, 0, 79, 20, 0, 21, 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, 80, 0, 0, 0, 81, 0, 0, 82,
2730 0, 0, 83, 0, 84, 0, 0, 0, 0, 0,
2731 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2732 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2733 0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
2734 82, 0, 0, 83, 0, 84, 0, 0, 0, 0,
2735 0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
2736 82, 0, 0, 83, 0, 84, 0, 0, 0, 0,
2737 124, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2738 0, 0, 0, 0, 125, 0, 0, 0, 0, 0,
2739 0, 0, 0, 0, 126, 127, 0, 0, 81, 0,
2740 0, 82, 0, 0, 83, 0, 405, 128, 129, 130,
2741 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
2742 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2743 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
2744 161, 162, 163, 0, 0, 164, 165, 166, 167, 168,
2745 169, 170, 171, 172, 0, 0, 0, 0, 0, 0,
2746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747 0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2748 179, 180, 181, 182, 183, 184, 185
2751 static const short int yycheck[] =
2753 37, 125, 130, 130, 128, 282, 53, 4, 305, 306,
2754 29, 3, 111, 34, 23, 9, 53, 557, 325, 326,
2755 131, 30, 15, 222, 153, 15, 161, 21, 0, 164,
2756 159, 84, 52, 53, 54, 234, 57, 577, 335, 163,
2757 239, 240, 166, 167, 168, 169, 170, 171, 172, 41,
2758 357, 71, 251, 10, 11, 12, 13, 14, 15, 16,
2759 17, 0, 153, 116, 57, 189, 190, 57, 23, 122,
2760 161, 108, 109, 110, 10, 11, 12, 13, 14, 15,
2761 16, 17, 193, 153, 61, 284, 25, 576, 125, 20,
2762 153, 128, 31, 163, 86, 294, 295, 296, 405, 588,
2763 163, 152, 41, 42, 43, 44, 45, 46, 47, 155,
2764 41, 42, 43, 44, 45, 46, 47, 159, 164, 50,
2765 32, 33, 164, 62, 161, 162, 163, 164, 165, 166,
2766 167, 168, 169, 170, 171, 172, 153, 61, 155, 55,
2767 56, 57, 45, 162, 47, 153, 163, 164, 153, 186,
2768 187, 188, 189, 190, 163, 163, 116, 153, 163, 22,
2769 457, 24, 122, 159, 152, 162, 365, 366, 367, 27,
2770 28, 224, 225, 24, 373, 228, 4, 301, 119, 120,
2771 121, 122, 123, 124, 125, 126, 127, 128, 387, 388,
2772 153, 55, 56, 230, 108, 109, 27, 28, 161, 3,
2773 4, 152, 159, 3, 4, 252, 3, 4, 3, 4,
2774 152, 488, 152, 490, 152, 252, 64, 65, 66, 67,
2775 68, 69, 70, 159, 3, 4, 263, 77, 78, 157,
2776 155, 4, 4, 432, 155, 434, 24, 4, 24, 438,
2777 24, 158, 59, 280, 155, 158, 4, 446, 447, 448,
2778 4, 375, 299, 377, 378, 379, 4, 4, 7, 4,
2779 161, 385, 299, 300, 301, 7, 7, 125, 126, 127,
2780 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
2781 138, 153, 156, 153, 483, 484, 153, 486, 487, 157,
2782 36, 153, 153, 346, 493, 24, 153, 153, 397, 398,
2783 399, 400, 401, 502, 153, 24, 239, 240, 153, 153,
2784 153, 410, 411, 412, 413, 414, 153, 153, 251, 10,
2785 11, 12, 13, 14, 15, 16, 17, 161, 155, 155,
2786 155, 155, 155, 155, 155, 155, 535, 155, 375, 376,
2787 377, 378, 379, 380, 381, 155, 153, 156, 385, 386,
2788 342, 284, 405, 63, 153, 153, 157, 153, 34, 458,
2789 459, 294, 295, 296, 153, 155, 465, 24, 153, 21,
2790 153, 495, 496, 497, 155, 574, 153, 21, 153, 155,
2791 4, 155, 153, 153, 421, 153, 24, 153, 153, 4,
2792 589, 153, 153, 153, 153, 36, 57, 596, 435, 4,
2793 153, 600, 601, 153, 161, 156, 161, 24, 57, 533,
2794 509, 510, 511, 512, 153, 153, 453, 516, 517, 518,
2795 519, 153, 153, 153, 157, 153, 153, 153, 153, 557,
2796 557, 153, 365, 366, 367, 156, 159, 153, 156, 156,
2797 373, 153, 541, 542, 21, 156, 36, 156, 485, 577,
2798 577, 156, 156, 156, 387, 388, 156, 159, 495, 496,
2799 497, 156, 21, 156, 501, 153, 565, 156, 567, 568,
2800 156, 21, 153, 21, 21, 96, 96, 96, 317, 41,
2801 318, 25, 96, 520, 96, 422, 222, 52, 61, 421,
2802 3, 19, 595, 460, 501, -1, 533, -1, 20, 432,
2803 22, 434, 24, -1, -1, 438, 435, -1, -1, 31,
2804 32, 33, -1, 446, 447, 448, -1, -1, -1, 41,
2805 42, 43, 44, 45, 46, 47, -1, -1, 50, 51,
2806 -1, -1, -1, -1, -1, -1, 58, -1, 5, 6,
2807 62, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2808 483, 484, -1, 486, 487, 22, -1, 24, -1, 26,
2809 493, -1, -1, -1, -1, -1, -1, -1, -1, 502,
2810 -1, 38, 39, -1, -1, -1, -1, -1, -1, -1,
2811 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2812 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2813 -1, -1, 535, -1, -1, -1, -1, -1, -1, -1,
2814 -1, -1, 79, 80, 81, 82, 83, 84, 85, 86,
2815 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
2816 97, 98, 99, 100, 101, 102, 103, 104, -1, -1,
2817 -1, 574, -1, 110, -1, 112, -1, 114, 115, 116,
2818 -1, -1, -1, -1, -1, -1, 589, -1, -1, -1,
2819 -1, -1, -1, 596, -1, -1, -1, 600, 601, -1,
2820 -1, -1, 139, 140, 141, 142, 143, 144, 145, 146,
2821 147, 148, 149, 150, 151, -1, -1, -1, -1, -1,
2822 157, -1, -1, 160, -1, 162, 5, 6, 165, 8,
2823 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2824 19, -1, 21, 22, -1, 24, 5, 6, -1, 8,
2825 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2826 19, -1, 21, 22, -1, 24, -1, 5, 6, 48,
2827 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2828 18, 19, -1, 21, 22, -1, 24, 5, 6, 48,
2829 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2830 18, 19, -1, 21, 22, -1, 24, -1, -1, -1,
2831 48, -1, 5, 6, -1, 8, 9, 10, 11, 12,
2832 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
2833 48, 24, -1, -1, -1, -1, -1, -1, -1, -1,
2834 -1, -1, -1, -1, 37, -1, -1, -1, -1, -1,
2835 -1, -1, -1, -1, -1, 48, -1, -1, -1, -1,
2836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2837 -1, -1, -1, -1, -1, 154, -1, -1, 157, -1,
2838 -1, 160, -1, 162, 163, -1, -1, -1, -1, -1,
2839 -1, -1, -1, -1, -1, 154, -1, -1, 157, -1,
2840 -1, 160, -1, 162, 163, -1, -1, -1, -1, -1,
2841 -1, -1, -1, -1, -1, -1, 154, -1, -1, 157,
2842 -1, -1, 160, -1, 162, 163, -1, 3, 4, 5,
2843 6, 7, -1, -1, -1, -1, 154, -1, -1, 157,
2844 -1, -1, 160, -1, 162, 163, 22, -1, 24, -1,
2845 26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
2846 -1, 154, 38, 39, 157, -1, -1, 160, -1, 162,
2847 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2848 -1, -1, -1, -1, -1, 61, -1, -1, -1, -1,
2849 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2850 -1, -1, -1, 79, 80, 81, 82, 83, 84, 85,
2851 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
2852 96, 97, 98, 99, 100, 101, 102, 103, 104, -1,
2853 -1, -1, -1, -1, 110, -1, 112, -1, 114, 115,
2854 116, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2855 -1, -1, -1, 3, 4, -1, -1, 7, -1, -1,
2856 -1, -1, -1, 139, 140, 141, 142, 143, 144, 145,
2857 146, 147, 148, 149, 150, 151, 26, 27, 28, -1,
2858 -1, -1, -1, -1, 160, -1, -1, -1, 38, 39,
2859 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2860 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2861 -1, 61, -1, -1, -1, -1, -1, -1, -1, -1,
2862 -1, -1, -1, -1, -1, -1, -1, -1, -1, 79,
2863 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
2864 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
2865 100, 101, 102, 103, 104, -1, -1, -1, -1, -1,
2866 110, -1, 112, -1, 114, 115, 116, -1, -1, -1,
2867 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2868 -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
2869 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
2870 150, 151, -1, -1, -1, -1, -1, -1, 5, 6,
2871 160, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2872 17, 18, 19, -1, 21, 22, -1, 24, -1, -1,
2873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2874 37, -1, -1, -1, -1, -1, -1, -1, -1, 5,
2875 6, 48, 8, 9, 10, 11, 12, 13, 14, 15,
2876 16, 17, 18, 19, -1, 21, 22, -1, 24, 5,
2877 6, -1, 8, 9, 10, 11, 12, 13, 14, 15,
2878 16, 17, 18, 19, -1, 21, 22, -1, 24, -1,
2879 -1, -1, 48, -1, -1, -1, -1, -1, -1, -1,
2880 -1, 37, -1, -1, -1, -1, -1, -1, -1, -1,
2881 5, 6, 48, 8, 9, 10, 11, 12, 13, 14,
2882 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
2883 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2884 -1, -1, 37, -1, -1, -1, -1, -1, -1, -1,
2885 -1, -1, -1, 48, -1, -1, -1, 154, -1, -1,
2886 157, -1, -1, 160, -1, 162, 5, 6, -1, 8,
2887 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2888 19, -1, 21, 22, -1, 24, -1, -1, -1, -1,
2889 -1, -1, -1, -1, -1, -1, -1, -1, 154, -1,
2890 -1, 157, -1, 159, 160, -1, 162, -1, -1, 48,
2891 -1, -1, -1, -1, -1, -1, -1, -1, 154, -1,
2892 -1, 157, -1, -1, 160, -1, 162, 5, 6, -1,
2893 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2894 18, 19, -1, 21, 22, -1, 24, -1, -1, -1,
2895 -1, -1, -1, -1, -1, -1, -1, -1, -1, 154,
2896 -1, -1, 157, -1, -1, 160, -1, 162, 5, 6,
2897 48, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2898 17, 18, 19, -1, 21, 22, -1, 24, 5, 6,
2899 -1, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2900 17, 18, 19, -1, 21, 22, -1, 24, -1, -1,
2901 -1, 48, -1, -1, -1, 154, -1, -1, 157, -1,
2902 -1, 160, -1, 162, -1, -1, -1, -1, -1, 5,
2903 6, 48, 8, 9, 10, 11, 12, 13, 14, 15,
2904 16, 17, 18, 19, -1, 21, 22, -1, 24, -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, 48, -1, -1, -1, 154, -1, -1, 157,
2908 -1, -1, 160, -1, 162, -1, -1, -1, -1, -1,
2909 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2910 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2911 -1, -1, -1, -1, -1, -1, -1, 154, -1, -1,
2912 157, -1, -1, 160, -1, 162, -1, -1, -1, -1,
2913 -1, -1, -1, -1, -1, -1, -1, 154, -1, -1,
2914 157, -1, -1, 160, -1, 162, -1, -1, -1, -1,
2915 35, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2916 -1, -1, -1, -1, 49, -1, -1, -1, -1, -1,
2917 -1, -1, -1, -1, 59, 60, -1, -1, 154, -1,
2918 -1, 157, -1, -1, 160, -1, 162, 72, 73, 74,
2919 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2920 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2921 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2922 105, 106, 107, -1, -1, 110, 111, 112, 113, 114,
2923 115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
2924 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2925 -1, -1, -1, -1, 139, 140, 141, 142, 143, 144,
2926 145, 146, 147, 148, 149, 150, 151
2929 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2930 symbol of state STATE-NUM. */
2931 static const unsigned char yystos[] =
2933 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
2934 44, 45, 46, 47, 62, 181, 219, 221, 223, 230,
2935 22, 24, 51, 58, 62, 180, 212, 223, 224, 61,
2936 64, 65, 66, 67, 68, 69, 70, 182, 217, 23,
2937 231, 232, 30, 163, 220, 231, 52, 53, 54, 71,
2938 209, 152, 61, 20, 45, 47, 50, 181, 152, 45,
2939 47, 222, 24, 207, 4, 5, 6, 8, 9, 10,
2940 11, 12, 13, 14, 15, 16, 17, 18, 19, 21,
2941 48, 154, 157, 160, 162, 167, 189, 190, 191, 192,
2942 193, 212, 227, 29, 162, 218, 180, 236, 152, 152,
2943 152, 152, 157, 210, 207, 189, 32, 33, 199, 199,
2944 199, 199, 217, 4, 4, 4, 162, 8, 163, 193,
2945 194, 212, 155, 164, 35, 49, 59, 60, 72, 73,
2946 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2947 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2948 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
2949 104, 105, 106, 107, 110, 111, 112, 113, 114, 115,
2950 116, 117, 118, 139, 140, 141, 142, 143, 144, 145,
2951 146, 147, 148, 149, 150, 151, 169, 170, 171, 174,
2952 175, 233, 234, 240, 241, 243, 244, 24, 55, 56,
2953 208, 4, 24, 24, 211, 191, 191, 191, 9, 10,
2954 11, 12, 13, 14, 15, 16, 17, 18, 19, 176,
2955 177, 179, 191, 196, 158, 158, 163, 194, 153, 163,
2956 155, 37, 194, 195, 191, 229, 59, 8, 229, 9,
2957 21, 10, 11, 12, 13, 14, 15, 16, 17, 176,
2958 177, 178, 182, 119, 120, 121, 122, 123, 124, 125,
2959 126, 127, 128, 172, 27, 28, 125, 126, 127, 128,
2960 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2961 173, 191, 191, 229, 191, 191, 237, 229, 229, 229,
2962 229, 229, 229, 229, 191, 191, 191, 229, 229, 182,
2963 108, 109, 153, 159, 205, 206, 204, 27, 28, 3,
2964 4, 168, 4, 7, 26, 38, 39, 103, 104, 110,
2965 112, 114, 115, 116, 157, 160, 162, 165, 169, 170,
2966 171, 174, 175, 197, 227, 203, 193, 193, 161, 163,
2967 193, 37, 191, 214, 215, 216, 153, 156, 3, 4,
2968 7, 26, 27, 28, 38, 39, 61, 160, 197, 226,
2969 227, 228, 228, 228, 228, 189, 191, 191, 153, 184,
2970 153, 184, 228, 157, 153, 153, 153, 153, 153, 153,
2971 153, 153, 228, 228, 228, 153, 36, 189, 191, 229,
2972 24, 153, 187, 187, 187, 172, 173, 155, 155, 155,
2973 155, 155, 159, 196, 198, 162, 198, 163, 198, 24,
2974 155, 155, 155, 155, 155, 187, 159, 161, 161, 212,
2975 213, 153, 156, 37, 63, 225, 198, 153, 153, 228,
2976 228, 228, 15, 57, 15, 153, 242, 228, 157, 229,
2977 191, 229, 229, 229, 191, 191, 153, 153, 153, 229,
2978 191, 228, 228, 153, 34, 57, 185, 188, 155, 155,
2979 196, 196, 196, 196, 196, 153, 159, 163, 193, 198,
2980 161, 163, 196, 196, 196, 196, 196, 37, 214, 185,
2981 186, 24, 161, 21, 21, 155, 153, 153, 228, 4,
2982 228, 229, 238, 153, 228, 153, 153, 153, 228, 228,
2983 228, 155, 191, 24, 4, 187, 196, 196, 242, 153,
2984 153, 153, 153, 196, 161, 163, 153, 153, 153, 153,
2985 36, 57, 183, 153, 228, 228, 238, 239, 228, 228,
2986 153, 184, 184, 153, 228, 153, 229, 229, 229, 239,
2987 228, 153, 153, 156, 196, 196, 196, 196, 161, 196,
2988 196, 196, 196, 191, 4, 24, 153, 157, 156, 229,
2989 159, 228, 156, 196, 196, 153, 156, 153, 153, 156,
2990 156, 156, 156, 156, 21, 159, 178, 235, 36, 159,
2991 156, 156, 196, 196, 196, 228, 226, 159, 178, 21,
2992 156, 156, 156, 153, 226, 228, 21, 153, 233, 228,
2996 #define yyerrok (yyerrstatus = 0)
2997 #define yyclearin (yychar = YYEMPTY)
2998 #define YYEMPTY (-2)
3001 #define YYACCEPT goto yyacceptlab
3002 #define YYABORT goto yyabortlab
3003 #define YYERROR goto yyerrorlab
3006 /* Like YYERROR except do call yyerror. This remains here temporarily
3007 to ease the transition to the new meaning of YYERROR, for GCC.
3008 Once GCC version 2 has supplanted version 1, this can go. */
3010 #define YYFAIL goto yyerrlab
3012 #define YYRECOVERING() (!!yyerrstatus)
3014 #define YYBACKUP(Token, Value) \
3016 if (yychar == YYEMPTY && yylen == 1) \
3020 yytoken = YYTRANSLATE (yychar); \
3026 yyerror (YY_("syntax error: cannot back up")); \
3033 #define YYERRCODE 256
3036 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3037 If N is 0, then set CURRENT to the empty location which ends
3038 the previous symbol: RHS[0] (always defined). */
3040 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3041 #ifndef YYLLOC_DEFAULT
3042 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3046 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3047 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3048 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3049 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3053 (Current).first_line = (Current).last_line = \
3054 YYRHSLOC (Rhs, 0).last_line; \
3055 (Current).first_column = (Current).last_column = \
3056 YYRHSLOC (Rhs, 0).last_column; \
3062 /* YY_LOCATION_PRINT -- Print the location on the stream.
3063 This macro was not mandated originally: define only if we know
3064 we won't break user code: when these are the locations we know. */
3066 #ifndef YY_LOCATION_PRINT
3067 # if YYLTYPE_IS_TRIVIAL
3068 # define YY_LOCATION_PRINT(File, Loc) \
3069 fprintf (File, "%d.%d-%d.%d", \
3070 (Loc).first_line, (Loc).first_column, \
3071 (Loc).last_line, (Loc).last_column)
3073 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3078 /* YYLEX -- calling `yylex' with the right arguments. */
3081 # define YYLEX yylex (YYLEX_PARAM)
3083 # define YYLEX yylex ()
3086 /* Enable debugging if requested. */
3090 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3091 # define YYFPRINTF fprintf
3094 # define YYDPRINTF(Args) \
3100 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3104 YYFPRINTF (stderr, "%s ", Title); \
3105 yysymprint (stderr, \
3107 YYFPRINTF (stderr, "\n"); \
3111 /*------------------------------------------------------------------.
3112 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3114 `------------------------------------------------------------------*/
3116 #if defined (__STDC__) || defined (__cplusplus)
3118 yy_stack_print (short int *bottom, short int *top)
3121 yy_stack_print (bottom, top)
3126 YYFPRINTF (stderr, "Stack now");
3127 for (/* Nothing. */; bottom <= top; ++bottom)
3128 YYFPRINTF (stderr, " %d", *bottom);
3129 YYFPRINTF (stderr, "\n");
3132 # define YY_STACK_PRINT(Bottom, Top) \
3135 yy_stack_print ((Bottom), (Top)); \
3139 /*------------------------------------------------.
3140 | Report that the YYRULE is going to be reduced. |
3141 `------------------------------------------------*/
3143 #if defined (__STDC__) || defined (__cplusplus)
3145 yy_reduce_print (int yyrule)
3148 yy_reduce_print (yyrule)
3153 unsigned long int yylno = yyrline[yyrule];
3154 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3156 /* Print the symbols being reduced, and their result. */
3157 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3158 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3159 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3162 # define YY_REDUCE_PRINT(Rule) \
3165 yy_reduce_print (Rule); \
3168 /* Nonzero means print parse trace. It is left uninitialized so that
3169 multiple parsers can coexist. */
3171 #else /* !YYDEBUG */
3172 # define YYDPRINTF(Args)
3173 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3174 # define YY_STACK_PRINT(Bottom, Top)
3175 # define YY_REDUCE_PRINT(Rule)
3176 #endif /* !YYDEBUG */
3179 /* YYINITDEPTH -- initial size of the parser's stacks. */
3181 # define YYINITDEPTH 200
3184 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3185 if the built-in stack extension method is used).
3187 Do not make this value too large; the results are undefined if
3188 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3189 evaluated with infinite-precision integer arithmetic. */
3192 # define YYMAXDEPTH 10000
3200 # if defined (__GLIBC__) && defined (_STRING_H)
3201 # define yystrlen strlen
3203 /* Return the length of YYSTR. */
3205 # if defined (__STDC__) || defined (__cplusplus)
3206 yystrlen (const char *yystr)
3212 const char *yys = yystr;
3214 while (*yys++ != '\0')
3217 return yys - yystr - 1;
3223 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3224 # define yystpcpy stpcpy
3226 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3229 # if defined (__STDC__) || defined (__cplusplus)
3230 yystpcpy (char *yydest, const char *yysrc)
3232 yystpcpy (yydest, yysrc)
3238 const char *yys = yysrc;
3240 while ((*yyd++ = *yys++) != '\0')
3249 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3250 quotes and backslashes, so that it's suitable for yyerror. The
3251 heuristic is that double-quoting is unnecessary unless the string
3252 contains an apostrophe, a comma, or backslash (other than
3253 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3254 null, do not copy; instead, return the length of what the result
3257 yytnamerr (char *yyres, const char *yystr)
3262 char const *yyp = yystr;
3269 goto do_not_strip_quotes;
3273 goto do_not_strip_quotes;
3286 do_not_strip_quotes: ;
3290 return yystrlen (yystr);
3292 return yystpcpy (yyres, yystr) - yyres;
3296 #endif /* YYERROR_VERBOSE */
3301 /*--------------------------------.
3302 | Print this symbol on YYOUTPUT. |
3303 `--------------------------------*/
3305 #if defined (__STDC__) || defined (__cplusplus)
3307 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3310 yysymprint (yyoutput, yytype, yyvaluep)
3316 /* Pacify ``unused variable'' warnings. */
3319 if (yytype < YYNTOKENS)
3320 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3322 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3326 if (yytype < YYNTOKENS)
3327 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3334 YYFPRINTF (yyoutput, ")");
3337 #endif /* ! YYDEBUG */
3338 /*-----------------------------------------------.
3339 | Release the memory associated to this symbol. |
3340 `-----------------------------------------------*/
3342 #if defined (__STDC__) || defined (__cplusplus)
3344 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3347 yydestruct (yymsg, yytype, yyvaluep)
3353 /* Pacify ``unused variable'' warnings. */
3358 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3369 /* Prevent warnings from -Wmissing-prototypes. */
3371 #ifdef YYPARSE_PARAM
3372 # if defined (__STDC__) || defined (__cplusplus)
3373 int yyparse (void *YYPARSE_PARAM);
3377 #else /* ! YYPARSE_PARAM */
3378 #if defined (__STDC__) || defined (__cplusplus)
3383 #endif /* ! YYPARSE_PARAM */
3387 /* The look-ahead symbol. */
3390 /* The semantic value of the look-ahead symbol. */
3393 /* Number of syntax errors so far. */
3402 #ifdef YYPARSE_PARAM
3403 # if defined (__STDC__) || defined (__cplusplus)
3404 int yyparse (void *YYPARSE_PARAM)
3406 int yyparse (YYPARSE_PARAM)
3407 void *YYPARSE_PARAM;
3409 #else /* ! YYPARSE_PARAM */
3410 #if defined (__STDC__) || defined (__cplusplus)
3424 /* Number of tokens to shift before error messages enabled. */
3426 /* Look-ahead token as an internal (translated) token number. */
3429 /* Three stacks and their tools:
3430 `yyss': related to states,
3431 `yyvs': related to semantic values,
3432 `yyls': related to locations.
3434 Refer to the stacks thru separate pointers, to allow yyoverflow
3435 to reallocate them elsewhere. */
3437 /* The state stack. */
3438 short int yyssa[YYINITDEPTH];
3439 short int *yyss = yyssa;
3442 /* The semantic value stack. */
3443 YYSTYPE yyvsa[YYINITDEPTH];
3444 YYSTYPE *yyvs = yyvsa;
3449 #define YYPOPSTACK (yyvsp--, yyssp--)
3451 YYSIZE_T yystacksize = YYINITDEPTH;
3453 /* The variables used to return semantic value and location from the
3458 /* When reducing, the number of symbols on the RHS of the reduced
3462 YYDPRINTF ((stderr, "Starting parse\n"));
3467 yychar = YYEMPTY; /* Cause a token to be read. */
3469 /* Initialize stack pointers.
3470 Waste one element of value and location stack
3471 so that they stay on the same level as the state stack.
3472 The wasted elements are never initialized. */
3479 /*------------------------------------------------------------.
3480 | yynewstate -- Push a new state, which is found in yystate. |
3481 `------------------------------------------------------------*/
3483 /* In all cases, when you get here, the value and location stacks
3484 have just been pushed. so pushing a state here evens the stacks.
3491 if (yyss + yystacksize - 1 <= yyssp)
3493 /* Get the current used size of the three stacks, in elements. */
3494 YYSIZE_T yysize = yyssp - yyss + 1;
3498 /* Give user a chance to reallocate the stack. Use copies of
3499 these so that the &'s don't force the real ones into
3501 YYSTYPE *yyvs1 = yyvs;
3502 short int *yyss1 = yyss;
3505 /* Each stack pointer address is followed by the size of the
3506 data in use in that stack, in bytes. This used to be a
3507 conditional around just the two extra args, but that might
3508 be undefined if yyoverflow is a macro. */
3509 yyoverflow (YY_("memory exhausted"),
3510 &yyss1, yysize * sizeof (*yyssp),
3511 &yyvs1, yysize * sizeof (*yyvsp),
3518 #else /* no yyoverflow */
3519 # ifndef YYSTACK_RELOCATE
3520 goto yyexhaustedlab;
3522 /* Extend the stack our own way. */
3523 if (YYMAXDEPTH <= yystacksize)
3524 goto yyexhaustedlab;
3526 if (YYMAXDEPTH < yystacksize)
3527 yystacksize = YYMAXDEPTH;
3530 short int *yyss1 = yyss;
3531 union yyalloc *yyptr =
3532 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3534 goto yyexhaustedlab;
3535 YYSTACK_RELOCATE (yyss);
3536 YYSTACK_RELOCATE (yyvs);
3538 # undef YYSTACK_RELOCATE
3540 YYSTACK_FREE (yyss1);
3543 #endif /* no yyoverflow */
3545 yyssp = yyss + yysize - 1;
3546 yyvsp = yyvs + yysize - 1;
3549 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3550 (unsigned long int) yystacksize));
3552 if (yyss + yystacksize - 1 <= yyssp)
3556 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3565 /* Do appropriate processing given the current state. */
3566 /* Read a look-ahead token if we need one and don't already have one. */
3569 /* First try to decide what to do without reference to look-ahead token. */
3571 yyn = yypact[yystate];
3572 if (yyn == YYPACT_NINF)
3575 /* Not known => get a look-ahead token if don't already have one. */
3577 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3578 if (yychar == YYEMPTY)
3580 YYDPRINTF ((stderr, "Reading a token: "));
3584 if (yychar <= YYEOF)
3586 yychar = yytoken = YYEOF;
3587 YYDPRINTF ((stderr, "Now at end of input.\n"));
3591 yytoken = YYTRANSLATE (yychar);
3592 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3595 /* If the proper action on seeing token YYTOKEN is to reduce or to
3596 detect an error, take that action. */
3598 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3603 if (yyn == 0 || yyn == YYTABLE_NINF)
3612 /* Shift the look-ahead token. */
3613 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3615 /* Discard the token being shifted unless it is eof. */
3616 if (yychar != YYEOF)
3622 /* Count tokens shifted since error; after three, turn off error
3631 /*-----------------------------------------------------------.
3632 | yydefault -- do the default action for the current state. |
3633 `-----------------------------------------------------------*/
3635 yyn = yydefact[yystate];
3641 /*-----------------------------.
3642 | yyreduce -- Do a reduction. |
3643 `-----------------------------*/
3645 /* yyn is the number of a rule to reduce with. */
3648 /* If YYLEN is nonzero, implement the default value of the action:
3651 Otherwise, the following line sets YYVAL to garbage.
3652 This behavior is undocumented and Bison
3653 users should not rely upon it. Assigning to YYVAL
3654 unconditionally makes the parser a bit smaller, and it avoids a
3655 GCC warning that YYVAL may be used uninitialized. */
3656 yyval = yyvsp[1-yylen];
3659 YY_REDUCE_PRINT (yyn);
3663 #line 1576 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3665 if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
3666 error("Value too large for type");
3667 (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3672 #line 1585 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3674 if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
3675 error("Value too large for type");
3676 (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3681 #line 1607 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3682 { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3686 #line 1607 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3687 { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3691 #line 1608 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3692 { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3696 #line 1608 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3697 { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3701 #line 1609 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3702 { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3706 #line 1609 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3707 { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3711 #line 1610 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3712 { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3716 #line 1610 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3717 { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
3721 #line 1611 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3722 { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
3726 #line 1611 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3727 { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
3731 #line 1615 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3732 { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
3736 #line 1615 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3737 { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
3741 #line 1616 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3742 { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
3746 #line 1616 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3747 { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
3751 #line 1617 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3752 { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
3756 #line 1617 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3757 { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
3761 #line 1618 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3762 { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
3766 #line 1618 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3767 { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
3771 #line 1619 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3772 { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
3776 #line 1619 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3777 { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
3781 #line 1620 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3782 { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
3786 #line 1620 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3787 { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
3791 #line 1621 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3792 { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
3796 #line 1621 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3797 { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
3801 #line 1622 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3802 { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
3806 #line 1623 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3807 { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
3811 #line 1654 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3813 (yyval.StrVal) = (yyvsp[-1].StrVal);
3818 #line 1657 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3825 #line 1662 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3826 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3830 #line 1663 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3831 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3835 #line 1664 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3836 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3840 #line 1665 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3841 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3845 #line 1666 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3846 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3850 #line 1667 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3851 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3855 #line 1668 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3856 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3860 #line 1669 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3861 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3865 #line 1673 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3866 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3870 #line 1674 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3871 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::C; ;}
3875 #line 1675 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3876 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::CSRet; ;}
3880 #line 1676 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3881 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Fast; ;}
3885 #line 1677 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3886 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::Cold; ;}
3890 #line 1678 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3891 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
3895 #line 1679 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3896 { CurFun.LastCC = (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
3900 #line 1680 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3902 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
3903 error("Calling conv too large");
3904 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3909 #line 1690 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3910 { (yyval.UIntVal) = 0; ;}
3914 #line 1691 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3916 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3917 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3918 error("Alignment must be a power of two");
3923 #line 1699 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3924 { (yyval.UIntVal) = 0; ;}
3928 #line 1700 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3930 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
3931 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
3932 error("Alignment must be a power of two");
3937 #line 1708 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3939 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
3940 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
3941 error("Invalid character in section name");
3942 (yyval.StrVal) = (yyvsp[0].StrVal);
3947 #line 1717 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3948 { (yyval.StrVal) = 0; ;}
3952 #line 1718 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3953 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
3957 #line 1725 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3962 #line 1726 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3967 #line 1730 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3969 CurGV->setSection((yyvsp[0].StrVal));
3970 free((yyvsp[0].StrVal));
3975 #line 1734 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3977 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
3978 error("Alignment must be a power of two");
3979 CurGV->setAlignment((yyvsp[0].UInt64Val));
3985 #line 1751 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3987 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3988 (yyval.TypeVal).S = Signless;
3993 #line 1759 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3995 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
3996 (yyval.TypeVal).S = Signless;
4001 #line 1766 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4003 if (!UpRefs.empty())
4004 error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).T)->getDescription());
4005 (yyval.TypeVal) = (yyvsp[0].TypeVal);
4010 #line 1780 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4012 (yyval.TypeVal).T = new PATypeHolder((yyvsp[0].PrimType).T);
4013 (yyval.TypeVal).S = (yyvsp[0].PrimType).S;
4018 #line 1784 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4020 (yyval.TypeVal).T = new PATypeHolder(OpaqueType::get());
4021 (yyval.TypeVal).S = Signless;
4026 #line 1788 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4027 { // Named types are also simple types...
4028 const Type* tmp = getType((yyvsp[0].ValIDVal));
4029 (yyval.TypeVal).T = new PATypeHolder(tmp);
4030 (yyval.TypeVal).S = Signless; // FIXME: what if its signed?
4035 #line 1793 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4036 { // Type UpReference
4037 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4038 error("Value out of range");
4039 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4040 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
4041 (yyval.TypeVal).T = new PATypeHolder(OT);
4042 (yyval.TypeVal).S = Signless;
4043 UR_OUT("New Upreference!\n");
4048 #line 1802 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4049 { // Function derived type?
4050 std::vector<const Type*> Params;
4051 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4052 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4053 Params.push_back(I->T->get());
4055 FunctionType::ParamAttrsList ParamAttrs;
4056 if (CurFun.LastCC == OldCallingConv::CSRet) {
4057 ParamAttrs.push_back(FunctionType::NoAttributeSet);
4058 ParamAttrs.push_back(FunctionType::StructRetAttribute);
4060 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4061 if (isVarArg) Params.pop_back();
4063 (yyval.TypeVal).T = new PATypeHolder(
4064 HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).T->get(),Params,isVarArg, ParamAttrs)));
4065 (yyval.TypeVal).S = (yyvsp[-3].TypeVal).S;
4066 delete (yyvsp[-3].TypeVal).T; // Delete the return type handle
4067 delete (yyvsp[-1].TypeList); // Delete the argument list
4072 #line 1822 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4073 { // Sized array type?
4074 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).T->get(),
4075 (unsigned)(yyvsp[-3].UInt64Val))));
4076 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4077 delete (yyvsp[-1].TypeVal).T;
4082 #line 1828 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4083 { // Packed array type?
4084 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).T->get();
4085 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4086 error("Unsigned result not equal to signed result");
4087 if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4088 error("Elements of a PackedType must be integer or floating point");
4089 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4090 error("PackedType length should be a power of 2");
4091 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PackedType::get(ElemTy,
4092 (unsigned)(yyvsp[-3].UInt64Val))));
4093 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4094 delete (yyvsp[-1].TypeVal).T;
4099 #line 1841 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4100 { // Structure type?
4101 std::vector<const Type*> Elements;
4102 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4103 E = (yyvsp[-1].TypeList)->end(); I != E; ++I)
4104 Elements.push_back(I->T->get());
4105 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
4106 (yyval.TypeVal).S = Signless;
4107 delete (yyvsp[-1].TypeList);
4112 #line 1850 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4113 { // Empty structure type?
4114 (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4115 (yyval.TypeVal).S = Signless;
4120 #line 1854 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4121 { // Packed Structure type?
4122 std::vector<const Type*> Elements;
4123 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4124 E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4125 Elements.push_back(I->T->get());
4128 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
4129 (yyval.TypeVal).S = Signless;
4130 delete (yyvsp[-2].TypeList);
4135 #line 1865 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4136 { // Empty packed structure type?
4137 (yyval.TypeVal).T = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4138 (yyval.TypeVal).S = Signless;
4143 #line 1869 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4145 if ((yyvsp[-1].TypeVal).T->get() == Type::LabelTy)
4146 error("Cannot form a pointer to a basic block");
4147 (yyval.TypeVal).T = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).T->get())));
4148 (yyval.TypeVal).S = (yyvsp[-1].TypeVal).S;
4149 delete (yyvsp[-1].TypeVal).T;
4154 #line 1882 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4156 (yyval.TypeList) = new std::list<PATypeInfo>();
4157 (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4162 #line 1886 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4164 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4169 #line 1894 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4172 VoidTI.T = new PATypeHolder(Type::VoidTy);
4173 VoidTI.S = Signless;
4174 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4179 #line 1900 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4181 (yyval.TypeList) = new std::list<PATypeInfo>();
4183 VoidTI.T = new PATypeHolder(Type::VoidTy);
4184 VoidTI.S = Signless;
4185 (yyval.TypeList)->push_back(VoidTI);
4190 #line 1907 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4192 (yyval.TypeList) = new std::list<PATypeInfo>();
4197 #line 1919 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4198 { // Nonempty unsized arr
4199 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).T->get());
4201 error("Cannot make array constant with type: '" +
4202 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4203 const Type *ETy = ATy->getElementType();
4204 int NumElements = ATy->getNumElements();
4206 // Verify that we have the correct size...
4207 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4208 error("Type mismatch: constant sized array initialized with " +
4209 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4210 itostr(NumElements) + "");
4212 // Verify all elements are correct type!
4213 std::vector<Constant*> Elems;
4214 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4215 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4216 const Type* ValTy = C->getType();
4218 error("Element #" + utostr(i) + " is not of type '" +
4219 ETy->getDescription() +"' as required!\nIt is of type '"+
4220 ValTy->getDescription() + "'");
4223 (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4224 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4225 delete (yyvsp[-3].TypeVal).T;
4226 delete (yyvsp[-1].ConstVector);
4231 #line 1949 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4233 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4235 error("Cannot make array constant with type: '" +
4236 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4237 int NumElements = ATy->getNumElements();
4238 if (NumElements != -1 && NumElements != 0)
4239 error("Type mismatch: constant sized array initialized with 0"
4240 " arguments, but has size of " + itostr(NumElements) +"");
4241 (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4242 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4243 delete (yyvsp[-2].TypeVal).T;
4248 #line 1962 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4250 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).T->get());
4252 error("Cannot make array constant with type: '" +
4253 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4254 int NumElements = ATy->getNumElements();
4255 const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4256 if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4257 error("String arrays require type i8, not '" + ETy->getDescription() +
4259 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4260 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4261 error("Can't build string constant of size " +
4262 itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4263 itostr(NumElements) + "");
4264 std::vector<Constant*> Vals;
4265 for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4266 Vals.push_back(ConstantInt::get(ETy, *C));
4267 free((yyvsp[0].StrVal));
4268 (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4269 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4270 delete (yyvsp[-2].TypeVal).T;
4275 #line 1985 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4276 { // Nonempty unsized arr
4277 const PackedType *PTy = dyn_cast<PackedType>((yyvsp[-3].TypeVal).T->get());
4279 error("Cannot make packed constant with type: '" +
4280 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4281 const Type *ETy = PTy->getElementType();
4282 int NumElements = PTy->getNumElements();
4283 // Verify that we have the correct size...
4284 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4285 error("Type mismatch: constant sized packed initialized with " +
4286 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4287 itostr(NumElements) + "");
4288 // Verify all elements are correct type!
4289 std::vector<Constant*> Elems;
4290 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4291 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4292 const Type* ValTy = C->getType();
4294 error("Element #" + utostr(i) + " is not of type '" +
4295 ETy->getDescription() +"' as required!\nIt is of type '"+
4296 ValTy->getDescription() + "'");
4299 (yyval.ConstVal).C = ConstantPacked::get(PTy, Elems);
4300 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4301 delete (yyvsp[-3].TypeVal).T;
4302 delete (yyvsp[-1].ConstVector);
4307 #line 2013 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4309 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).T->get());
4311 error("Cannot make struct constant with type: '" +
4312 (yyvsp[-3].TypeVal).T->get()->getDescription() + "'");
4313 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4314 error("Illegal number of initializers for structure type");
4316 // Check to ensure that constants are compatible with the type initializer!
4317 std::vector<Constant*> Fields;
4318 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4319 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4320 if (C->getType() != STy->getElementType(i))
4321 error("Expected type '" + STy->getElementType(i)->getDescription() +
4322 "' for element #" + utostr(i) + " of structure initializer");
4323 Fields.push_back(C);
4325 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4326 (yyval.ConstVal).S = (yyvsp[-3].TypeVal).S;
4327 delete (yyvsp[-3].TypeVal).T;
4328 delete (yyvsp[-1].ConstVector);
4333 #line 2035 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4335 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).T->get());
4337 error("Cannot make struct constant with type: '" +
4338 (yyvsp[-2].TypeVal).T->get()->getDescription() + "'");
4339 if (STy->getNumContainedTypes() != 0)
4340 error("Illegal number of initializers for structure type");
4341 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4342 (yyval.ConstVal).S = (yyvsp[-2].TypeVal).S;
4343 delete (yyvsp[-2].TypeVal).T;
4348 #line 2046 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4350 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).T->get());
4352 error("Cannot make packed struct constant with type: '" +
4353 (yyvsp[-5].TypeVal).T->get()->getDescription() + "'");
4354 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4355 error("Illegal number of initializers for packed structure type");
4357 // Check to ensure that constants are compatible with the type initializer!
4358 std::vector<Constant*> Fields;
4359 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4360 Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4361 if (C->getType() != STy->getElementType(i))
4362 error("Expected type '" + STy->getElementType(i)->getDescription() +
4363 "' for element #" + utostr(i) + " of packed struct initializer");
4364 Fields.push_back(C);
4366 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4367 (yyval.ConstVal).S = (yyvsp[-5].TypeVal).S;
4368 delete (yyvsp[-5].TypeVal).T;
4369 delete (yyvsp[-2].ConstVector);
4374 #line 2068 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4376 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).T->get());
4378 error("Cannot make packed struct constant with type: '" +
4379 (yyvsp[-4].TypeVal).T->get()->getDescription() + "'");
4380 if (STy->getNumContainedTypes() != 0)
4381 error("Illegal number of initializers for packed structure type");
4382 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4383 (yyval.ConstVal).S = (yyvsp[-4].TypeVal).S;
4384 delete (yyvsp[-4].TypeVal).T;
4389 #line 2079 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4391 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4393 error("Cannot make null pointer constant with type: '" +
4394 (yyvsp[-1].TypeVal).T->get()->getDescription() + "'");
4395 (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4396 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4397 delete (yyvsp[-1].TypeVal).T;
4402 #line 2088 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4404 (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).T->get());
4405 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4406 delete (yyvsp[-1].TypeVal).T;
4411 #line 2093 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4413 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
4415 error("Global const reference must be a pointer type, not" +
4416 (yyvsp[-1].TypeVal).T->get()->getDescription());
4418 // ConstExprs can exist in the body of a function, thus creating
4419 // GlobalValues whenever they refer to a variable. Because we are in
4420 // the context of a function, getExistingValue will search the functions
4421 // symbol table instead of the module symbol table for the global symbol,
4422 // which throws things all off. To get around this, we just tell
4423 // getExistingValue that we are at global scope here.
4425 Function *SavedCurFn = CurFun.CurrentFunction;
4426 CurFun.CurrentFunction = 0;
4427 Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4428 CurFun.CurrentFunction = SavedCurFn;
4430 // If this is an initializer for a constant pointer, which is referencing a
4431 // (currently) undefined variable, create a stub now that shall be replaced
4432 // in the future with the right type of variable.
4435 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4436 const PointerType *PT = cast<PointerType>(Ty);
4438 // First check to see if the forward references value is already created!
4439 PerModuleInfo::GlobalRefsType::iterator I =
4440 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4442 if (I != CurModule.GlobalRefs.end()) {
4443 V = I->second; // Placeholder already exists, use it...
4444 (yyvsp[0].ValIDVal).destroy();
4447 if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4449 // Create the forward referenced global.
4451 if (const FunctionType *FTy =
4452 dyn_cast<FunctionType>(PT->getElementType())) {
4453 GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4454 CurModule.CurrentModule);
4456 GV = new GlobalVariable(PT->getElementType(), false,
4457 GlobalValue::ExternalLinkage, 0,
4458 Name, CurModule.CurrentModule);
4461 // Keep track of the fact that we have a forward ref to recycle it
4462 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4466 (yyval.ConstVal).C = cast<GlobalValue>(V);
4467 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4468 delete (yyvsp[-1].TypeVal).T; // Free the type handle
4473 #line 2151 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4475 if ((yyvsp[-1].TypeVal).T->get() != (yyvsp[0].ConstVal).C->getType())
4476 error("Mismatched types for constant expression");
4477 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4478 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4479 delete (yyvsp[-1].TypeVal).T;
4484 #line 2158 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4486 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
4487 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4488 error("Cannot create a null initialized value of this type");
4489 (yyval.ConstVal).C = Constant::getNullValue(Ty);
4490 (yyval.ConstVal).S = (yyvsp[-1].TypeVal).S;
4491 delete (yyvsp[-1].TypeVal).T;
4496 #line 2166 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4497 { // integral constants
4498 const Type *Ty = (yyvsp[-1].PrimType).T;
4499 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4500 error("Constant value doesn't fit in type");
4501 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4502 (yyval.ConstVal).S = Signed;
4507 #line 2173 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4508 { // integral constants
4509 const Type *Ty = (yyvsp[-1].PrimType).T;
4510 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4511 error("Constant value doesn't fit in type");
4512 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4513 (yyval.ConstVal).S = Unsigned;
4518 #line 2180 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4519 { // Boolean constants
4520 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4521 (yyval.ConstVal).S = Unsigned;
4526 #line 2184 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4527 { // Boolean constants
4528 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4529 (yyval.ConstVal).S = Unsigned;
4534 #line 2188 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4535 { // Float & Double constants
4536 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4537 error("Floating point constant invalid for type");
4538 (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4539 (yyval.ConstVal).S = Signless;
4544 #line 2197 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4546 const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4547 const Type* DstTy = (yyvsp[-1].TypeVal).T->get();
4548 Signedness SrcSign = (yyvsp[-3].ConstVal).S;
4549 Signedness DstSign = (yyvsp[-1].TypeVal).S;
4550 if (!SrcTy->isFirstClassType())
4551 error("cast constant expression from a non-primitive type: '" +
4552 SrcTy->getDescription() + "'");
4553 if (!DstTy->isFirstClassType())
4554 error("cast constant expression to a non-primitive type: '" +
4555 DstTy->getDescription() + "'");
4556 (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4557 (yyval.ConstVal).S = DstSign;
4558 delete (yyvsp[-1].TypeVal).T;
4563 #line 2212 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4565 const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4566 if (!isa<PointerType>(Ty))
4567 error("GetElementPtr requires a pointer operand");
4569 std::vector<Value*> VIndices;
4570 std::vector<Constant*> CIndices;
4571 upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4573 delete (yyvsp[-1].ValueList);
4574 (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, CIndices);
4575 (yyval.ConstVal).S = Signless;
4580 #line 2225 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4582 if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4583 cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4584 error("Select condition must be bool type");
4585 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4586 error("Select operand types must match");
4587 (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4588 (yyval.ConstVal).S = Unsigned;
4593 #line 2234 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4595 const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4596 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4597 error("Binary operator types must match");
4598 // First, make sure we're dealing with the right opcode by upgrading from
4599 // obsolete versions.
4600 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4602 // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4603 // To retain backward compatibility with these early compilers, we emit a
4604 // cast to the appropriate integer type automatically if we are in the
4605 // broken case. See PR424 for more information.
4606 if (!isa<PointerType>(Ty)) {
4607 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4609 const Type *IntPtrTy = 0;
4610 switch (CurModule.CurrentModule->getPointerSize()) {
4611 case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4612 case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4613 default: error("invalid pointer binary constant expr");
4615 (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4616 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4617 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4618 (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4620 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4625 #line 2262 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4627 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4628 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4629 error("Logical operator types must match");
4630 if (!Ty->isInteger()) {
4631 if (!isa<PackedType>(Ty) ||
4632 !cast<PackedType>(Ty)->getElementType()->isInteger())
4633 error("Logical operator requires integer operands");
4635 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4636 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4637 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4642 #line 2275 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4644 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4645 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4646 error("setcc operand types must match");
4647 unsigned short pred;
4648 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4649 (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4650 (yyval.ConstVal).S = Unsigned;
4655 #line 2284 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4657 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4658 error("icmp operand types must match");
4659 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4660 (yyval.ConstVal).S = Unsigned;
4665 #line 2290 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4667 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4668 error("fcmp operand types must match");
4669 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4670 (yyval.ConstVal).S = Unsigned;
4675 #line 2296 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4677 if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4678 cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4679 error("Shift count for shift constant must be unsigned byte");
4680 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4681 if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4682 error("Shift constant expression requires integer operand");
4683 Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4684 (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4685 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4690 #line 2307 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4692 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4693 error("Invalid extractelement operands");
4694 (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4695 (yyval.ConstVal).S = (yyvsp[-3].ConstVal).S;
4700 #line 2313 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4702 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4703 error("Invalid insertelement operands");
4704 (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4705 (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4710 #line 2319 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4712 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4713 error("Invalid shufflevector operands");
4714 (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4715 (yyval.ConstVal).S = (yyvsp[-5].ConstVal).S;
4720 #line 2330 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4721 { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
4725 #line 2331 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4727 (yyval.ConstVector) = new std::vector<ConstInfo>();
4728 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
4733 #line 2340 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4734 { (yyval.BoolVal) = false; ;}
4738 #line 2341 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4739 { (yyval.BoolVal) = true; ;}
4743 #line 2353 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4745 (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
4746 CurModule.ModuleDone();
4751 #line 2362 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4752 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
4756 #line 2363 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4757 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4761 #line 2364 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4762 { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
4766 #line 2365 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4767 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
4771 #line 2366 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4773 (yyval.ModuleVal) = CurModule.CurrentModule;
4774 // Emit an error if there are any unresolved types left.
4775 if (!CurModule.LateResolveTypes.empty()) {
4776 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
4777 if (DID.Type == ValID::NameVal) {
4778 error("Reference to an undefined type: '"+DID.getName() + "'");
4780 error("Reference to an undefined type: #" + itostr(DID.Num));
4787 #line 2382 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4789 // Eagerly resolve types. This is not an optimization, this is a
4790 // requirement that is due to the fact that we could have this:
4792 // %list = type { %list * }
4793 // %list = type { %list * } ; repeated type decl
4795 // If types are not resolved eagerly, then the two types will not be
4796 // determined to be the same type!
4798 const Type* Ty = (yyvsp[0].TypeVal).T->get();
4799 ResolveTypeTo((yyvsp[-2].StrVal), Ty);
4801 if (!setTypeName(Ty, (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
4802 // If this is a named type that is not a redefinition, add it to the slot
4804 CurModule.Types.push_back(Ty);
4806 delete (yyvsp[0].TypeVal).T;
4811 #line 2402 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4812 { // Function prototypes can be in const pool
4817 #line 2404 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4818 { // Asm blocks can be in the const pool
4823 #line 2406 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4825 if ((yyvsp[0].ConstVal).C == 0)
4826 error("Global value initializer is not a constant");
4827 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C);
4832 #line 2410 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4839 #line 2413 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4841 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4842 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4843 delete (yyvsp[0].TypeVal).T;
4848 #line 2417 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4855 #line 2420 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4857 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4858 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4859 delete (yyvsp[0].TypeVal).T;
4864 #line 2424 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4871 #line 2427 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4873 const Type *Ty = (yyvsp[0].TypeVal).T->get();
4875 ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0);
4876 delete (yyvsp[0].TypeVal).T;
4881 #line 2432 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4888 #line 2435 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4894 #line 2437 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4900 #line 2439 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4906 #line 2444 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4908 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
4909 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4910 std::string NewAsm((yyvsp[0].StrVal), EndStr);
4911 free((yyvsp[0].StrVal));
4913 if (AsmSoFar.empty())
4914 CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
4916 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
4921 #line 2458 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4922 { (yyval.Endianness) = Module::BigEndian; ;}
4926 #line 2459 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4927 { (yyval.Endianness) = Module::LittleEndian; ;}
4931 #line 2463 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4933 CurModule.setEndianness((yyvsp[0].Endianness));
4938 #line 2466 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4940 if ((yyvsp[0].UInt64Val) == 32)
4941 CurModule.setPointerSize(Module::Pointer32);
4942 else if ((yyvsp[0].UInt64Val) == 64)
4943 CurModule.setPointerSize(Module::Pointer64);
4945 error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
4950 #line 2474 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4952 CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
4953 free((yyvsp[0].StrVal));
4958 #line 2478 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4960 CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
4961 free((yyvsp[0].StrVal));
4966 #line 2489 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4968 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4969 free((yyvsp[0].StrVal));
4974 #line 2493 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4976 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
4977 free((yyvsp[0].StrVal));
4982 #line 2497 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4987 #line 2510 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4988 { (yyval.StrVal) = 0; ;}
4992 #line 2514 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4994 if ((yyvsp[-1].TypeVal).T->get() == Type::VoidTy)
4995 error("void typed arguments are invalid");
4996 (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
5001 #line 2522 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5003 (yyval.ArgList) = (yyvsp[-2].ArgList);
5004 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5005 delete (yyvsp[0].ArgVal);
5010 #line 2527 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5012 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5013 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5014 delete (yyvsp[0].ArgVal);
5019 #line 2535 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5020 { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5024 #line 2536 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5026 (yyval.ArgList) = (yyvsp[-2].ArgList);
5028 VoidTI.T = new PATypeHolder(Type::VoidTy);
5029 VoidTI.S = Signless;
5030 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5035 #line 2543 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5037 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5039 VoidTI.T = new PATypeHolder(Type::VoidTy);
5040 VoidTI.S = Signless;
5041 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5046 #line 2550 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5047 { (yyval.ArgList) = 0; ;}
5051 #line 2554 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5053 UnEscapeLexed((yyvsp[-5].StrVal));
5054 std::string FunctionName((yyvsp[-5].StrVal));
5055 free((yyvsp[-5].StrVal)); // Free strdup'd memory!
5057 const Type* RetTy = (yyvsp[-6].TypeVal).T->get();
5059 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5060 error("LLVM functions cannot return aggregate types");
5062 std::vector<const Type*> ParamTypeList;
5064 // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5065 // i8*. We check here for those names and override the parameter list
5066 // types to ensure the prototype is correct.
5067 if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5068 ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5069 } else if (FunctionName == "llvm.va_copy") {
5070 ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5071 ParamTypeList.push_back(PointerType::get(Type::Int8Ty));
5072 } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
5073 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5074 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5075 const Type *Ty = I->first.T->get();
5076 ParamTypeList.push_back(Ty);
5081 ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
5082 if (isVarArg) ParamTypeList.pop_back();
5084 // Convert the CSRet calling convention into the corresponding parameter
5086 FunctionType::ParamAttrsList ParamAttrs;
5087 if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5088 ParamAttrs.push_back(FunctionType::NoAttributeSet); // result
5089 ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5092 const FunctionType *FT = FunctionType::get(RetTy, ParamTypeList, isVarArg,
5094 const PointerType *PFT = PointerType::get(FT);
5095 delete (yyvsp[-6].TypeVal).T;
5098 if (!FunctionName.empty()) {
5099 ID = ValID::create((char*)FunctionName.c_str());
5101 ID = ValID::create((int)CurModule.Values[PFT].size());
5105 // See if this function was forward referenced. If so, recycle the object.
5106 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5107 // Move the function to the end of the list, from whereever it was
5108 // previously inserted.
5109 Fn = cast<Function>(FWRef);
5110 CurModule.CurrentModule->getFunctionList().remove(Fn);
5111 CurModule.CurrentModule->getFunctionList().push_back(Fn);
5112 } else if (!FunctionName.empty() && // Merge with an earlier prototype?
5113 (Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
5114 // If this is the case, either we need to be a forward decl, or it needs
5116 if (!CurFun.isDeclare && !Fn->isDeclaration())
5117 error("Redefinition of function '" + FunctionName + "'");
5119 // Make sure to strip off any argument names so we can't get conflicts.
5120 if (Fn->isDeclaration())
5121 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
5124 } else { // Not already defined?
5125 Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
5126 CurModule.CurrentModule);
5128 InsertValue(Fn, CurModule.Values);
5131 CurFun.FunctionStart(Fn);
5133 if (CurFun.isDeclare) {
5134 // If we have declaration, always overwrite linkage. This will allow us
5135 // to correctly handle cases, when pointer to function is passed as
5136 // argument to another function.
5137 Fn->setLinkage(CurFun.Linkage);
5139 Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5140 Fn->setAlignment((yyvsp[0].UIntVal));
5141 if ((yyvsp[-1].StrVal)) {
5142 Fn->setSection((yyvsp[-1].StrVal));
5143 free((yyvsp[-1].StrVal));
5146 // Add all of the arguments we parsed to the function...
5147 if ((yyvsp[-3].ArgList)) { // Is null if empty...
5148 if (isVarArg) { // Nuke the last entry
5149 assert((yyvsp[-3].ArgList)->back().first.T->get() == Type::VoidTy &&
5150 (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5151 delete (yyvsp[-3].ArgList)->back().first.T;
5152 (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
5154 Function::arg_iterator ArgIt = Fn->arg_begin();
5155 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5156 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I, ++ArgIt) {
5157 delete I->first.T; // Delete the typeholder...
5158 setValueName(ArgIt, I->second); // Insert arg into symtab...
5161 delete (yyvsp[-3].ArgList); // We're now done with the argument list
5167 #line 2673 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5169 (yyval.FunctionVal) = CurFun.CurrentFunction;
5171 // Make sure that we keep track of the linkage type even if there was a
5172 // previous "declare".
5173 (yyval.FunctionVal)->setLinkage((yyvsp[-2].Linkage));
5178 #line 2687 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5180 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5185 #line 2693 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5186 { CurFun.Linkage = GlobalValue::DLLImportLinkage; ;}
5190 #line 2694 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5191 { CurFun.Linkage = GlobalValue::ExternalWeakLinkage; ;}
5195 #line 2698 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5196 { CurFun.isDeclare = true; ;}
5200 #line 2698 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5202 (yyval.FunctionVal) = CurFun.CurrentFunction;
5203 CurFun.FunctionDone();
5209 #line 2710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5210 { (yyval.BoolVal) = false; ;}
5214 #line 2711 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5215 { (yyval.BoolVal) = true; ;}
5219 #line 2716 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5220 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5224 #line 2717 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5225 { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5229 #line 2718 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5230 { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5234 #line 2719 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5235 { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true)); ;}
5239 #line 2720 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5240 { (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false)); ;}
5244 #line 2721 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5245 { (yyval.ValIDVal) = ValID::createNull(); ;}
5249 #line 2722 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5250 { (yyval.ValIDVal) = ValID::createUndef(); ;}
5254 #line 2723 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5255 { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5259 #line 2724 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5260 { // Nonempty unsized packed vector
5261 const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5262 int NumElements = (yyvsp[-1].ConstVector)->size();
5263 PackedType* pt = PackedType::get(ETy, NumElements);
5264 PATypeHolder* PTy = new PATypeHolder(
5265 HandleUpRefs(PackedType::get(ETy, NumElements)));
5267 // Verify all elements are correct type!
5268 std::vector<Constant*> Elems;
5269 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5270 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5271 const Type *CTy = C->getType();
5273 error("Element #" + utostr(i) + " is not of type '" +
5274 ETy->getDescription() +"' as required!\nIt is of type '" +
5275 CTy->getDescription() + "'");
5278 (yyval.ValIDVal) = ValID::create(ConstantPacked::get(pt, Elems));
5279 delete PTy; delete (yyvsp[-1].ConstVector);
5284 #line 2745 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5286 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5291 #line 2748 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5293 char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5294 std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5295 End = UnEscapeLexed((yyvsp[0].StrVal), true);
5296 std::string Constraints = std::string((yyvsp[0].StrVal), End);
5297 (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5298 free((yyvsp[-2].StrVal));
5299 free((yyvsp[0].StrVal));
5304 #line 2763 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5305 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); ;}
5309 #line 2764 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5310 { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); ;}
5314 #line 2777 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5316 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
5317 (yyval.ValueVal).S = (yyvsp[-1].TypeVal).S;
5318 (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5319 delete (yyvsp[-1].TypeVal).T;
5324 #line 2786 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5326 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5331 #line 2789 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5332 { // Do not allow functions with 0 basic blocks
5333 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5338 #line 2798 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5340 setValueName((yyvsp[0].TermInstVal), (yyvsp[-1].StrVal));
5341 InsertValue((yyvsp[0].TermInstVal));
5342 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal));
5343 InsertValue((yyvsp[-2].BasicBlockVal));
5344 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5349 #line 2808 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5351 if ((yyvsp[0].InstVal).I)
5352 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5353 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5358 #line 2813 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5360 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
5361 // Make sure to move the basic block to the correct location in the
5362 // function, instead of leaving it inserted wherever it was first
5364 Function::BasicBlockListType &BBL =
5365 CurFun.CurrentFunction->getBasicBlockList();
5366 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5371 #line 2822 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5373 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5374 // Make sure to move the basic block to the correct location in the
5375 // function, instead of leaving it inserted wherever it was first
5377 Function::BasicBlockListType &BBL =
5378 CurFun.CurrentFunction->getBasicBlockList();
5379 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5384 #line 2836 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5385 { // Return with a result...
5386 (yyval.TermInstVal) = new ReturnInst((yyvsp[0].ValueVal).V);
5391 #line 2839 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5392 { // Return with no result...
5393 (yyval.TermInstVal) = new ReturnInst();
5398 #line 2842 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5399 { // Unconditional Branch...
5400 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5401 (yyval.TermInstVal) = new BranchInst(tmpBB);
5406 #line 2846 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5408 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5409 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5410 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5411 (yyval.TermInstVal) = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5416 #line 2852 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5418 Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5419 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5420 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5421 (yyval.TermInstVal) = S;
5422 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5423 E = (yyvsp[-1].JumpTable)->end();
5424 for (; I != E; ++I) {
5425 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5426 S->addCase(CI, I->second);
5428 error("Switch case is constant, but not a simple integer");
5430 delete (yyvsp[-1].JumpTable);
5435 #line 2867 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5437 Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5438 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5439 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5440 (yyval.TermInstVal) = S;
5445 #line 2874 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5447 const PointerType *PFTy;
5448 const FunctionType *Ty;
5450 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).T->get())) ||
5451 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5452 // Pull out the types of all of the arguments...
5453 std::vector<const Type*> ParamTypes;
5454 if ((yyvsp[-7].ValueList)) {
5455 for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5457 ParamTypes.push_back((*I).V->getType());
5459 FunctionType::ParamAttrsList ParamAttrs;
5460 if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5461 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5462 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5464 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5465 if (isVarArg) ParamTypes.pop_back();
5466 Ty = FunctionType::get((yyvsp[-10].TypeVal).T->get(), ParamTypes, isVarArg, ParamAttrs);
5467 PFTy = PointerType::get(Ty);
5469 Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling...
5470 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5471 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5473 // Create the call node...
5474 if (!(yyvsp[-7].ValueList)) { // Has no arguments?
5475 (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, std::vector<Value*>());
5476 } else { // Has arguments?
5477 // Loop through FunctionType's arguments and ensure they are specified
5480 FunctionType::param_iterator I = Ty->param_begin();
5481 FunctionType::param_iterator E = Ty->param_end();
5482 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5484 std::vector<Value*> Args;
5485 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5486 if ((*ArgI).V->getType() != *I)
5487 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5488 (*I)->getDescription() + "'");
5489 Args.push_back((*ArgI).V);
5492 if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5493 error("Invalid number of parameters detected");
5495 (yyval.TermInstVal) = new InvokeInst(V, Normal, Except, Args);
5497 cast<InvokeInst>((yyval.TermInstVal))->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5498 delete (yyvsp[-10].TypeVal).T;
5499 delete (yyvsp[-7].ValueList);
5504 #line 2929 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5506 (yyval.TermInstVal) = new UnwindInst();
5511 #line 2932 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5513 (yyval.TermInstVal) = new UnreachableInst();
5518 #line 2938 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5520 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5521 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5524 error("May only switch on a constant pool value");
5526 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5527 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5532 #line 2948 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5534 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5535 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5538 error("May only switch on a constant pool value");
5540 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5541 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5546 #line 2961 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5549 if ((yyvsp[-1].StrVal))
5550 if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5551 if (BCI->getSrcTy() == BCI->getDestTy() &&
5552 BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5553 // This is a useless bit cast causing a name redefinition. It is
5554 // a bit cast from a type to the same type of an operand with the
5555 // same name as the name we would give this instruction. Since this
5556 // instruction results in no code generation, it is safe to omit
5557 // the instruction. This situation can occur because of collapsed
5558 // type planes. For example:
5559 // %X = add int %Y, %Z
5560 // %X = cast int %Y to uint
5561 // After upgrade, this looks like:
5562 // %X = add i32 %Y, %Z
5563 // %X = bitcast i32 to i32
5564 // The bitcast is clearly useless so we omit it.
5567 (yyval.InstVal).I = 0;
5568 (yyval.InstVal).S = Signless;
5570 setValueName((yyvsp[0].InstVal).I, (yyvsp[-1].StrVal));
5571 InsertValue((yyvsp[0].InstVal).I);
5572 (yyval.InstVal) = (yyvsp[0].InstVal);
5578 #line 2990 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5579 { // Used for PHI nodes
5580 (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5581 (yyval.PHIList).S = (yyvsp[-5].TypeVal).S;
5582 Value* tmpVal = getVal((yyvsp[-5].TypeVal).T->get(), (yyvsp[-3].ValIDVal));
5583 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5584 (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5585 delete (yyvsp[-5].TypeVal).T;
5590 #line 2998 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5592 (yyval.PHIList) = (yyvsp[-6].PHIList);
5593 Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
5594 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5595 (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5600 #line 3006 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5601 { // Used for call statements, and memory insts...
5602 (yyval.ValueList) = new std::vector<ValueInfo>();
5603 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
5608 #line 3010 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5610 (yyval.ValueList) = (yyvsp[-2].ValueList);
5611 (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
5616 #line 3018 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5617 { (yyval.ValueList) = 0; ;}
5621 #line 3022 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5623 (yyval.BoolVal) = true;
5628 #line 3025 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5630 (yyval.BoolVal) = false;
5635 #line 3031 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5637 const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5638 if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<PackedType>(Ty))
5639 error("Arithmetic operator requires integer, FP, or packed operands");
5640 if (isa<PackedType>(Ty) &&
5641 ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
5642 error("Remainder not supported on packed types");
5643 // Upgrade the opcode from obsolete versions before we do anything with it.
5644 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5645 Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5646 Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
5647 (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
5648 if ((yyval.InstVal).I == 0)
5649 error("binary operator returned null");
5650 (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5651 delete (yyvsp[-3].TypeVal).T;
5656 #line 3048 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5658 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5659 if (!Ty->isInteger()) {
5660 if (!isa<PackedType>(Ty) ||
5661 !cast<PackedType>(Ty)->getElementType()->isInteger())
5662 error("Logical operator requires integral operands");
5664 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
5665 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5666 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5667 (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
5668 if ((yyval.InstVal).I == 0)
5669 error("binary operator returned null");
5670 (yyval.InstVal).S = (yyvsp[-3].TypeVal).S;
5671 delete (yyvsp[-3].TypeVal).T;
5676 #line 3064 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5678 const Type* Ty = (yyvsp[-3].TypeVal).T->get();
5679 if(isa<PackedType>(Ty))
5680 error("PackedTypes currently not supported in setcc instructions");
5681 unsigned short pred;
5682 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
5683 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5684 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5685 (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
5686 if ((yyval.InstVal).I == 0)
5687 error("binary operator returned null");
5688 (yyval.InstVal).S = Unsigned;
5689 delete (yyvsp[-3].TypeVal).T;
5694 #line 3078 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5696 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5697 if (isa<PackedType>(Ty))
5698 error("PackedTypes currently not supported in icmp instructions");
5699 else if (!Ty->isInteger() && !isa<PointerType>(Ty))
5700 error("icmp requires integer or pointer typed operands");
5701 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5702 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5703 (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
5704 (yyval.InstVal).S = Unsigned;
5705 delete (yyvsp[-3].TypeVal).T;
5710 #line 3090 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5712 const Type *Ty = (yyvsp[-3].TypeVal).T->get();
5713 if (isa<PackedType>(Ty))
5714 error("PackedTypes currently not supported in fcmp instructions");
5715 else if (!Ty->isFloatingPoint())
5716 error("fcmp instruction requires floating point operands");
5717 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
5718 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
5719 (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
5720 (yyval.InstVal).S = Unsigned;
5721 delete (yyvsp[-3].TypeVal).T;
5726 #line 3102 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5728 warning("Use of obsolete 'not' instruction: Replacing with 'xor");
5729 const Type *Ty = (yyvsp[0].ValueVal).V->getType();
5730 Value *Ones = ConstantInt::getAllOnesValue(Ty);
5732 error("Expected integral type for not instruction");
5733 (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
5734 if ((yyval.InstVal).I == 0)
5735 error("Could not create a xor instruction");
5736 (yyval.InstVal).S = (yyvsp[0].ValueVal).S
5741 #line 3113 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5743 if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
5744 cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
5745 error("Shift amount must be int8");
5746 const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
5747 if (!Ty->isInteger())
5748 error("Shift constant expression requires integer operand");
5749 Value* ShiftAmt = 0;
5750 if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
5751 if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
5752 ShiftAmt = ConstantExpr::getZExt(C, Ty);
5754 ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
5756 ShiftAmt = (yyvsp[0].ValueVal).V;
5757 (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
5758 (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5763 #line 3131 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5765 const Type *DstTy = (yyvsp[0].TypeVal).T->get();
5766 if (!DstTy->isFirstClassType())
5767 error("cast instruction to a non-primitive type: '" +
5768 DstTy->getDescription() + "'");
5769 (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
5770 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5771 delete (yyvsp[0].TypeVal).T;
5776 #line 3140 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5778 if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
5779 cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
5780 error("select condition must be bool");
5781 if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
5782 error("select value types should match");
5783 (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5784 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5789 #line 3149 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5791 const Type *Ty = (yyvsp[0].TypeVal).T->get();
5793 (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
5794 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5795 delete (yyvsp[0].TypeVal).T;
5800 #line 3156 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5802 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5803 const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5804 ObsoleteVarArgs = true;
5805 Function* NF = cast<Function>(CurModule.CurrentModule->
5806 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5809 //foo = alloca 1 of t
5813 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
5814 CurBB->getInstList().push_back(foo);
5815 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5816 CurBB->getInstList().push_back(bar);
5817 CurBB->getInstList().push_back(new StoreInst(bar, foo));
5818 (yyval.InstVal).I = new VAArgInst(foo, DstTy);
5819 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5820 delete (yyvsp[0].TypeVal).T;
5825 #line 3177 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5827 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
5828 const Type* DstTy = (yyvsp[0].TypeVal).T->get();
5829 ObsoleteVarArgs = true;
5830 Function* NF = cast<Function>(CurModule.CurrentModule->
5831 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
5833 //b = vanext a, t ->
5834 //foo = alloca 1 of t
5837 //tmp = vaarg foo, t
5839 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
5840 CurBB->getInstList().push_back(foo);
5841 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
5842 CurBB->getInstList().push_back(bar);
5843 CurBB->getInstList().push_back(new StoreInst(bar, foo));
5844 Instruction* tmp = new VAArgInst(foo, DstTy);
5845 CurBB->getInstList().push_back(tmp);
5846 (yyval.InstVal).I = new LoadInst(foo);
5847 (yyval.InstVal).S = (yyvsp[0].TypeVal).S;
5848 delete (yyvsp[0].TypeVal).T;
5853 #line 3201 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5855 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5856 error("Invalid extractelement operands");
5857 (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5858 (yyval.InstVal).S = (yyvsp[-2].ValueVal).S;
5863 #line 3207 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5865 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5866 error("Invalid insertelement operands");
5867 (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5868 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5873 #line 3213 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5875 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
5876 error("Invalid shufflevector operands");
5877 (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
5878 (yyval.InstVal).S = (yyvsp[-4].ValueVal).S;
5883 #line 3219 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5885 const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
5886 if (!Ty->isFirstClassType())
5887 error("PHI node operands must be of first class type");
5888 PHINode *PHI = new PHINode(Ty);
5889 PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
5890 while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
5891 if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
5892 error("All elements of a PHI node must be of the same type");
5893 PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
5894 (yyvsp[0].PHIList).P->pop_front();
5896 (yyval.InstVal).I = PHI;
5897 (yyval.InstVal).S = (yyvsp[0].PHIList).S;
5898 delete (yyvsp[0].PHIList).P; // Free the list...
5903 #line 3235 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5906 // Handle the short call syntax
5907 const PointerType *PFTy;
5908 const FunctionType *FTy;
5909 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).T->get())) ||
5910 !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5911 // Pull out the types of all of the arguments...
5912 std::vector<const Type*> ParamTypes;
5913 if ((yyvsp[-1].ValueList)) {
5914 for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
5916 ParamTypes.push_back((*I).V->getType());
5919 FunctionType::ParamAttrsList ParamAttrs;
5920 if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
5921 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5922 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5924 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5925 if (isVarArg) ParamTypes.pop_back();
5927 const Type *RetTy = (yyvsp[-4].TypeVal).T->get();
5928 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5929 error("Functions cannot return aggregate types");
5931 FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
5932 PFTy = PointerType::get(FTy);
5935 // First upgrade any intrinsic calls.
5936 std::vector<Value*> Args;
5937 if ((yyvsp[-1].ValueList))
5938 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
5939 Args.push_back((*(yyvsp[-1].ValueList))[i].V);
5940 Instruction *Inst = upgradeIntrinsicCall(FTy, (yyvsp[-3].ValIDVal), Args);
5942 // If we got an upgraded intrinsic
5944 (yyval.InstVal).I = Inst;
5945 (yyval.InstVal).S = Signless;
5947 // Get the function we're calling
5948 Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
5950 // Check the argument values match
5951 if (!(yyvsp[-1].ValueList)) { // Has no arguments?
5952 // Make sure no arguments is a good thing!
5953 if (FTy->getNumParams() != 0)
5954 error("No arguments passed to a function that expects arguments");
5955 } else { // Has arguments?
5956 // Loop through FunctionType's arguments and ensure they are specified
5959 FunctionType::param_iterator I = FTy->param_begin();
5960 FunctionType::param_iterator E = FTy->param_end();
5961 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
5963 for (; ArgI != ArgE && I != E; ++ArgI, ++I)
5964 if ((*ArgI).V->getType() != *I)
5965 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5966 (*I)->getDescription() + "'");
5968 if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
5969 error("Invalid number of parameters detected");
5972 // Create the call instruction
5973 CallInst *CI = new CallInst(V, Args);
5974 CI->setTailCall((yyvsp[-6].BoolVal));
5975 CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
5976 (yyval.InstVal).I = CI;
5977 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
5979 delete (yyvsp[-4].TypeVal).T;
5980 delete (yyvsp[-1].ValueList);
5985 #line 3313 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5987 (yyval.InstVal) = (yyvsp[0].InstVal);
5992 #line 3321 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5993 { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
5997 #line 3322 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5998 { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6002 #line 3326 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6003 { (yyval.BoolVal) = true; ;}
6007 #line 3327 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6008 { (yyval.BoolVal) = false; ;}
6012 #line 3331 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6014 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6015 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6016 (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6017 delete (yyvsp[-1].TypeVal).T;
6022 #line 3337 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6024 const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6025 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6026 (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6027 delete (yyvsp[-4].TypeVal).T;
6032 #line 3343 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6034 const Type *Ty = (yyvsp[-1].TypeVal).T->get();
6035 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6036 (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6037 delete (yyvsp[-1].TypeVal).T;
6042 #line 3349 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6044 const Type *Ty = (yyvsp[-4].TypeVal).T->get();
6045 (yyval.InstVal).S = (yyvsp[-4].TypeVal).S;
6046 (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6047 delete (yyvsp[-4].TypeVal).T;
6052 #line 3355 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6054 const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6055 if (!isa<PointerType>(PTy))
6056 error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6057 (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6058 (yyval.InstVal).S = Signless;
6063 #line 3362 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6065 const Type* Ty = (yyvsp[-1].TypeVal).T->get();
6066 (yyval.InstVal).S = (yyvsp[-1].TypeVal).S;
6067 if (!isa<PointerType>(Ty))
6068 error("Can't load from nonpointer type: " + Ty->getDescription());
6069 if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6070 error("Can't load from pointer of non-first-class type: " +
6071 Ty->getDescription());
6072 Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6073 (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6074 delete (yyvsp[-1].TypeVal).T;
6079 #line 3374 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6081 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).T->get());
6083 error("Can't store to a nonpointer type: " +
6084 (yyvsp[-1].TypeVal).T->get()->getDescription());
6085 const Type *ElTy = PTy->getElementType();
6086 if (ElTy != (yyvsp[-3].ValueVal).V->getType())
6087 error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6088 "' into space of type '" + ElTy->getDescription() + "'");
6089 Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6090 (yyval.InstVal).I = new StoreInst((yyvsp[-3].ValueVal).V, tmpVal, (yyvsp[-5].BoolVal));
6091 (yyval.InstVal).S = Signless;
6092 delete (yyvsp[-1].TypeVal).T;
6097 #line 3388 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6099 const Type* Ty = (yyvsp[-2].TypeVal).T->get();
6100 if (!isa<PointerType>(Ty))
6101 error("getelementptr insn requires pointer operand");
6103 std::vector<Value*> VIndices;
6104 upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6106 Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6107 (yyval.InstVal).I = new GetElementPtrInst(tmpVal, VIndices);
6108 (yyval.InstVal).S = Signless;
6109 delete (yyvsp[-2].TypeVal).T;
6110 delete (yyvsp[0].ValueList);
6118 /* Line 1126 of yacc.c. */
6119 #line 6120 "UpgradeParser.tab.c"
6125 YY_STACK_PRINT (yyss, yyssp);
6130 /* Now `shift' the result of the reduction. Determine what state
6131 that goes to, based on the state we popped back to and the rule
6132 number reduced by. */
6136 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6137 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6138 yystate = yytable[yystate];
6140 yystate = yydefgoto[yyn - YYNTOKENS];
6145 /*------------------------------------.
6146 | yyerrlab -- here on detecting error |
6147 `------------------------------------*/
6149 /* If not already recovering from an error, report this error. */
6154 yyn = yypact[yystate];
6156 if (YYPACT_NINF < yyn && yyn < YYLAST)
6158 int yytype = YYTRANSLATE (yychar);
6159 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6160 YYSIZE_T yysize = yysize0;
6162 int yysize_overflow = 0;
6164 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6165 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6169 /* This is so xgettext sees the translatable formats that are
6170 constructed on the fly. */
6171 YY_("syntax error, unexpected %s");
6172 YY_("syntax error, unexpected %s, expecting %s");
6173 YY_("syntax error, unexpected %s, expecting %s or %s");
6174 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6175 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6179 static char const yyunexpected[] = "syntax error, unexpected %s";
6180 static char const yyexpecting[] = ", expecting %s";
6181 static char const yyor[] = " or %s";
6182 char yyformat[sizeof yyunexpected
6183 + sizeof yyexpecting - 1
6184 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6185 * (sizeof yyor - 1))];
6186 char const *yyprefix = yyexpecting;
6188 /* Start YYX at -YYN if negative to avoid negative indexes in
6190 int yyxbegin = yyn < 0 ? -yyn : 0;
6192 /* Stay within bounds of both yycheck and yytname. */
6193 int yychecklim = YYLAST - yyn;
6194 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6197 yyarg[0] = yytname[yytype];
6198 yyfmt = yystpcpy (yyformat, yyunexpected);
6200 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6201 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6203 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6207 yyformat[sizeof yyunexpected - 1] = '\0';
6210 yyarg[yycount++] = yytname[yyx];
6211 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6212 yysize_overflow |= yysize1 < yysize;
6214 yyfmt = yystpcpy (yyfmt, yyprefix);
6218 yyf = YY_(yyformat);
6219 yysize1 = yysize + yystrlen (yyf);
6220 yysize_overflow |= yysize1 < yysize;
6223 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6224 yymsg = (char *) YYSTACK_ALLOC (yysize);
6227 /* Avoid sprintf, as that infringes on the user's name space.
6228 Don't have undefined behavior even if the translation
6229 produced a string with the wrong number of "%s"s. */
6232 while ((*yyp = *yyf))
6234 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6236 yyp += yytnamerr (yyp, yyarg[yyi++]);
6246 YYSTACK_FREE (yymsg);
6250 yyerror (YY_("syntax error"));
6251 goto yyexhaustedlab;
6255 #endif /* YYERROR_VERBOSE */
6256 yyerror (YY_("syntax error"));
6261 if (yyerrstatus == 3)
6263 /* If just tried and failed to reuse look-ahead token after an
6264 error, discard it. */
6266 if (yychar <= YYEOF)
6268 /* Return failure if at end of input. */
6269 if (yychar == YYEOF)
6274 yydestruct ("Error: discarding", yytoken, &yylval);
6279 /* Else will try to reuse look-ahead token after shifting the error
6284 /*---------------------------------------------------.
6285 | yyerrorlab -- error raised explicitly by YYERROR. |
6286 `---------------------------------------------------*/
6289 /* Pacify compilers like GCC when the user code never invokes
6290 YYERROR and the label yyerrorlab therefore never appears in user
6301 /*-------------------------------------------------------------.
6302 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6303 `-------------------------------------------------------------*/
6305 yyerrstatus = 3; /* Each real token shifted decrements this. */
6309 yyn = yypact[yystate];
6310 if (yyn != YYPACT_NINF)
6313 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6321 /* Pop the current state because it cannot handle the error token. */
6326 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6329 YY_STACK_PRINT (yyss, yyssp);
6338 /* Shift the error token. */
6339 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6345 /*-------------------------------------.
6346 | yyacceptlab -- YYACCEPT comes here. |
6347 `-------------------------------------*/
6352 /*-----------------------------------.
6353 | yyabortlab -- YYABORT comes here. |
6354 `-----------------------------------*/
6360 /*-------------------------------------------------.
6361 | yyexhaustedlab -- memory exhaustion comes here. |
6362 `-------------------------------------------------*/
6364 yyerror (YY_("memory exhausted"));
6370 if (yychar != YYEOF && yychar != YYEMPTY)
6371 yydestruct ("Cleanup: discarding lookahead",
6373 while (yyssp != yyss)
6375 yydestruct ("Cleanup: popping",
6376 yystos[*yyssp], yyvsp);
6381 YYSTACK_FREE (yyss);
6387 #line 3404 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6390 int yyerror(const char *ErrorMsg) {
6392 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6393 + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6394 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6395 if (yychar != YYEMPTY && yychar != 0)
6396 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6398 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6399 std::cout << "llvm-upgrade: parse failed.\n";
6403 void warning(const std::string& ErrorMsg) {
6405 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6406 + ":" + llvm::utostr((unsigned) Upgradelineno-1) + ": ";
6407 std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6408 if (yychar != YYEMPTY && yychar != 0)
6409 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6411 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6414 void error(const std::string& ErrorMsg, int LineNo) {
6415 if (LineNo == -1) LineNo = Upgradelineno;
6416 Upgradelineno = LineNo;
6417 yyerror(ErrorMsg.c_str());