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/ValueSymbolTable.h"
381 #include "llvm/Support/GetElementPtrTypeIterator.h"
382 #include "llvm/ADT/STLExtras.h"
383 #include "llvm/Support/MathExtras.h"
390 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
391 // relating to upreferences in the input stream.
393 //#define DEBUG_UPREFS 1
395 #define UR_OUT(X) std::cerr << X
400 #define YYERROR_VERBOSE 1
401 #define YYINCLUDED_STDLIB_H
407 int yyerror(const char*);
408 static void warning(const std::string& WarningMsg);
412 std::istream* LexInput;
413 static std::string CurFilename;
415 // This bool controls whether attributes are ever added to function declarations
416 // definitions and calls.
417 static bool AddAttributes = false;
419 static Module *ParserResult;
420 static bool ObsoleteVarArgs;
421 static bool NewVarArgs;
422 static BasicBlock *CurBB;
423 static GlobalVariable *CurGV;
425 // This contains info used when building the body of a function. It is
426 // destroyed when the function is completed.
428 typedef std::vector<Value *> ValueList; // Numbered defs
430 typedef std::pair<std::string,TypeInfo> RenameMapKey;
431 typedef std::map<RenameMapKey,std::string> RenameMapType;
434 ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
435 std::map<const Type *,ValueList> *FutureLateResolvers = 0);
437 static struct PerModuleInfo {
438 Module *CurrentModule;
439 std::map<const Type *, ValueList> Values; // Module level numbered definitions
440 std::map<const Type *,ValueList> LateResolveValues;
441 std::vector<PATypeHolder> Types;
442 std::vector<Signedness> TypeSigns;
443 std::map<std::string,Signedness> NamedTypeSigns;
444 std::map<std::string,Signedness> NamedValueSigns;
445 std::map<ValID, PATypeHolder> LateResolveTypes;
446 static Module::Endianness Endian;
447 static Module::PointerSize PointerSize;
448 RenameMapType RenameMap;
450 /// PlaceHolderInfo - When temporary placeholder objects are created, remember
451 /// how they were referenced and on which line of the input they came from so
452 /// that we can resolve them later and print error messages as appropriate.
453 std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
455 // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
456 // references to global values. Global values may be referenced before they
457 // are defined, and if so, the temporary object that they represent is held
458 // here. This is used for forward references of GlobalValues.
460 typedef std::map<std::pair<const PointerType *, ValID>, GlobalValue*>
462 GlobalRefsType GlobalRefs;
465 // If we could not resolve some functions at function compilation time
466 // (calls to functions before they are defined), resolve them now... Types
467 // are resolved when the constant pool has been completely parsed.
469 ResolveDefinitions(LateResolveValues);
471 // Check to make sure that all global value forward references have been
474 if (!GlobalRefs.empty()) {
475 std::string UndefinedReferences = "Unresolved global references exist:\n";
477 for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
479 UndefinedReferences += " " + I->first.first->getDescription() + " " +
480 I->first.second.getName() + "\n";
482 error(UndefinedReferences);
486 if (CurrentModule->getDataLayout().empty()) {
487 std::string dataLayout;
488 if (Endian != Module::AnyEndianness)
489 dataLayout.append(Endian == Module::BigEndian ? "E" : "e");
490 if (PointerSize != Module::AnyPointerSize) {
491 if (!dataLayout.empty())
493 dataLayout.append(PointerSize == Module::Pointer64 ?
494 "p:64:64" : "p:32:32");
496 CurrentModule->setDataLayout(dataLayout);
499 Values.clear(); // Clear out function local definitions
502 NamedTypeSigns.clear();
503 NamedValueSigns.clear();
507 // GetForwardRefForGlobal - Check to see if there is a forward reference
508 // for this global. If so, remove it from the GlobalRefs map and return it.
509 // If not, just return null.
510 GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
511 // Check to see if there is a forward reference to this global variable...
512 // if there is, eliminate it and patch the reference to use the new def'n.
513 GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
514 GlobalValue *Ret = 0;
515 if (I != GlobalRefs.end()) {
521 void setEndianness(Module::Endianness E) { Endian = E; }
522 void setPointerSize(Module::PointerSize sz) { PointerSize = sz; }
525 Module::Endianness PerModuleInfo::Endian = Module::AnyEndianness;
526 Module::PointerSize PerModuleInfo::PointerSize = Module::AnyPointerSize;
528 static struct PerFunctionInfo {
529 Function *CurrentFunction; // Pointer to current function being created
531 std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
532 std::map<const Type*, ValueList> LateResolveValues;
533 bool isDeclare; // Is this function a forward declararation?
534 GlobalValue::LinkageTypes Linkage;// Linkage for forward declaration.
536 /// BBForwardRefs - When we see forward references to basic blocks, keep
537 /// track of them here.
538 std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
539 std::vector<BasicBlock*> NumberedBlocks;
540 RenameMapType RenameMap;
543 inline PerFunctionInfo() {
546 Linkage = GlobalValue::ExternalLinkage;
549 inline void FunctionStart(Function *M) {
554 void FunctionDone() {
555 NumberedBlocks.clear();
557 // Any forward referenced blocks left?
558 if (!BBForwardRefs.empty()) {
559 error("Undefined reference to label " +
560 BBForwardRefs.begin()->first->getName());
564 // Resolve all forward references now.
565 ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
567 Values.clear(); // Clear out function local definitions
571 Linkage = GlobalValue::ExternalLinkage;
573 } CurFun; // Info for the current function...
575 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
577 /// This function is just a utility to make a Key value for the rename map.
578 /// The Key is a combination of the name, type, Signedness of the original
579 /// value (global/function). This just constructs the key and ensures that
580 /// named Signedness values are resolved to the actual Signedness.
581 /// @brief Make a key for the RenameMaps
582 static RenameMapKey makeRenameMapKey(const std::string &Name, const Type* Ty,
583 const Signedness &Sign) {
587 // Don't allow Named Signedness nodes because they won't match. The actual
588 // Signedness must be looked up in the NamedTypeSigns map.
589 TI.S.copy(CurModule.NamedTypeSigns[Sign.getName()]);
592 return std::make_pair(Name, TI);
596 //===----------------------------------------------------------------------===//
597 // Code to handle definitions of all the types
598 //===----------------------------------------------------------------------===//
600 static int InsertValue(Value *V,
601 std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
602 if (V->hasName()) return -1; // Is this a numbered definition?
604 // Yes, insert the value into the value table...
605 ValueList &List = ValueTab[V->getType()];
607 return List.size()-1;
610 static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
612 case ValID::NumberVal: // Is it a numbered definition?
613 // Module constants occupy the lowest numbered slots...
614 if ((unsigned)D.Num < CurModule.Types.size()) {
615 return CurModule.Types[(unsigned)D.Num];
618 case ValID::NameVal: // Is it a named definition?
619 if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
624 error("Internal parser error: Invalid symbol type reference");
628 // If we reached here, we referenced either a symbol that we don't know about
629 // or an id number that hasn't been read yet. We may be referencing something
630 // forward, so just create an entry to be resolved later and get to it...
632 if (DoNotImprovise) return 0; // Do we just want a null to be returned?
634 if (inFunctionScope()) {
635 if (D.Type == ValID::NameVal) {
636 error("Reference to an undefined type: '" + D.getName() + "'");
639 error("Reference to an undefined type: #" + itostr(D.Num));
644 std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
645 if (I != CurModule.LateResolveTypes.end())
648 Type *Typ = OpaqueType::get();
649 CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
653 /// This is like the getType method except that instead of looking up the type
654 /// for a given ID, it looks up that type's sign.
655 /// @brief Get the signedness of a referenced type
656 static Signedness getTypeSign(const ValID &D) {
658 case ValID::NumberVal: // Is it a numbered definition?
659 // Module constants occupy the lowest numbered slots...
660 if ((unsigned)D.Num < CurModule.TypeSigns.size()) {
661 return CurModule.TypeSigns[(unsigned)D.Num];
664 case ValID::NameVal: { // Is it a named definition?
665 std::map<std::string,Signedness>::const_iterator I =
666 CurModule.NamedTypeSigns.find(D.Name);
667 if (I != CurModule.NamedTypeSigns.end())
669 // Perhaps its a named forward .. just cache the name
677 // If we don't find it, its signless
683 /// This function is analagous to getElementType in LLVM. It provides the same
684 /// function except that it looks up the Signedness instead of the type. This is
685 /// used when processing GEP instructions that need to extract the type of an
686 /// indexed struct/array/ptr member.
687 /// @brief Look up an element's sign.
688 static Signedness getElementSign(const ValueInfo& VI,
689 const std::vector<Value*> &Indices) {
690 const Type *Ptr = VI.V->getType();
691 assert(isa<PointerType>(Ptr) && "Need pointer type");
695 while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
696 if (CurIdx == Indices.size())
699 Value *Index = Indices[CurIdx++];
700 assert(!isa<PointerType>(CT) || CurIdx == 1 && "Invalid type");
701 Ptr = CT->getTypeAtIndex(Index);
702 if (const Type* Ty = Ptr->getForwardedType())
704 assert(S.isComposite() && "Bad Signedness type");
705 if (isa<StructType>(CT)) {
706 S = S.get(cast<ConstantInt>(Index)->getZExtValue());
711 S = CurModule.NamedTypeSigns[S.getName()];
714 Result.makeComposite(S);
718 /// This function just translates a ConstantInfo into a ValueInfo and calls
719 /// getElementSign(ValueInfo,...). Its just a convenience.
720 /// @brief ConstantInfo version of getElementSign.
721 static Signedness getElementSign(const ConstInfo& CI,
722 const std::vector<Constant*> &Indices) {
726 std::vector<Value*> Idx;
727 for (unsigned i = 0; i < Indices.size(); ++i)
728 Idx.push_back(Indices[i]);
729 Signedness result = getElementSign(VI, Idx);
734 /// This function determines if two function types differ only in their use of
735 /// the sret parameter attribute in the first argument. If they are identical
736 /// in all other respects, it returns true. Otherwise, it returns false.
737 static bool FuncTysDifferOnlyBySRet(const FunctionType *F1,
738 const FunctionType *F2) {
739 if (F1->getReturnType() != F2->getReturnType() ||
740 F1->getNumParams() != F2->getNumParams() ||
741 F1->getParamAttrs(0) != F2->getParamAttrs(0))
743 unsigned SRetMask = ~unsigned(FunctionType::StructRetAttribute);
744 for (unsigned i = 0; i < F1->getNumParams(); ++i) {
745 if (F1->getParamType(i) != F2->getParamType(i) ||
746 unsigned(F1->getParamAttrs(i+1)) & SRetMask !=
747 unsigned(F2->getParamAttrs(i+1)) & SRetMask)
753 /// This function determines if the type of V and Ty differ only by the SRet
754 /// parameter attribute. This is a more generalized case of
755 /// FuncTysDIfferOnlyBySRet since it doesn't require FunctionType arguments.
756 static bool TypesDifferOnlyBySRet(Value *V, const Type* Ty) {
757 if (V->getType() == Ty)
759 const PointerType *PF1 = dyn_cast<PointerType>(Ty);
760 const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
762 const FunctionType* FT1 = dyn_cast<FunctionType>(PF1->getElementType());
763 const FunctionType* FT2 = dyn_cast<FunctionType>(PF2->getElementType());
765 return FuncTysDifferOnlyBySRet(FT1, FT2);
770 // The upgrade of csretcc to sret param attribute may have caused a function
771 // to not be found because the param attribute changed the type of the called
772 // function. This helper function, used in getExistingValue, detects that
773 // situation and bitcasts the function to the correct type.
774 static Value* handleSRetFuncTypeMerge(Value *V, const Type* Ty) {
775 // Handle degenerate cases
778 if (V->getType() == Ty)
781 const PointerType *PF1 = dyn_cast<PointerType>(Ty);
782 const PointerType *PF2 = dyn_cast<PointerType>(V->getType());
784 const FunctionType *FT1 = dyn_cast<FunctionType>(PF1->getElementType());
785 const FunctionType *FT2 = dyn_cast<FunctionType>(PF2->getElementType());
786 if (FT1 && FT2 && FuncTysDifferOnlyBySRet(FT1, FT2))
787 if (FT2->paramHasAttr(1, FunctionType::StructRetAttribute))
789 else if (Constant *C = dyn_cast<Constant>(V))
790 return ConstantExpr::getBitCast(C, PF1);
792 return new BitCastInst(V, PF1, "upgrd.cast", CurBB);
798 // getExistingValue - Look up the value specified by the provided type and
799 // the provided ValID. If the value exists and has already been defined, return
800 // it. Otherwise return null.
802 static Value *getExistingValue(const Type *Ty, const ValID &D) {
803 if (isa<FunctionType>(Ty)) {
804 error("Functions are not values and must be referenced as pointers");
808 case ValID::NumberVal: { // Is it a numbered definition?
809 unsigned Num = (unsigned)D.Num;
811 // Module constants occupy the lowest numbered slots...
812 std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
813 if (VI != CurModule.Values.end()) {
814 if (Num < VI->second.size())
815 return VI->second[Num];
816 Num -= VI->second.size();
819 // Make sure that our type is within bounds
820 VI = CurFun.Values.find(Ty);
821 if (VI == CurFun.Values.end()) return 0;
823 // Check that the number is within bounds...
824 if (VI->second.size() <= Num) return 0;
826 return VI->second[Num];
829 case ValID::NameVal: { // Is it a named definition?
830 // Get the name out of the ID
831 RenameMapKey Key = makeRenameMapKey(D.Name, Ty, D.S);
833 if (inFunctionScope()) {
834 // See if the name was renamed
835 RenameMapType::const_iterator I = CurFun.RenameMap.find(Key);
836 std::string LookupName;
837 if (I != CurFun.RenameMap.end())
838 LookupName = I->second;
841 ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
842 V = SymTab.lookup(LookupName);
843 if (V && V->getType() != Ty)
844 V = handleSRetFuncTypeMerge(V, Ty);
845 assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type");
848 RenameMapType::const_iterator I = CurModule.RenameMap.find(Key);
849 std::string LookupName;
850 if (I != CurModule.RenameMap.end())
851 LookupName = I->second;
854 V = CurModule.CurrentModule->getValueSymbolTable().lookup(LookupName);
855 if (V && V->getType() != Ty)
856 V = handleSRetFuncTypeMerge(V, Ty);
857 assert((!V || TypesDifferOnlyBySRet(V, Ty)) && "Found wrong type");
862 D.destroy(); // Free old strdup'd memory...
866 // Check to make sure that "Ty" is an integral type, and that our
867 // value will fit into the specified type...
868 case ValID::ConstSIntVal: // Is it a constant pool reference??
869 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
870 error("Signed integral constant '" + itostr(D.ConstPool64) +
871 "' is invalid for type '" + Ty->getDescription() + "'");
873 return ConstantInt::get(Ty, D.ConstPool64);
875 case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
876 if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
877 if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64))
878 error("Integral constant '" + utostr(D.UConstPool64) +
879 "' is invalid or out of range");
880 else // This is really a signed reference. Transmogrify.
881 return ConstantInt::get(Ty, D.ConstPool64);
883 return ConstantInt::get(Ty, D.UConstPool64);
885 case ValID::ConstFPVal: // Is it a floating point const pool reference?
886 if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
887 error("FP constant invalid for type");
888 return ConstantFP::get(Ty, D.ConstPoolFP);
890 case ValID::ConstNullVal: // Is it a null value?
891 if (!isa<PointerType>(Ty))
892 error("Cannot create a a non pointer null");
893 return ConstantPointerNull::get(cast<PointerType>(Ty));
895 case ValID::ConstUndefVal: // Is it an undef value?
896 return UndefValue::get(Ty);
898 case ValID::ConstZeroVal: // Is it a zero value?
899 return Constant::getNullValue(Ty);
901 case ValID::ConstantVal: // Fully resolved constant?
902 if (D.ConstantValue->getType() != Ty)
903 error("Constant expression type different from required type");
904 return D.ConstantValue;
906 case ValID::InlineAsmVal: { // Inline asm expression
907 const PointerType *PTy = dyn_cast<PointerType>(Ty);
908 const FunctionType *FTy =
909 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
910 if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints))
911 error("Invalid type for asm constraint string");
912 InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
913 D.IAD->HasSideEffects);
914 D.destroy(); // Free InlineAsmDescriptor.
918 assert(0 && "Unhandled case");
922 assert(0 && "Unhandled case");
926 // getVal - This function is identical to getExistingValue, except that if a
927 // value is not already defined, it "improvises" by creating a placeholder var
928 // that looks and acts just like the requested variable. When the value is
929 // defined later, all uses of the placeholder variable are replaced with the
932 static Value *getVal(const Type *Ty, const ValID &ID) {
933 if (Ty == Type::LabelTy)
934 error("Cannot use a basic block here");
936 // See if the value has already been defined.
937 Value *V = getExistingValue(Ty, ID);
940 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty))
941 error("Invalid use of a composite type");
943 // If we reached here, we referenced either a symbol that we don't know about
944 // or an id number that hasn't been read yet. We may be referencing something
945 // forward, so just create an entry to be resolved later and get to it...
946 V = new Argument(Ty);
948 // Remember where this forward reference came from. FIXME, shouldn't we try
949 // to recycle these things??
950 CurModule.PlaceHolderInfo.insert(
951 std::make_pair(V, std::make_pair(ID, Upgradelineno)));
953 if (inFunctionScope())
954 InsertValue(V, CurFun.LateResolveValues);
956 InsertValue(V, CurModule.LateResolveValues);
960 /// @brief This just makes any name given to it unique, up to MAX_UINT times.
961 static std::string makeNameUnique(const std::string& Name) {
962 static unsigned UniqueNameCounter = 1;
963 std::string Result(Name);
964 Result += ".upgrd." + llvm::utostr(UniqueNameCounter++);
968 /// getBBVal - This is used for two purposes:
969 /// * If isDefinition is true, a new basic block with the specified ID is being
971 /// * If isDefinition is true, this is a reference to a basic block, which may
972 /// or may not be a forward reference.
974 static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
975 assert(inFunctionScope() && "Can't get basic block at global scope");
981 error("Illegal label reference " + ID.getName());
983 case ValID::NumberVal: // Is it a numbered definition?
984 if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
985 CurFun.NumberedBlocks.resize(ID.Num+1);
986 BB = CurFun.NumberedBlocks[ID.Num];
988 case ValID::NameVal: // Is it a named definition?
990 if (Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name)) {
991 if (N->getType() != Type::LabelTy) {
992 // Register names didn't use to conflict with basic block names
993 // because of type planes. Now they all have to be unique. So, we just
994 // rename the register and treat this name as if no basic block
996 RenameMapKey Key = makeRenameMapKey(ID.Name, N->getType(), ID.S);
997 N->setName(makeNameUnique(N->getName()));
998 CurModule.RenameMap[Key] = N->getName();
1001 BB = cast<BasicBlock>(N);
1007 // See if the block has already been defined.
1009 // If this is the definition of the block, make sure the existing value was
1010 // just a forward reference. If it was a forward reference, there will be
1011 // an entry for it in the PlaceHolderInfo map.
1012 if (isDefinition && !CurFun.BBForwardRefs.erase(BB))
1013 // The existing value was a definition, not a forward reference.
1014 error("Redefinition of label " + ID.getName());
1016 ID.destroy(); // Free strdup'd memory.
1020 // Otherwise this block has not been seen before.
1021 BB = new BasicBlock("", CurFun.CurrentFunction);
1022 if (ID.Type == ValID::NameVal) {
1023 BB->setName(ID.Name);
1025 CurFun.NumberedBlocks[ID.Num] = BB;
1028 // If this is not a definition, keep track of it so we can use it as a forward
1030 if (!isDefinition) {
1031 // Remember where this forward reference came from.
1032 CurFun.BBForwardRefs[BB] = std::make_pair(ID, Upgradelineno);
1034 // The forward declaration could have been inserted anywhere in the
1035 // function: insert it into the correct place now.
1036 CurFun.CurrentFunction->getBasicBlockList().remove(BB);
1037 CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
1044 //===----------------------------------------------------------------------===//
1045 // Code to handle forward references in instructions
1046 //===----------------------------------------------------------------------===//
1048 // This code handles the late binding needed with statements that reference
1049 // values not defined yet... for example, a forward branch, or the PHI node for
1052 // This keeps a table (CurFun.LateResolveValues) of all such forward references
1053 // and back patchs after we are done.
1056 // ResolveDefinitions - If we could not resolve some defs at parsing
1057 // time (forward branches, phi functions for loops, etc...) resolve the
1061 ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
1062 std::map<const Type*,ValueList> *FutureLateResolvers) {
1064 // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
1065 for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
1066 E = LateResolvers.end(); LRI != E; ++LRI) {
1067 const Type* Ty = LRI->first;
1068 ValueList &List = LRI->second;
1069 while (!List.empty()) {
1070 Value *V = List.back();
1073 std::map<Value*, std::pair<ValID, int> >::iterator PHI =
1074 CurModule.PlaceHolderInfo.find(V);
1075 assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error");
1077 ValID &DID = PHI->second.first;
1079 Value *TheRealValue = getExistingValue(Ty, DID);
1081 V->replaceAllUsesWith(TheRealValue);
1083 CurModule.PlaceHolderInfo.erase(PHI);
1084 } else if (FutureLateResolvers) {
1085 // Functions have their unresolved items forwarded to the module late
1087 InsertValue(V, *FutureLateResolvers);
1089 if (DID.Type == ValID::NameVal) {
1090 error("Reference to an invalid definition: '" + DID.getName() +
1091 "' of type '" + V->getType()->getDescription() + "'",
1092 PHI->second.second);
1095 error("Reference to an invalid definition: #" +
1096 itostr(DID.Num) + " of type '" +
1097 V->getType()->getDescription() + "'", PHI->second.second);
1104 LateResolvers.clear();
1107 /// This function is used for type resolution and upref handling. When a type
1108 /// becomes concrete, this function is called to adjust the signedness for the
1110 static void ResolveTypeSign(const Type* oldTy, const Signedness &Sign) {
1111 std::string TyName = CurModule.CurrentModule->getTypeName(oldTy);
1112 if (!TyName.empty())
1113 CurModule.NamedTypeSigns[TyName] = Sign;
1116 /// ResolveTypeTo - A brand new type was just declared. This means that (if
1117 /// name is not null) things referencing Name can be resolved. Otherwise,
1118 /// things refering to the number can be resolved. Do this now.
1119 static void ResolveTypeTo(char *Name, const Type *ToTy, const Signedness& Sign){
1122 D = ValID::create(Name);
1124 D = ValID::create((int)CurModule.Types.size());
1127 CurModule.NamedTypeSigns[Name] = Sign;
1129 std::map<ValID, PATypeHolder>::iterator I =
1130 CurModule.LateResolveTypes.find(D);
1131 if (I != CurModule.LateResolveTypes.end()) {
1132 const Type *OldTy = I->second.get();
1133 ((DerivedType*)OldTy)->refineAbstractTypeTo(ToTy);
1134 CurModule.LateResolveTypes.erase(I);
1138 /// This is the implementation portion of TypeHasInteger. It traverses the
1139 /// type given, avoiding recursive types, and returns true as soon as it finds
1140 /// an integer type. If no integer type is found, it returns false.
1141 static bool TypeHasIntegerI(const Type *Ty, std::vector<const Type*> Stack) {
1142 // Handle some easy cases
1143 if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID))
1145 if (Ty->isInteger())
1147 if (const SequentialType *STy = dyn_cast<SequentialType>(Ty))
1148 return STy->getElementType()->isInteger();
1150 // Avoid type structure recursion
1151 for (std::vector<const Type*>::iterator I = Stack.begin(), E = Stack.end();
1156 // Push us on the type stack
1157 Stack.push_back(Ty);
1159 if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
1160 if (TypeHasIntegerI(FTy->getReturnType(), Stack))
1162 FunctionType::param_iterator I = FTy->param_begin();
1163 FunctionType::param_iterator E = FTy->param_end();
1165 if (TypeHasIntegerI(*I, Stack))
1168 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1169 StructType::element_iterator I = STy->element_begin();
1170 StructType::element_iterator E = STy->element_end();
1171 for (; I != E; ++I) {
1172 if (TypeHasIntegerI(*I, Stack))
1177 // There shouldn't be anything else, but its definitely not integer
1178 assert(0 && "What type is this?");
1182 /// This is the interface to TypeHasIntegerI. It just provides the type stack,
1183 /// to avoid recursion, and then calls TypeHasIntegerI.
1184 static inline bool TypeHasInteger(const Type *Ty) {
1185 std::vector<const Type*> TyStack;
1186 return TypeHasIntegerI(Ty, TyStack);
1189 // setValueName - Set the specified value to the name given. The name may be
1190 // null potentially, in which case this is a noop. The string passed in is
1191 // assumed to be a malloc'd string buffer, and is free'd by this function.
1193 static void setValueName(const ValueInfo &V, char *NameStr) {
1195 std::string Name(NameStr); // Copy string
1196 free(NameStr); // Free old string
1198 if (V.V->getType() == Type::VoidTy) {
1199 error("Can't assign name '" + Name + "' to value with void type");
1203 assert(inFunctionScope() && "Must be in function scope");
1205 // Search the function's symbol table for an existing value of this name
1206 ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1207 Value* Existing = ST.lookup(Name);
1209 // An existing value of the same name was found. This might have happened
1210 // because of the integer type planes collapsing in LLVM 2.0.
1211 if (Existing->getType() == V.V->getType() &&
1212 !TypeHasInteger(Existing->getType())) {
1213 // If the type does not contain any integers in them then this can't be
1214 // a type plane collapsing issue. It truly is a redefinition and we
1215 // should error out as the assembly is invalid.
1216 error("Redefinition of value named '" + Name + "' of type '" +
1217 V.V->getType()->getDescription() + "'");
1220 // In LLVM 2.0 we don't allow names to be re-used for any values in a
1221 // function, regardless of Type. Previously re-use of names was okay as
1222 // long as they were distinct types. With type planes collapsing because
1223 // of the signedness change and because of PR411, this can no longer be
1224 // supported. We must search the entire symbol table for a conflicting
1225 // name and make the name unique. No warning is needed as this can't
1227 std::string NewName = makeNameUnique(Name);
1228 // We're changing the name but it will probably be used by other
1229 // instructions as operands later on. Consequently we have to retain
1230 // a mapping of the renaming that we're doing.
1231 RenameMapKey Key = makeRenameMapKey(Name, V.V->getType(), V.S);
1232 CurFun.RenameMap[Key] = NewName;
1241 /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
1242 /// this is a declaration, otherwise it is a definition.
1243 static GlobalVariable *
1244 ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
1245 bool isConstantGlobal, const Type *Ty,
1246 Constant *Initializer,
1247 const Signedness &Sign) {
1248 if (isa<FunctionType>(Ty))
1249 error("Cannot declare global vars of function type");
1251 const PointerType *PTy = PointerType::get(Ty);
1255 Name = NameStr; // Copy string
1256 free(NameStr); // Free old string
1259 // See if this global value was forward referenced. If so, recycle the
1262 if (!Name.empty()) {
1263 ID = ValID::create((char*)Name.c_str());
1265 ID = ValID::create((int)CurModule.Values[PTy].size());
1267 ID.S.makeComposite(Sign);
1269 if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1270 // Move the global to the end of the list, from whereever it was
1271 // previously inserted.
1272 GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1273 CurModule.CurrentModule->getGlobalList().remove(GV);
1274 CurModule.CurrentModule->getGlobalList().push_back(GV);
1275 GV->setInitializer(Initializer);
1276 GV->setLinkage(Linkage);
1277 GV->setConstant(isConstantGlobal);
1278 InsertValue(GV, CurModule.Values);
1282 // If this global has a name, check to see if there is already a definition
1283 // of this global in the module and emit warnings if there are conflicts.
1284 if (!Name.empty()) {
1285 // The global has a name. See if there's an existing one of the same name.
1286 if (CurModule.CurrentModule->getNamedGlobal(Name)) {
1287 // We found an existing global ov the same name. This isn't allowed
1288 // in LLVM 2.0. Consequently, we must alter the name of the global so it
1289 // can at least compile. This can happen because of type planes
1290 // There is alread a global of the same name which means there is a
1291 // conflict. Let's see what we can do about it.
1292 std::string NewName(makeNameUnique(Name));
1293 if (Linkage != GlobalValue::InternalLinkage) {
1294 // The linkage of this gval is external so we can't reliably rename
1295 // it because it could potentially create a linking problem.
1296 // However, we can't leave the name conflict in the output either or
1297 // it won't assemble with LLVM 2.0. So, all we can do is rename
1298 // this one to something unique and emit a warning about the problem.
1299 warning("Renaming global variable '" + Name + "' to '" + NewName +
1300 "' may cause linkage errors");
1303 // Put the renaming in the global rename map
1304 RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S);
1305 CurModule.RenameMap[Key] = NewName;
1312 // Otherwise there is no existing GV to use, create one now.
1313 GlobalVariable *GV =
1314 new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1315 CurModule.CurrentModule);
1316 InsertValue(GV, CurModule.Values);
1317 // Remember the sign of this global.
1318 CurModule.NamedValueSigns[Name] = ID.S;
1322 // setTypeName - Set the specified type to the name given. The name may be
1323 // null potentially, in which case this is a noop. The string passed in is
1324 // assumed to be a malloc'd string buffer, and is freed by this function.
1326 // This function returns true if the type has already been defined, but is
1327 // allowed to be redefined in the specified context. If the name is a new name
1328 // for the type plane, it is inserted and false is returned.
1329 static bool setTypeName(const PATypeInfo& TI, char *NameStr) {
1330 assert(!inFunctionScope() && "Can't give types function-local names");
1331 if (NameStr == 0) return false;
1333 std::string Name(NameStr); // Copy string
1334 free(NameStr); // Free old string
1336 const Type* Ty = TI.PAT->get();
1338 // We don't allow assigning names to void type
1339 if (Ty == Type::VoidTy) {
1340 error("Can't assign name '" + Name + "' to the void type");
1344 // Set the type name, checking for conflicts as we do so.
1345 bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, Ty);
1347 // Save the sign information for later use
1348 CurModule.NamedTypeSigns[Name] = TI.S;
1350 if (AlreadyExists) { // Inserting a name that is already defined???
1351 const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1352 assert(Existing && "Conflict but no matching type?");
1354 // There is only one case where this is allowed: when we are refining an
1355 // opaque type. In this case, Existing will be an opaque type.
1356 if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1357 // We ARE replacing an opaque type!
1358 const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(Ty);
1362 // Otherwise, this is an attempt to redefine a type. That's okay if
1363 // the redefinition is identical to the original. This will be so if
1364 // Existing and T point to the same Type object. In this one case we
1365 // allow the equivalent redefinition.
1366 if (Existing == Ty) return true; // Yes, it's equal.
1368 // Any other kind of (non-equivalent) redefinition is an error.
1369 error("Redefinition of type named '" + Name + "' in the '" +
1370 Ty->getDescription() + "' type plane");
1376 //===----------------------------------------------------------------------===//
1377 // Code for handling upreferences in type names...
1380 // TypeContains - Returns true if Ty directly contains E in it.
1382 static bool TypeContains(const Type *Ty, const Type *E) {
1383 return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1384 E) != Ty->subtype_end();
1388 struct UpRefRecord {
1389 // NestingLevel - The number of nesting levels that need to be popped before
1390 // this type is resolved.
1391 unsigned NestingLevel;
1393 // LastContainedTy - This is the type at the current binding level for the
1394 // type. Every time we reduce the nesting level, this gets updated.
1395 const Type *LastContainedTy;
1397 // UpRefTy - This is the actual opaque type that the upreference is
1398 // represented with.
1399 OpaqueType *UpRefTy;
1401 UpRefRecord(unsigned NL, OpaqueType *URTy)
1402 : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) { }
1406 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1407 static std::vector<UpRefRecord> UpRefs;
1409 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1410 /// called. It loops through the UpRefs vector, which is a list of the
1411 /// currently active types. For each type, if the up reference is contained in
1412 /// the newly completed type, we decrement the level count. When the level
1413 /// count reaches zero, the upreferenced type is the type that is passed in:
1414 /// thus we can complete the cycle.
1416 static PATypeHolder HandleUpRefs(const Type *ty, const Signedness& Sign) {
1417 // If Ty isn't abstract, or if there are no up-references in it, then there is
1418 // nothing to resolve here.
1419 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1421 PATypeHolder Ty(ty);
1422 UR_OUT("Type '" << Ty->getDescription() <<
1423 "' newly formed. Resolving upreferences.\n" <<
1424 UpRefs.size() << " upreferences active!\n");
1426 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1427 // to zero), we resolve them all together before we resolve them to Ty. At
1428 // the end of the loop, if there is anything to resolve to Ty, it will be in
1430 OpaqueType *TypeToResolve = 0;
1433 for (; i != UpRefs.size(); ++i) {
1434 UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1435 << UpRefs[i].UpRefTy->getDescription() << ") = "
1436 << (TypeContains(Ty, UpRefs[i].UpRefTy) ? "true" : "false") << "\n");
1437 if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1438 // Decrement level of upreference
1439 unsigned Level = --UpRefs[i].NestingLevel;
1440 UpRefs[i].LastContainedTy = Ty;
1441 UR_OUT(" Uplevel Ref Level = " << Level << "\n");
1442 if (Level == 0) { // Upreference should be resolved!
1443 if (!TypeToResolve) {
1444 TypeToResolve = UpRefs[i].UpRefTy;
1446 UR_OUT(" * Resolving upreference for "
1447 << UpRefs[i].UpRefTy->getDescription() << "\n";
1448 std::string OldName = UpRefs[i].UpRefTy->getDescription());
1449 ResolveTypeSign(UpRefs[i].UpRefTy, Sign);
1450 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1451 UR_OUT(" * Type '" << OldName << "' refined upreference to: "
1452 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1454 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
1455 --i; // Do not skip the next element...
1460 if (TypeToResolve) {
1461 UR_OUT(" * Resolving upreference for "
1462 << UpRefs[i].UpRefTy->getDescription() << "\n";
1463 std::string OldName = TypeToResolve->getDescription());
1464 ResolveTypeSign(TypeToResolve, Sign);
1465 TypeToResolve->refineAbstractTypeTo(Ty);
1471 bool Signedness::operator<(const Signedness &that) const {
1474 return *(this->name) < *(that.name);
1476 return CurModule.NamedTypeSigns[*name] < that;
1477 } else if (that.isNamed()) {
1478 return *this < CurModule.NamedTypeSigns[*that.name];
1481 if (isComposite() && that.isComposite()) {
1482 if (sv->size() == that.sv->size()) {
1483 SignVector::const_iterator thisI = sv->begin(), thisE = sv->end();
1484 SignVector::const_iterator thatI = that.sv->begin(),
1485 thatE = that.sv->end();
1486 for (; thisI != thisE; ++thisI, ++thatI) {
1487 if (*thisI < *thatI)
1489 else if (!(*thisI == *thatI))
1494 return sv->size() < that.sv->size();
1496 return kind < that.kind;
1499 bool Signedness::operator==(const Signedness &that) const {
1502 return *(this->name) == *(that.name);
1504 return CurModule.NamedTypeSigns[*(this->name)] == that;
1505 else if (that.isNamed())
1506 return *this == CurModule.NamedTypeSigns[*(that.name)];
1507 if (isComposite() && that.isComposite()) {
1508 if (sv->size() == that.sv->size()) {
1509 SignVector::const_iterator thisI = sv->begin(), thisE = sv->end();
1510 SignVector::const_iterator thatI = that.sv->begin(),
1511 thatE = that.sv->end();
1512 for (; thisI != thisE; ++thisI, ++thatI) {
1513 if (!(*thisI == *thatI))
1520 return kind == that.kind;
1523 void Signedness::copy(const Signedness &that) {
1524 if (that.isNamed()) {
1526 name = new std::string(*that.name);
1527 } else if (that.isComposite()) {
1529 sv = new SignVector();
1537 void Signedness::destroy() {
1540 } else if (isComposite()) {
1546 void Signedness::dump() const {
1547 if (isComposite()) {
1548 if (sv->size() == 1) {
1553 for (unsigned i = 0; i < sv->size(); ++i) {
1560 } else if (isNamed()) {
1562 } else if (isSigned()) {
1564 } else if (isUnsigned()) {
1571 static inline Instruction::TermOps
1572 getTermOp(TermOps op) {
1574 default : assert(0 && "Invalid OldTermOp");
1575 case RetOp : return Instruction::Ret;
1576 case BrOp : return Instruction::Br;
1577 case SwitchOp : return Instruction::Switch;
1578 case InvokeOp : return Instruction::Invoke;
1579 case UnwindOp : return Instruction::Unwind;
1580 case UnreachableOp: return Instruction::Unreachable;
1584 static inline Instruction::BinaryOps
1585 getBinaryOp(BinaryOps op, const Type *Ty, const Signedness& Sign) {
1587 default : assert(0 && "Invalid OldBinaryOps");
1593 case SetGT : assert(0 && "Should use getCompareOp");
1594 case AddOp : return Instruction::Add;
1595 case SubOp : return Instruction::Sub;
1596 case MulOp : return Instruction::Mul;
1598 // This is an obsolete instruction so we must upgrade it based on the
1599 // types of its operands.
1600 bool isFP = Ty->isFloatingPoint();
1601 if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
1602 // If its a vector type we want to use the element type
1603 isFP = PTy->getElementType()->isFloatingPoint();
1605 return Instruction::FDiv;
1606 else if (Sign.isSigned())
1607 return Instruction::SDiv;
1608 return Instruction::UDiv;
1610 case UDivOp : return Instruction::UDiv;
1611 case SDivOp : return Instruction::SDiv;
1612 case FDivOp : return Instruction::FDiv;
1614 // This is an obsolete instruction so we must upgrade it based on the
1615 // types of its operands.
1616 bool isFP = Ty->isFloatingPoint();
1617 if (const VectorType* PTy = dyn_cast<VectorType>(Ty))
1618 // If its a vector type we want to use the element type
1619 isFP = PTy->getElementType()->isFloatingPoint();
1620 // Select correct opcode
1622 return Instruction::FRem;
1623 else if (Sign.isSigned())
1624 return Instruction::SRem;
1625 return Instruction::URem;
1627 case URemOp : return Instruction::URem;
1628 case SRemOp : return Instruction::SRem;
1629 case FRemOp : return Instruction::FRem;
1630 case LShrOp : return Instruction::LShr;
1631 case AShrOp : return Instruction::AShr;
1632 case ShlOp : return Instruction::Shl;
1634 if (Sign.isSigned())
1635 return Instruction::AShr;
1636 return Instruction::LShr;
1637 case AndOp : return Instruction::And;
1638 case OrOp : return Instruction::Or;
1639 case XorOp : return Instruction::Xor;
1643 static inline Instruction::OtherOps
1644 getCompareOp(BinaryOps op, unsigned short &predicate, const Type* &Ty,
1645 const Signedness &Sign) {
1646 bool isSigned = Sign.isSigned();
1647 bool isFP = Ty->isFloatingPoint();
1649 default : assert(0 && "Invalid OldSetCC");
1652 predicate = FCmpInst::FCMP_OEQ;
1653 return Instruction::FCmp;
1655 predicate = ICmpInst::ICMP_EQ;
1656 return Instruction::ICmp;
1660 predicate = FCmpInst::FCMP_UNE;
1661 return Instruction::FCmp;
1663 predicate = ICmpInst::ICMP_NE;
1664 return Instruction::ICmp;
1668 predicate = FCmpInst::FCMP_OLE;
1669 return Instruction::FCmp;
1672 predicate = ICmpInst::ICMP_SLE;
1674 predicate = ICmpInst::ICMP_ULE;
1675 return Instruction::ICmp;
1679 predicate = FCmpInst::FCMP_OGE;
1680 return Instruction::FCmp;
1683 predicate = ICmpInst::ICMP_SGE;
1685 predicate = ICmpInst::ICMP_UGE;
1686 return Instruction::ICmp;
1690 predicate = FCmpInst::FCMP_OLT;
1691 return Instruction::FCmp;
1694 predicate = ICmpInst::ICMP_SLT;
1696 predicate = ICmpInst::ICMP_ULT;
1697 return Instruction::ICmp;
1701 predicate = FCmpInst::FCMP_OGT;
1702 return Instruction::FCmp;
1705 predicate = ICmpInst::ICMP_SGT;
1707 predicate = ICmpInst::ICMP_UGT;
1708 return Instruction::ICmp;
1713 static inline Instruction::MemoryOps getMemoryOp(MemoryOps op) {
1715 default : assert(0 && "Invalid OldMemoryOps");
1716 case MallocOp : return Instruction::Malloc;
1717 case FreeOp : return Instruction::Free;
1718 case AllocaOp : return Instruction::Alloca;
1719 case LoadOp : return Instruction::Load;
1720 case StoreOp : return Instruction::Store;
1721 case GetElementPtrOp : return Instruction::GetElementPtr;
1725 static inline Instruction::OtherOps
1726 getOtherOp(OtherOps op, const Signedness &Sign) {
1728 default : assert(0 && "Invalid OldOtherOps");
1729 case PHIOp : return Instruction::PHI;
1730 case CallOp : return Instruction::Call;
1731 case SelectOp : return Instruction::Select;
1732 case UserOp1 : return Instruction::UserOp1;
1733 case UserOp2 : return Instruction::UserOp2;
1734 case VAArg : return Instruction::VAArg;
1735 case ExtractElementOp : return Instruction::ExtractElement;
1736 case InsertElementOp : return Instruction::InsertElement;
1737 case ShuffleVectorOp : return Instruction::ShuffleVector;
1738 case ICmpOp : return Instruction::ICmp;
1739 case FCmpOp : return Instruction::FCmp;
1743 static inline Value*
1744 getCast(CastOps op, Value *Src, const Signedness &SrcSign, const Type *DstTy,
1745 const Signedness &DstSign, bool ForceInstruction = false) {
1746 Instruction::CastOps Opcode;
1747 const Type* SrcTy = Src->getType();
1749 if (SrcTy->isFloatingPoint() && isa<PointerType>(DstTy)) {
1750 // fp -> ptr cast is no longer supported but we must upgrade this
1751 // by doing a double cast: fp -> int -> ptr
1752 SrcTy = Type::Int64Ty;
1753 Opcode = Instruction::IntToPtr;
1754 if (isa<Constant>(Src)) {
1755 Src = ConstantExpr::getCast(Instruction::FPToUI,
1756 cast<Constant>(Src), SrcTy);
1758 std::string NewName(makeNameUnique(Src->getName()));
1759 Src = new FPToUIInst(Src, SrcTy, NewName, CurBB);
1761 } else if (isa<IntegerType>(DstTy) &&
1762 cast<IntegerType>(DstTy)->getBitWidth() == 1) {
1763 // cast type %x to bool was previously defined as setne type %x, null
1764 // The cast semantic is now to truncate, not compare so we must retain
1765 // the original intent by replacing the cast with a setne
1766 Constant* Null = Constant::getNullValue(SrcTy);
1767 Instruction::OtherOps Opcode = Instruction::ICmp;
1768 unsigned short predicate = ICmpInst::ICMP_NE;
1769 if (SrcTy->isFloatingPoint()) {
1770 Opcode = Instruction::FCmp;
1771 predicate = FCmpInst::FCMP_ONE;
1772 } else if (!SrcTy->isInteger() && !isa<PointerType>(SrcTy)) {
1773 error("Invalid cast to bool");
1775 if (isa<Constant>(Src) && !ForceInstruction)
1776 return ConstantExpr::getCompare(predicate, cast<Constant>(Src), Null);
1778 return CmpInst::create(Opcode, predicate, Src, Null);
1780 // Determine the opcode to use by calling CastInst::getCastOpcode
1782 CastInst::getCastOpcode(Src, SrcSign.isSigned(), DstTy,
1783 DstSign.isSigned());
1785 } else switch (op) {
1786 default: assert(0 && "Invalid cast token");
1787 case TruncOp: Opcode = Instruction::Trunc; break;
1788 case ZExtOp: Opcode = Instruction::ZExt; break;
1789 case SExtOp: Opcode = Instruction::SExt; break;
1790 case FPTruncOp: Opcode = Instruction::FPTrunc; break;
1791 case FPExtOp: Opcode = Instruction::FPExt; break;
1792 case FPToUIOp: Opcode = Instruction::FPToUI; break;
1793 case FPToSIOp: Opcode = Instruction::FPToSI; break;
1794 case UIToFPOp: Opcode = Instruction::UIToFP; break;
1795 case SIToFPOp: Opcode = Instruction::SIToFP; break;
1796 case PtrToIntOp: Opcode = Instruction::PtrToInt; break;
1797 case IntToPtrOp: Opcode = Instruction::IntToPtr; break;
1798 case BitCastOp: Opcode = Instruction::BitCast; break;
1801 if (isa<Constant>(Src) && !ForceInstruction)
1802 return ConstantExpr::getCast(Opcode, cast<Constant>(Src), DstTy);
1803 return CastInst::create(Opcode, Src, DstTy);
1806 static Instruction *
1807 upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
1808 std::vector<Value*>& Args) {
1810 std::string Name = ID.Type == ValID::NameVal ? ID.Name : "";
1813 if (Name == "llvm.isunordered.f32" || Name == "llvm.isunordered.f64") {
1814 if (Args.size() != 2)
1815 error("Invalid prototype for " + Name);
1816 return new FCmpInst(FCmpInst::FCMP_UNO, Args[0], Args[1]);
1820 if (Name.length() == 14 && !memcmp(&Name[5], "bswap.i", 7)) {
1821 const Type* ArgTy = Args[0]->getType();
1822 Name += ".i" + utostr(cast<IntegerType>(ArgTy)->getBitWidth());
1823 Function *F = cast<Function>(
1824 CurModule.CurrentModule->getOrInsertFunction(Name, RetTy, ArgTy,
1826 return new CallInst(F, Args[0]);
1830 if ((Name.length() <= 14 && !memcmp(&Name[5], "ctpop.i", 7)) ||
1831 (Name.length() <= 13 && !memcmp(&Name[5], "ctlz.i", 6)) ||
1832 (Name.length() <= 13 && !memcmp(&Name[5], "cttz.i", 6))) {
1833 // These intrinsics changed their result type.
1834 const Type* ArgTy = Args[0]->getType();
1835 Function *OldF = CurModule.CurrentModule->getFunction(Name);
1837 OldF->setName("upgrd.rm." + Name);
1839 Function *NewF = cast<Function>(
1840 CurModule.CurrentModule->getOrInsertFunction(Name, Type::Int32Ty,
1843 Instruction *Call = new CallInst(NewF, Args[0], "", CurBB);
1844 return CastInst::createIntegerCast(Call, RetTy, false);
1849 const Type* PtrTy = PointerType::get(Type::Int8Ty);
1850 std::vector<const Type*> Params;
1851 if (Name == "llvm.va_start" || Name == "llvm.va_end") {
1852 if (Args.size() != 1)
1853 error("Invalid prototype for " + Name + " prototype");
1854 Params.push_back(PtrTy);
1855 const FunctionType *FTy =
1856 FunctionType::get(Type::VoidTy, Params, false);
1857 const PointerType *PFTy = PointerType::get(FTy);
1858 Value* Func = getVal(PFTy, ID);
1859 Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
1860 return new CallInst(Func, &Args[0], Args.size());
1861 } else if (Name == "llvm.va_copy") {
1862 if (Args.size() != 2)
1863 error("Invalid prototype for " + Name + " prototype");
1864 Params.push_back(PtrTy);
1865 Params.push_back(PtrTy);
1866 const FunctionType *FTy =
1867 FunctionType::get(Type::VoidTy, Params, false);
1868 const PointerType *PFTy = PointerType::get(FTy);
1869 Value* Func = getVal(PFTy, ID);
1870 std::string InstName0(makeNameUnique("va0"));
1871 std::string InstName1(makeNameUnique("va1"));
1872 Args[0] = new BitCastInst(Args[0], PtrTy, InstName0, CurBB);
1873 Args[1] = new BitCastInst(Args[1], PtrTy, InstName1, CurBB);
1874 return new CallInst(Func, &Args[0], Args.size());
1881 const Type* upgradeGEPIndices(const Type* PTy,
1882 std::vector<ValueInfo> *Indices,
1883 std::vector<Value*> &VIndices,
1884 std::vector<Constant*> *CIndices = 0) {
1885 // Traverse the indices with a gep_type_iterator so we can build the list
1886 // of constant and value indices for use later. Also perform upgrades
1888 if (CIndices) CIndices->clear();
1889 for (unsigned i = 0, e = Indices->size(); i != e; ++i)
1890 VIndices.push_back((*Indices)[i].V);
1891 generic_gep_type_iterator<std::vector<Value*>::iterator>
1892 GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()),
1893 GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end());
1894 for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) {
1895 Value *Index = VIndices[i];
1896 if (CIndices && !isa<Constant>(Index))
1897 error("Indices to constant getelementptr must be constants");
1898 // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte
1899 // struct indices to i32 struct indices with ZExt for compatibility.
1900 else if (isa<StructType>(*GTI)) { // Only change struct indices
1901 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Index))
1902 if (CUI->getType()->getBitWidth() == 8)
1904 ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty);
1906 // Make sure that unsigned SequentialType indices are zext'd to
1907 // 64-bits if they were smaller than that because LLVM 2.0 will sext
1908 // all indices for SequentialType elements. We must retain the same
1909 // semantic (zext) for unsigned types.
1910 if (const IntegerType *Ity = dyn_cast<IntegerType>(Index->getType()))
1911 if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) {
1913 Index = ConstantExpr::getCast(Instruction::ZExt,
1914 cast<Constant>(Index), Type::Int64Ty);
1916 Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty,
1917 makeNameUnique("gep"), CurBB);
1918 VIndices[i] = Index;
1921 // Add to the CIndices list, if requested.
1923 CIndices->push_back(cast<Constant>(Index));
1927 GetElementPtrInst::getIndexedType(PTy, &VIndices[0], VIndices.size(), true);
1929 error("Index list invalid for constant getelementptr");
1933 unsigned upgradeCallingConv(unsigned CC) {
1935 case OldCallingConv::C : return CallingConv::C;
1936 case OldCallingConv::CSRet : return CallingConv::C;
1937 case OldCallingConv::Fast : return CallingConv::Fast;
1938 case OldCallingConv::Cold : return CallingConv::Cold;
1939 case OldCallingConv::X86_StdCall : return CallingConv::X86_StdCall;
1940 case OldCallingConv::X86_FastCall: return CallingConv::X86_FastCall;
1946 Module* UpgradeAssembly(const std::string &infile, std::istream& in,
1947 bool debug, bool addAttrs)
1950 CurFilename = infile;
1953 AddAttributes = addAttrs;
1954 ObsoleteVarArgs = false;
1957 CurModule.CurrentModule = new Module(CurFilename);
1959 // Check to make sure the parser succeeded
1962 delete ParserResult;
1963 std::cerr << "llvm-upgrade: parse failed.\n";
1967 // Check to make sure that parsing produced a result
1968 if (!ParserResult) {
1969 std::cerr << "llvm-upgrade: no parse result.\n";
1973 // Reset ParserResult variable while saving its value for the result.
1974 Module *Result = ParserResult;
1977 //Not all functions use vaarg, so make a second check for ObsoleteVarArgs
1980 if ((F = Result->getFunction("llvm.va_start"))
1981 && F->getFunctionType()->getNumParams() == 0)
1982 ObsoleteVarArgs = true;
1983 if((F = Result->getFunction("llvm.va_copy"))
1984 && F->getFunctionType()->getNumParams() == 1)
1985 ObsoleteVarArgs = true;
1988 if (ObsoleteVarArgs && NewVarArgs) {
1989 error("This file is corrupt: it uses both new and old style varargs");
1993 if(ObsoleteVarArgs) {
1994 if(Function* F = Result->getFunction("llvm.va_start")) {
1995 if (F->arg_size() != 0) {
1996 error("Obsolete va_start takes 0 argument");
2002 //bar = alloca typeof(foo)
2006 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2007 const Type* ArgTy = F->getFunctionType()->getReturnType();
2008 const Type* ArgTyPtr = PointerType::get(ArgTy);
2009 Function* NF = cast<Function>(Result->getOrInsertFunction(
2010 "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
2012 while (!F->use_empty()) {
2013 CallInst* CI = cast<CallInst>(F->use_back());
2014 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
2015 new CallInst(NF, bar, "", CI);
2016 Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
2017 CI->replaceAllUsesWith(foo);
2018 CI->getParent()->getInstList().erase(CI);
2020 Result->getFunctionList().erase(F);
2023 if(Function* F = Result->getFunction("llvm.va_end")) {
2024 if(F->arg_size() != 1) {
2025 error("Obsolete va_end takes 1 argument");
2031 //bar = alloca 1 of typeof(foo)
2033 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2034 const Type* ArgTy = F->getFunctionType()->getParamType(0);
2035 const Type* ArgTyPtr = PointerType::get(ArgTy);
2036 Function* NF = cast<Function>(Result->getOrInsertFunction(
2037 "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
2039 while (!F->use_empty()) {
2040 CallInst* CI = cast<CallInst>(F->use_back());
2041 AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
2042 new StoreInst(CI->getOperand(1), bar, CI);
2043 new CallInst(NF, bar, "", CI);
2044 CI->getParent()->getInstList().erase(CI);
2046 Result->getFunctionList().erase(F);
2049 if(Function* F = Result->getFunction("llvm.va_copy")) {
2050 if(F->arg_size() != 1) {
2051 error("Obsolete va_copy takes 1 argument");
2056 //a = alloca 1 of typeof(foo)
2057 //b = alloca 1 of typeof(foo)
2062 const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
2063 const Type* ArgTy = F->getFunctionType()->getReturnType();
2064 const Type* ArgTyPtr = PointerType::get(ArgTy);
2065 Function* NF = cast<Function>(Result->getOrInsertFunction(
2066 "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
2068 while (!F->use_empty()) {
2069 CallInst* CI = cast<CallInst>(F->use_back());
2070 AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
2071 AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
2072 new StoreInst(CI->getOperand(1), b, CI);
2073 new CallInst(NF, a, b, "", CI);
2074 Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
2075 CI->replaceAllUsesWith(foo);
2076 CI->getParent()->getInstList().erase(CI);
2078 Result->getFunctionList().erase(F);
2085 } // end llvm namespace
2087 using namespace llvm;
2091 /* Enabling traces. */
2096 /* Enabling verbose error messages. */
2097 #ifdef YYERROR_VERBOSE
2098 # undef YYERROR_VERBOSE
2099 # define YYERROR_VERBOSE 1
2101 # define YYERROR_VERBOSE 0
2104 /* Enabling the token table. */
2105 #ifndef YYTOKEN_TABLE
2106 # define YYTOKEN_TABLE 0
2109 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
2110 #line 1731 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
2111 typedef union YYSTYPE {
2112 llvm::Module *ModuleVal;
2113 llvm::Function *FunctionVal;
2114 std::pair<llvm::PATypeInfo, char*> *ArgVal;
2115 llvm::BasicBlock *BasicBlockVal;
2116 llvm::TermInstInfo TermInstVal;
2117 llvm::InstrInfo InstVal;
2118 llvm::ConstInfo ConstVal;
2119 llvm::ValueInfo ValueVal;
2120 llvm::PATypeInfo TypeVal;
2121 llvm::TypeInfo PrimType;
2122 llvm::PHIListInfo PHIList;
2123 std::list<llvm::PATypeInfo> *TypeList;
2124 std::vector<llvm::ValueInfo> *ValueList;
2125 std::vector<llvm::ConstInfo> *ConstVector;
2128 std::vector<std::pair<llvm::PATypeInfo,char*> > *ArgList;
2129 // Represent the RHS of PHI node
2130 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
2132 llvm::GlobalValue::LinkageTypes Linkage;
2140 char *StrVal; // This memory is strdup'd!
2141 llvm::ValID ValIDVal; // strdup'd memory maybe!
2143 llvm::BinaryOps BinaryOpVal;
2144 llvm::TermOps TermOpVal;
2145 llvm::MemoryOps MemOpVal;
2146 llvm::OtherOps OtherOpVal;
2147 llvm::CastOps CastOpVal;
2148 llvm::ICmpInst::Predicate IPred;
2149 llvm::FCmpInst::Predicate FPred;
2150 llvm::Module::Endianness Endianness;
2152 /* Line 196 of yacc.c. */
2153 #line 2154 "UpgradeParser.tab.c"
2154 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2155 # define YYSTYPE_IS_DECLARED 1
2156 # define YYSTYPE_IS_TRIVIAL 1
2161 /* Copy the second part of user declarations. */
2164 /* Line 219 of yacc.c. */
2165 #line 2166 "UpgradeParser.tab.c"
2167 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2168 # define YYSIZE_T __SIZE_TYPE__
2170 #if ! defined (YYSIZE_T) && defined (size_t)
2171 # define YYSIZE_T size_t
2173 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
2174 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2175 # define YYSIZE_T size_t
2177 #if ! defined (YYSIZE_T)
2178 # define YYSIZE_T unsigned int
2184 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
2185 # define YY_(msgid) dgettext ("bison-runtime", msgid)
2189 # define YY_(msgid) msgid
2193 #if ! defined (yyoverflow) || YYERROR_VERBOSE
2195 /* The parser invokes alloca or malloc; define the necessary symbols. */
2197 # ifdef YYSTACK_USE_ALLOCA
2198 # if YYSTACK_USE_ALLOCA
2200 # define YYSTACK_ALLOC __builtin_alloca
2202 # define YYSTACK_ALLOC alloca
2203 # if defined (__STDC__) || defined (__cplusplus)
2204 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
2205 # define YYINCLUDED_STDLIB_H
2211 # ifdef YYSTACK_ALLOC
2212 /* Pacify GCC's `empty if-body' warning. */
2213 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
2214 # ifndef YYSTACK_ALLOC_MAXIMUM
2215 /* The OS might guarantee only one guard page at the bottom of the stack,
2216 and a page size can be as small as 4096 bytes. So we cannot safely
2217 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
2218 to allow for a few compiler-allocated temporary stack slots. */
2219 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
2222 # define YYSTACK_ALLOC YYMALLOC
2223 # define YYSTACK_FREE YYFREE
2224 # ifndef YYSTACK_ALLOC_MAXIMUM
2225 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
2231 # define YYMALLOC malloc
2232 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
2233 && (defined (__STDC__) || defined (__cplusplus)))
2234 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
2238 # define YYFREE free
2239 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
2240 && (defined (__STDC__) || defined (__cplusplus)))
2241 void free (void *); /* INFRINGES ON USER NAME SPACE */
2248 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
2251 #if (! defined (yyoverflow) \
2252 && (! defined (__cplusplus) \
2253 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
2255 /* A type that is properly aligned for any stack member. */
2262 /* The size of the maximum gap between one aligned stack and the next. */
2263 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
2265 /* The size of an array large to enough to hold all stacks, each with
2267 # define YYSTACK_BYTES(N) \
2268 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
2269 + YYSTACK_GAP_MAXIMUM)
2271 /* Copy COUNT objects from FROM to TO. The source and destination do
2274 # if defined (__GNUC__) && 1 < __GNUC__
2275 # define YYCOPY(To, From, Count) \
2276 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
2278 # define YYCOPY(To, From, Count) \
2282 for (yyi = 0; yyi < (Count); yyi++) \
2283 (To)[yyi] = (From)[yyi]; \
2289 /* Relocate STACK from its old location to the new one. The
2290 local variables YYSIZE and YYSTACKSIZE give the old and new number of
2291 elements in the stack, and YYPTR gives the new location of the
2292 stack. Advance YYPTR to a properly aligned location for the next
2294 # define YYSTACK_RELOCATE(Stack) \
2297 YYSIZE_T yynewbytes; \
2298 YYCOPY (&yyptr->Stack, Stack, yysize); \
2299 Stack = &yyptr->Stack; \
2300 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2301 yyptr += yynewbytes / sizeof (*yyptr); \
2307 #if defined (__STDC__) || defined (__cplusplus)
2308 typedef signed char yysigned_char;
2310 typedef short int yysigned_char;
2313 /* YYFINAL -- State number of the termination state. */
2315 /* YYLAST -- Last index in YYTABLE. */
2318 /* YYNTOKENS -- Number of terminals. */
2319 #define YYNTOKENS 166
2320 /* YYNNTS -- Number of nonterminals. */
2322 /* YYNRULES -- Number of rules. */
2323 #define YYNRULES 310
2324 /* YYNRULES -- Number of states. */
2325 #define YYNSTATES 606
2327 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
2328 #define YYUNDEFTOK 2
2329 #define YYMAXUTOK 406
2331 #define YYTRANSLATE(YYX) \
2332 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
2334 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
2335 static const unsigned char yytranslate[] =
2337 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2338 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2339 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2340 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2341 155, 156, 164, 2, 153, 2, 2, 2, 2, 2,
2342 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2343 160, 152, 161, 2, 2, 2, 2, 2, 2, 2,
2344 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2345 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2346 2, 157, 154, 159, 2, 2, 2, 2, 2, 165,
2347 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2348 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2349 158, 2, 2, 162, 2, 163, 2, 2, 2, 2,
2350 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2351 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2352 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2353 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2354 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2355 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2356 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2357 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2358 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2359 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2360 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2361 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2362 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2363 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2364 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2365 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2366 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2367 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2368 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2369 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2370 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2371 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2372 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2373 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2374 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2375 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2376 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2377 145, 146, 147, 148, 149, 150, 151
2381 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
2383 static const unsigned short int yyprhs[] =
2385 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
2386 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
2387 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
2388 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
2389 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
2390 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
2391 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
2392 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
2393 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
2394 179, 180, 181, 183, 185, 187, 189, 191, 193, 196,
2395 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
2396 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
2397 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
2398 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
2399 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
2400 340, 344, 351, 357, 360, 363, 366, 369, 372, 375,
2401 378, 381, 384, 387, 394, 400, 409, 416, 423, 430,
2402 438, 446, 453, 460, 469, 478, 482, 484, 486, 488,
2403 490, 493, 496, 501, 504, 506, 511, 514, 519, 520,
2404 528, 529, 537, 538, 546, 547, 555, 559, 564, 565,
2405 567, 569, 571, 575, 579, 583, 587, 591, 595, 597,
2406 598, 600, 602, 604, 605, 608, 612, 614, 616, 620,
2407 622, 623, 632, 634, 636, 637, 642, 644, 646, 649,
2408 650, 652, 654, 655, 656, 662, 663, 665, 667, 669,
2409 671, 673, 675, 677, 679, 681, 685, 687, 693, 695,
2410 697, 699, 701, 704, 707, 710, 714, 717, 718, 720,
2411 722, 724, 727, 730, 734, 744, 754, 763, 777, 779,
2412 781, 788, 794, 797, 804, 812, 814, 818, 820, 821,
2413 824, 826, 832, 838, 844, 851, 858, 861, 866, 871,
2414 878, 883, 888, 893, 898, 905, 912, 915, 923, 925,
2415 928, 929, 931, 932, 936, 943, 947, 954, 957, 962,
2419 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
2420 static const short int yyrhs[] =
2422 200, 0, -1, 5, -1, 6, -1, 3, -1, 4,
2423 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
2424 -1, 84, -1, 85, -1, 86, -1, 87, -1, 88,
2425 -1, 89, -1, 90, -1, 91, -1, 92, -1, 97,
2426 -1, 98, -1, 99, -1, 100, -1, 101, -1, 102,
2427 -1, 119, -1, 120, -1, 121, -1, 122, -1, 123,
2428 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
2429 -1, 129, -1, 130, -1, 131, -1, 132, -1, 133,
2430 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138,
2431 -1, 125, -1, 126, -1, 127, -1, 128, -1, 27,
2432 -1, 28, -1, 93, -1, 94, -1, 95, -1, 96,
2433 -1, 140, -1, 141, -1, 142, -1, 143, -1, 144,
2434 -1, 145, -1, 146, -1, 147, -1, 148, -1, 149,
2435 -1, 150, -1, 151, -1, 139, -1, 16, -1, 14,
2436 -1, 12, -1, 10, -1, 17, -1, 15, -1, 13,
2437 -1, 11, -1, 176, -1, 177, -1, 18, -1, 19,
2438 -1, 212, 152, -1, -1, 41, -1, 42, -1, 43,
2439 -1, 44, -1, 45, -1, 46, -1, 47, -1, -1,
2440 -1, 65, -1, 66, -1, 67, -1, 68, -1, 69,
2441 -1, 70, -1, 64, 4, -1, -1, 57, 4, -1,
2442 -1, 153, 57, 4, -1, 34, 24, -1, -1, 185,
2443 -1, -1, 153, 188, 187, -1, 185, -1, 57, 4,
2444 -1, 191, -1, 8, -1, 193, -1, 8, -1, 193,
2445 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
2446 -1, 14, -1, 15, -1, 16, -1, 17, -1, 18,
2447 -1, 19, -1, 21, -1, 192, -1, 48, -1, 229,
2448 -1, 154, 4, -1, 190, 155, 195, 156, -1, 157,
2449 4, 158, 193, 159, -1, 160, 4, 158, 193, 161,
2450 -1, 162, 194, 163, -1, 162, 163, -1, 160, 162,
2451 194, 163, 161, -1, 160, 162, 163, 161, -1, 193,
2452 164, -1, 193, -1, 194, 153, 193, -1, 194, -1,
2453 194, 153, 37, -1, 37, -1, -1, 191, 157, 198,
2454 159, -1, 191, 157, 159, -1, 191, 165, 24, -1,
2455 191, 160, 198, 161, -1, 191, 162, 198, 163, -1,
2456 191, 162, 163, -1, 191, 160, 162, 198, 163, 161,
2457 -1, 191, 160, 162, 163, 161, -1, 191, 38, -1,
2458 191, 39, -1, 191, 229, -1, 191, 197, -1, 191,
2459 26, -1, 176, 168, -1, 177, 4, -1, 9, 27,
2460 -1, 9, 28, -1, 179, 7, -1, 175, 155, 196,
2461 36, 191, 156, -1, 110, 155, 196, 244, 156, -1,
2462 112, 155, 196, 153, 196, 153, 196, 156, -1, 169,
2463 155, 196, 153, 196, 156, -1, 170, 155, 196, 153,
2464 196, 156, -1, 171, 155, 196, 153, 196, 156, -1,
2465 103, 172, 155, 196, 153, 196, 156, -1, 104, 173,
2466 155, 196, 153, 196, 156, -1, 174, 155, 196, 153,
2467 196, 156, -1, 114, 155, 196, 153, 196, 156, -1,
2468 115, 155, 196, 153, 196, 153, 196, 156, -1, 116,
2469 155, 196, 153, 196, 153, 196, 156, -1, 198, 153,
2470 196, -1, 196, -1, 32, -1, 33, -1, 201, -1,
2471 201, 222, -1, 201, 224, -1, 201, 62, 61, 207,
2472 -1, 201, 25, -1, 202, -1, 202, 180, 20, 189,
2473 -1, 202, 224, -1, 202, 62, 61, 207, -1, -1,
2474 202, 180, 181, 199, 196, 203, 187, -1, -1, 202,
2475 180, 50, 199, 191, 204, 187, -1, -1, 202, 180,
2476 45, 199, 191, 205, 187, -1, -1, 202, 180, 47,
2477 199, 191, 206, 187, -1, 202, 51, 209, -1, 202,
2478 58, 152, 210, -1, -1, 24, -1, 56, -1, 55,
2479 -1, 53, 152, 208, -1, 54, 152, 4, -1, 52,
2480 152, 24, -1, 71, 152, 24, -1, 157, 211, 159,
2481 -1, 211, 153, 24, -1, 24, -1, -1, 22, -1,
2482 24, -1, 212, -1, -1, 191, 213, -1, 215, 153,
2483 214, -1, 214, -1, 215, -1, 215, 153, 37, -1,
2484 37, -1, -1, 182, 189, 212, 155, 216, 156, 186,
2485 183, -1, 29, -1, 162, -1, -1, 181, 220, 217,
2486 218, -1, 30, -1, 163, -1, 232, 221, -1, -1,
2487 45, -1, 47, -1, -1, -1, 31, 225, 223, 226,
2488 217, -1, -1, 63, -1, 3, -1, 4, -1, 7,
2489 -1, 27, -1, 28, -1, 38, -1, 39, -1, 26,
2490 -1, 160, 198, 161, -1, 197, -1, 61, 227, 24,
2491 153, 24, -1, 167, -1, 212, -1, 229, -1, 228,
2492 -1, 191, 230, -1, 232, 233, -1, 219, 233, -1,
2493 234, 180, 236, -1, 234, 238, -1, -1, 23, -1,
2494 77, -1, 78, -1, 72, 231, -1, 72, 8, -1,
2495 73, 21, 230, -1, 73, 9, 230, 153, 21, 230,
2496 153, 21, 230, -1, 74, 178, 230, 153, 21, 230,
2497 157, 237, 159, -1, 74, 178, 230, 153, 21, 230,
2498 157, 159, -1, 75, 182, 189, 230, 155, 241, 156,
2499 36, 21, 230, 235, 21, 230, -1, 235, -1, 76,
2500 -1, 237, 178, 228, 153, 21, 230, -1, 178, 228,
2501 153, 21, 230, -1, 180, 243, -1, 191, 157, 230,
2502 153, 230, 159, -1, 239, 153, 157, 230, 153, 230,
2503 159, -1, 231, -1, 240, 153, 231, -1, 240, -1,
2504 -1, 60, 59, -1, 59, -1, 169, 191, 230, 153,
2505 230, -1, 170, 191, 230, 153, 230, -1, 171, 191,
2506 230, 153, 230, -1, 103, 172, 191, 230, 153, 230,
2507 -1, 104, 173, 191, 230, 153, 230, -1, 49, 231,
2508 -1, 174, 231, 153, 231, -1, 175, 231, 36, 191,
2509 -1, 112, 231, 153, 231, 153, 231, -1, 113, 231,
2510 153, 191, -1, 117, 231, 153, 191, -1, 118, 231,
2511 153, 191, -1, 114, 231, 153, 231, -1, 115, 231,
2512 153, 231, 153, 231, -1, 116, 231, 153, 231, 153,
2513 231, -1, 111, 239, -1, 242, 182, 189, 230, 155,
2514 241, 156, -1, 246, -1, 153, 240, -1, -1, 35,
2515 -1, -1, 105, 191, 184, -1, 105, 191, 153, 15,
2516 230, 184, -1, 106, 191, 184, -1, 106, 191, 153,
2517 15, 230, 184, -1, 107, 231, -1, 245, 108, 191,
2518 230, -1, 245, 109, 231, 153, 191, 230, -1, 110,
2522 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2523 static const unsigned short int yyrline[] =
2525 0, 1871, 1871, 1872, 1880, 1881, 1891, 1891, 1891, 1891,
2526 1891, 1891, 1891, 1891, 1891, 1891, 1891, 1895, 1895, 1895,
2527 1899, 1899, 1899, 1899, 1899, 1899, 1903, 1903, 1904, 1904,
2528 1905, 1905, 1906, 1906, 1907, 1907, 1911, 1911, 1912, 1912,
2529 1913, 1913, 1914, 1914, 1915, 1915, 1916, 1916, 1917, 1917,
2530 1918, 1919, 1922, 1922, 1922, 1922, 1926, 1926, 1926, 1926,
2531 1926, 1926, 1926, 1927, 1927, 1927, 1927, 1927, 1927, 1933,
2532 1933, 1933, 1933, 1937, 1937, 1937, 1937, 1941, 1941, 1945,
2533 1945, 1950, 1953, 1958, 1959, 1960, 1961, 1962, 1963, 1964,
2534 1965, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1986,
2535 1987, 1995, 1996, 2004, 2013, 2014, 2021, 2022, 2026, 2030,
2536 2046, 2047, 2054, 2055, 2062, 2070, 2070, 2070, 2070, 2070,
2537 2070, 2070, 2071, 2071, 2071, 2071, 2071, 2076, 2080, 2084,
2538 2089, 2098, 2116, 2122, 2135, 2146, 2150, 2163, 2167, 2181,
2539 2185, 2192, 2193, 2199, 2206, 2218, 2248, 2261, 2284, 2312,
2540 2334, 2345, 2367, 2378, 2387, 2392, 2451, 2458, 2466, 2473,
2541 2480, 2484, 2488, 2497, 2512, 2525, 2534, 2562, 2575, 2584,
2542 2590, 2596, 2607, 2613, 2619, 2630, 2631, 2640, 2641, 2653,
2543 2662, 2663, 2664, 2665, 2666, 2682, 2702, 2704, 2706, 2706,
2544 2713, 2713, 2721, 2721, 2729, 2729, 2738, 2740, 2742, 2747,
2545 2761, 2762, 2766, 2769, 2777, 2781, 2788, 2792, 2796, 2800,
2546 2808, 2808, 2812, 2813, 2817, 2825, 2830, 2838, 2839, 2846,
2547 2853, 2857, 3038, 3038, 3042, 3042, 3052, 3052, 3056, 3061,
2548 3062, 3063, 3067, 3068, 3067, 3080, 3081, 3086, 3087, 3088,
2549 3089, 3093, 3097, 3098, 3099, 3100, 3121, 3125, 3139, 3140,
2550 3145, 3145, 3153, 3163, 3166, 3175, 3186, 3191, 3200, 3211,
2551 3211, 3214, 3218, 3222, 3227, 3237, 3255, 3264, 3329, 3333,
2552 3340, 3352, 3367, 3397, 3407, 3417, 3421, 3428, 3429, 3433,
2553 3436, 3442, 3461, 3479, 3495, 3509, 3523, 3534, 3552, 3561,
2554 3570, 3577, 3598, 3622, 3628, 3634, 3640, 3656, 3740, 3748,
2555 3749, 3753, 3754, 3758, 3764, 3771, 3777, 3784, 3791, 3804,
2560 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2561 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2562 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2563 static const char *const yytname[] =
2565 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "SINTVAL",
2566 "UINTVAL", "FPVAL", "VOID", "BOOL", "SBYTE", "UBYTE", "SHORT", "USHORT",
2567 "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE", "TYPE", "LABEL",
2568 "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
2569 "ZEROINITIALIZER", "TRUETOK", "FALSETOK", "BEGINTOK", "ENDTOK",
2570 "DECLARE", "GLOBAL", "CONSTANT", "SECTION", "VOLATILE", "TO",
2571 "DOTDOTDOT", "NULL_TOK", "UNDEF", "CONST", "INTERNAL", "LINKONCE",
2572 "WEAK", "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
2573 "NOT", "EXTERNAL", "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE",
2574 "BIG", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
2575 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
2576 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
2577 "RET", "BR", "SWITCH", "INVOKE", "UNREACHABLE", "UNWIND", "EXCEPT",
2578 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
2579 "SREM", "FREM", "AND", "OR", "XOR", "SHL", "SHR", "ASHR", "LSHR",
2580 "SETLE", "SETGE", "SETLT", "SETGT", "SETEQ", "SETNE", "ICMP", "FCMP",
2581 "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", "PHI_TOK",
2582 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
2583 "VAARG_old", "VANEXT_old", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT",
2584 "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD",
2585 "UNO", "UEQ", "UNE", "CAST", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT",
2586 "FPTOUI", "FPTOSI", "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR",
2587 "BITCAST", "'='", "','", "'\\\\'", "'('", "')'", "'['", "'x'", "']'",
2588 "'<'", "'>'", "'{'", "'}'", "'*'", "'c'", "$accept", "INTVAL",
2589 "EINT64VAL", "ArithmeticOps", "LogicalOps", "SetCondOps", "IPredicates",
2590 "FPredicates", "ShiftOps", "CastOps", "SIntType", "UIntType", "IntType",
2591 "FPType", "OptAssign", "OptLinkage", "OptCallingConv", "OptAlign",
2592 "OptCAlign", "SectionString", "OptSection", "GlobalVarAttributes",
2593 "GlobalVarAttribute", "TypesV", "UpRTypesV", "Types", "PrimType",
2594 "UpRTypes", "TypeListI", "ArgTypeListI", "ConstVal", "ConstExpr",
2595 "ConstVector", "GlobalType", "Module", "FunctionList", "ConstPool", "@1",
2596 "@2", "@3", "@4", "AsmBlock", "BigOrLittle", "TargetDefinition",
2597 "LibrariesDefinition", "LibList", "Name", "OptName", "ArgVal",
2598 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
2599 "@5", "END", "Function", "FnDeclareLinkage", "FunctionProto", "@6", "@7",
2600 "OptSideEffect", "ConstValueRef", "SymbolicValueRef", "ValueRef",
2601 "ResolvedVal", "BasicBlockList", "BasicBlock", "InstructionList",
2602 "Unwind", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
2603 "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal", "IndexList",
2604 "OptVolatile", "MemoryInst", 0
2609 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2611 static const unsigned short int yytoknum[] =
2613 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2614 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2615 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2616 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2617 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2618 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2619 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2620 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2621 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2622 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2623 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2624 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
2625 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2626 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2627 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2628 405, 406, 61, 44, 92, 40, 41, 91, 120, 93,
2629 60, 62, 123, 125, 42, 99
2633 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2634 static const unsigned char yyr1[] =
2636 0, 166, 167, 167, 168, 168, 169, 169, 169, 169,
2637 169, 169, 169, 169, 169, 169, 169, 170, 170, 170,
2638 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
2639 172, 172, 172, 172, 172, 172, 173, 173, 173, 173,
2640 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
2641 173, 173, 174, 174, 174, 174, 175, 175, 175, 175,
2642 175, 175, 175, 175, 175, 175, 175, 175, 175, 176,
2643 176, 176, 176, 177, 177, 177, 177, 178, 178, 179,
2644 179, 180, 180, 181, 181, 181, 181, 181, 181, 181,
2645 181, 182, 182, 182, 182, 182, 182, 182, 182, 183,
2646 183, 184, 184, 185, 186, 186, 187, 187, 188, 188,
2647 189, 189, 190, 190, 191, 192, 192, 192, 192, 192,
2648 192, 192, 192, 192, 192, 192, 192, 193, 193, 193,
2649 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
2650 194, 195, 195, 195, 195, 196, 196, 196, 196, 196,
2651 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
2652 196, 196, 196, 197, 197, 197, 197, 197, 197, 197,
2653 197, 197, 197, 197, 197, 198, 198, 199, 199, 200,
2654 201, 201, 201, 201, 201, 202, 202, 202, 203, 202,
2655 204, 202, 205, 202, 206, 202, 202, 202, 202, 207,
2656 208, 208, 209, 209, 209, 209, 210, 211, 211, 211,
2657 212, 212, 213, 213, 214, 215, 215, 216, 216, 216,
2658 216, 217, 218, 218, 220, 219, 221, 221, 222, 223,
2659 223, 223, 225, 226, 224, 227, 227, 228, 228, 228,
2660 228, 228, 228, 228, 228, 228, 228, 228, 229, 229,
2661 230, 230, 231, 232, 232, 233, 234, 234, 234, 235,
2662 235, 236, 236, 236, 236, 236, 236, 236, 236, 236,
2663 237, 237, 238, 239, 239, 240, 240, 241, 241, 242,
2664 242, 243, 243, 243, 243, 243, 243, 243, 243, 243,
2665 243, 243, 243, 243, 243, 243, 243, 243, 243, 244,
2666 244, 245, 245, 246, 246, 246, 246, 246, 246, 246,
2670 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2671 static const unsigned char yyr2[] =
2673 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2674 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2675 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2676 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2677 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2678 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2679 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2680 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2681 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
2682 0, 0, 1, 1, 1, 1, 1, 1, 2, 0,
2683 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
2684 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2685 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2686 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
2687 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
2688 3, 6, 5, 2, 2, 2, 2, 2, 2, 2,
2689 2, 2, 2, 6, 5, 8, 6, 6, 6, 7,
2690 7, 6, 6, 8, 8, 3, 1, 1, 1, 1,
2691 2, 2, 4, 2, 1, 4, 2, 4, 0, 7,
2692 0, 7, 0, 7, 0, 7, 3, 4, 0, 1,
2693 1, 1, 3, 3, 3, 3, 3, 3, 1, 0,
2694 1, 1, 1, 0, 2, 3, 1, 1, 3, 1,
2695 0, 8, 1, 1, 0, 4, 1, 1, 2, 0,
2696 1, 1, 0, 0, 5, 0, 1, 1, 1, 1,
2697 1, 1, 1, 1, 1, 3, 1, 5, 1, 1,
2698 1, 1, 2, 2, 2, 3, 2, 0, 1, 1,
2699 1, 2, 2, 3, 9, 9, 8, 13, 1, 1,
2700 6, 5, 2, 6, 7, 1, 3, 1, 0, 2,
2701 1, 5, 5, 5, 6, 6, 2, 4, 4, 6,
2702 4, 4, 4, 4, 6, 6, 2, 7, 1, 2,
2703 0, 1, 0, 3, 6, 3, 6, 2, 4, 6,
2707 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2708 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2709 means the default is an error. */
2710 static const unsigned short int yydefact[] =
2712 198, 0, 90, 184, 1, 183, 232, 83, 84, 85,
2713 86, 87, 88, 89, 0, 224, 257, 180, 181, 257,
2714 210, 211, 0, 0, 0, 90, 0, 186, 229, 0,
2715 91, 258, 254, 82, 226, 227, 228, 253, 0, 0,
2716 0, 0, 196, 0, 0, 0, 0, 0, 0, 0,
2717 81, 230, 231, 233, 199, 182, 0, 92, 93, 94,
2718 95, 96, 97, 0, 0, 302, 256, 0, 0, 0,
2719 0, 209, 197, 187, 2, 3, 111, 115, 116, 117,
2720 118, 119, 120, 121, 122, 123, 124, 125, 126, 128,
2721 0, 0, 0, 0, 248, 185, 0, 110, 127, 114,
2722 249, 129, 177, 178, 0, 0, 0, 0, 91, 98,
2723 0, 222, 223, 225, 301, 0, 280, 0, 0, 0,
2724 0, 91, 269, 259, 260, 6, 7, 8, 9, 10,
2725 11, 12, 13, 14, 15, 16, 17, 18, 19, 52,
2726 53, 54, 55, 20, 21, 22, 23, 24, 25, 0,
2727 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2728 0, 0, 0, 68, 56, 57, 58, 59, 60, 61,
2729 62, 63, 64, 65, 66, 67, 0, 0, 0, 0,
2730 0, 268, 255, 91, 272, 0, 298, 204, 201, 200,
2731 202, 203, 205, 208, 0, 130, 0, 0, 0, 113,
2732 135, 139, 0, 144, 138, 192, 194, 190, 115, 116,
2733 117, 118, 119, 120, 121, 122, 123, 124, 125, 0,
2734 0, 0, 0, 188, 234, 0, 0, 286, 279, 262,
2735 261, 0, 0, 72, 76, 71, 75, 70, 74, 69,
2736 73, 77, 78, 0, 0, 26, 27, 28, 29, 30,
2737 31, 32, 33, 34, 35, 0, 50, 51, 46, 47,
2738 48, 49, 36, 37, 38, 39, 40, 41, 42, 43,
2739 44, 45, 0, 101, 101, 307, 0, 0, 296, 0,
2740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2741 0, 0, 0, 0, 0, 206, 0, 0, 0, 0,
2742 0, 134, 143, 141, 0, 106, 106, 106, 160, 161,
2743 4, 5, 158, 159, 162, 157, 153, 154, 0, 0,
2744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2745 0, 0, 0, 0, 156, 155, 106, 220, 237, 238,
2746 239, 244, 240, 241, 242, 243, 235, 0, 246, 251,
2747 250, 252, 0, 263, 0, 0, 0, 0, 0, 303,
2748 0, 305, 300, 0, 0, 0, 0, 0, 0, 0,
2749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2750 207, 112, 112, 137, 0, 140, 0, 131, 0, 193,
2751 195, 191, 0, 0, 0, 0, 0, 0, 0, 146,
2752 176, 0, 0, 0, 150, 0, 147, 0, 0, 0,
2753 0, 0, 189, 219, 213, 216, 217, 0, 236, 0,
2754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2755 310, 0, 0, 0, 290, 293, 0, 0, 291, 292,
2756 0, 0, 0, 287, 288, 0, 308, 0, 132, 133,
2757 136, 142, 0, 0, 108, 106, 0, 0, 300, 0,
2758 0, 0, 0, 0, 145, 135, 114, 0, 148, 149,
2759 0, 0, 0, 0, 0, 212, 214, 0, 104, 0,
2760 245, 0, 0, 278, 0, 0, 101, 102, 101, 275,
2761 299, 0, 0, 0, 0, 0, 281, 282, 283, 278,
2762 0, 103, 109, 107, 0, 0, 0, 0, 0, 0,
2763 0, 175, 152, 0, 0, 0, 0, 0, 0, 218,
2764 215, 105, 99, 0, 0, 0, 277, 0, 284, 285,
2765 0, 304, 306, 0, 0, 0, 289, 294, 295, 0,
2766 309, 0, 0, 164, 0, 0, 0, 0, 151, 0,
2767 0, 0, 0, 0, 0, 221, 247, 0, 0, 0,
2768 276, 273, 0, 297, 0, 0, 0, 172, 0, 0,
2769 166, 167, 168, 171, 163, 100, 0, 266, 0, 0,
2770 0, 274, 169, 170, 0, 0, 0, 264, 0, 265,
2771 0, 0, 165, 173, 174, 0, 0, 0, 0, 0,
2772 0, 271, 0, 0, 270, 267
2775 /* YYDEFGOTO[NTERM-NUM]. */
2776 static const short int yydefgoto[] =
2778 -1, 94, 312, 329, 330, 331, 255, 272, 332, 333,
2779 219, 220, 243, 221, 25, 15, 63, 555, 359, 454,
2780 522, 389, 455, 95, 96, 222, 98, 99, 202, 304,
2781 400, 348, 401, 104, 1, 2, 3, 336, 307, 305,
2782 306, 55, 190, 42, 72, 194, 100, 476, 415, 416,
2783 417, 64, 113, 16, 30, 36, 17, 53, 18, 28,
2784 108, 419, 349, 101, 351, 489, 19, 32, 33, 181,
2785 182, 579, 66, 278, 526, 527, 183, 184, 430, 185,
2789 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2791 #define YYPACT_NINF -542
2792 static const short int yypact[] =
2794 -542, 13, 162, 567, -542, -542, -542, -542, -542, -542,
2795 -542, -542, -542, -542, 83, -542, 19, -542, -542, -14,
2796 -542, -542, 50, -87, 87, 233, 27, -542, 123, 141,
2797 175, -542, -542, 98, -542, -542, -542, -542, 33, 40,
2798 66, 68, -542, 14, 141, 1265, 156, 156, 156, 156,
2799 -542, -542, -542, -542, -542, -542, 221, -542, -542, -542,
2800 -542, -542, -542, 1265, -19, 1479, -542, 204, 135, 226,
2801 227, 235, -542, -542, -542, -542, 81, -542, -542, -542,
2802 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2803 256, 257, 4, 15, -542, -542, 108, -542, -542, 12,
2804 -542, -542, -542, -542, 1306, 1306, 1306, 1326, 175, -542,
2805 98, -542, -542, -542, -542, 1306, -542, 205, 1367, 116,
2806 479, 175, -542, -542, -542, -542, -542, -542, -542, -542,
2807 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2808 -542, -542, -542, -542, -542, -542, -542, -542, -542, 355,
2809 429, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306, 1306,
2810 1306, 1306, 1306, -542, -542, -542, -542, -542, -542, -542,
2811 -542, -542, -542, -542, -542, -542, 1306, 1306, 1306, 1306,
2812 1306, -542, -542, 175, -542, 86, -542, -542, -542, -542,
2813 -542, -542, -542, -542, -13, -542, 110, 111, 75, -542,
2814 -542, 12, -81, 1046, -542, -542, -542, -542, 174, 208,
2815 266, 210, 267, 212, 268, 230, 277, 275, 278, 246,
2816 280, 279, 566, -542, -542, 136, 766, -542, -542, 81,
2817 -542, 766, 766, -542, -542, -542, -542, -542, -542, -542,
2818 -542, -542, -542, 766, 1265, -542, -542, -542, -542, -542,
2819 -542, -542, -542, -542, -542, 1306, -542, -542, -542, -542,
2820 -542, -542, -542, -542, -542, -542, -542, -542, -542, -542,
2821 -542, -542, 1306, 137, 145, -542, 766, 132, 146, 147,
2822 148, 149, 151, 152, 158, 160, 766, 766, 766, 161,
2823 281, 1265, 1306, 1306, 291, -542, 1306, 1306, 155, -27,
2824 1306, -542, -542, 165, 163, 176, 176, 176, -542, -542,
2825 -542, -542, -542, -542, -542, -542, -542, -542, 355, 429,
2826 172, 177, 178, 179, 182, 1087, 1387, 529, 311, 184,
2827 185, 186, 188, 189, -542, -542, 176, 1107, -542, -542,
2828 -542, -542, -542, -542, -542, -542, 282, 1326, -542, -542,
2829 -542, -542, 193, -542, 194, 766, 766, 766, 7, -542,
2830 20, -542, 195, 766, 192, 1306, 1306, 1306, 1306, 1306,
2831 1306, 1306, 200, 201, 206, 1306, 1306, 766, 766, 207,
2832 -542, -59, -149, -542, 196, 12, 1148, -542, 44, -542,
2833 -542, -542, 203, 211, 1326, 1326, 1326, 1326, 1326, -542,
2834 -542, -8, 741, -82, -542, 10, -542, 1326, 1326, 1326,
2835 1326, 1326, -542, -542, 98, -542, 214, 209, -542, 337,
2836 -34, 342, 348, 215, 218, 219, 766, 371, 766, 1306,
2837 -542, 223, 766, 224, -542, -542, 225, 234, -542, -542,
2838 766, 766, 766, -542, -542, 228, -542, 1306, -542, -542,
2839 -542, -542, 362, 375, -542, 176, 1326, 1326, 195, 236,
2840 237, 240, 243, 1326, -542, 238, -25, 11, -542, -542,
2841 244, 245, 247, 250, 352, -542, -542, 1205, 370, 252,
2842 -542, 766, 766, 1306, 766, 766, 258, -542, 258, -542,
2843 259, 766, 264, 1306, 1306, 1306, -542, -542, -542, 1306,
2844 766, -542, -542, -542, 270, 271, 263, 1326, 1326, 1326,
2845 1326, -542, -542, 260, 1326, 1326, 1326, 1326, 1306, -542,
2846 -542, -542, 368, 402, 274, 276, 259, 287, -542, -542,
2847 374, -542, -542, 1306, 285, 766, -542, -542, -542, 290,
2848 -542, 1326, 1326, -542, 283, 295, 284, 294, -542, 296,
2849 297, 299, 302, 303, 430, -542, -542, 414, 41, 425,
2850 -542, -542, 305, -542, 306, 310, 1326, -542, 1326, 1326,
2851 -542, -542, -542, -542, -542, -542, 766, -542, 893, 144,
2852 448, -542, -542, -542, 314, 315, 316, -542, 331, -542,
2853 893, 766, -542, -542, -542, 464, 334, 180, 766, 481,
2854 482, -542, 766, 766, -542, -542
2857 /* YYPGOTO[NTERM-NUM]. */
2858 static const short int yypgoto[] =
2860 -542, -542, -542, 435, 439, 441, 191, 197, 442, 445,
2861 -119, -116, -541, -542, 478, 489, -107, -542, -267, 37,
2862 -542, -238, -542, -60, -542, -45, -542, -74, -51, -542,
2863 -101, 300, -252, 134, -542, -542, -542, -542, -542, -542,
2864 -542, 473, -542, -542, -542, -542, 8, -542, 46, -542,
2865 -542, 410, -542, -542, -542, -542, -542, -542, 518, -542,
2866 -542, -542, -528, 142, -90, -113, -542, 505, -542, -72,
2867 -542, -542, -542, -542, 97, 28, -542, -542, 70, -542,
2871 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2872 positive, shift that token. If negative, reduce the rule which
2873 number is the opposite. If zero, do what YYDEFACT says.
2874 If YYTABLE_NINF, syntax error. */
2875 #define YYTABLE_NINF -180
2876 static const short int yytable[] =
2878 97, 241, 227, 110, 242, 230, 223, 361, 197, 31,
2879 111, 26, 449, 4, 244, 204, 34, 578, 97, 201,
2880 74, 75, 426, 199, 77, 78, 79, 80, 81, 82,
2881 83, 84, 85, 86, 87, 428, 88, 20, 590, 21,
2882 275, 26, 31, 279, 280, 281, 282, 283, 284, 285,
2883 588, 233, 234, 235, 236, 237, 238, 239, 240, 205,
2884 206, 207, 596, 89, 427, 43, 289, 290, 390, 391,
2885 226, 463, 300, 226, 403, 405, 291, 427, 452, 468,
2886 74, 75, 301, 199, 77, 78, 79, 80, 81, 82,
2887 83, 84, 85, 86, 87, 420, 88, 20, 412, 21,
2888 448, 453, 38, 39, 40, 204, 273, 274, 226, 276,
2889 277, 226, 226, 226, 226, 226, 226, 226, 225, 463,
2890 20, 41, 21, 89, 201, 231, 300, 480, -139, 201,
2891 -112, 286, 287, 288, 226, 226, 384, 232, -139, 204,
2892 294, 352, 353, 112, 29, 463, 295, 299, 44, 35,
2893 467, 464, 303, 354, 233, 234, 235, 236, 237, 238,
2894 239, 240, -179, 463, 463, 54, 198, -112, 51, 90,
2895 52, 71, 91, 469, 513, 92, 204, 93, 200, 50,
2896 379, 105, 106, 107, 355, 67, 362, 5, 102, 103,
2897 188, 189, 68, 6, 292, 293, 372, 373, 374, 97,
2898 577, 308, 309, 7, 8, 9, 10, 11, 12, 13,
2899 356, -72, -72, -71, -71, -70, -70, 503, 69, 531,
2900 70, 532, 381, 382, 14, 109, 385, 357, 187, 90,
2901 191, 377, 91, -69, -69, 92, -113, 93, 298, 56,
2902 57, 58, 59, 60, 61, 62, 97, 378, 226, 310,
2903 311, 192, 433, 45, 435, 436, 437, 123, 124, 193,
2904 195, 196, 443, 203, 228, 423, 424, 425, 296, 297,
2905 -76, -75, -74, 431, 7, 8, 9, 10, 46, 12,
2906 47, -73, -79, 48, 313, -80, 314, 445, 446, 363,
2907 358, 337, 414, 458, 459, 460, 461, 462, 360, 364,
2908 365, 366, 367, 589, 368, 369, 470, 471, 472, 473,
2909 474, 370, 385, 371, 375, 380, 383, 376, 386, 387,
2910 226, 434, 226, 226, 226, 438, 439, 394, 466, 388,
2911 226, 444, 395, 396, 397, 406, 486, 398, 488, 407,
2912 408, 409, 492, 410, 411, 418, 421, 422, 429, 432,
2913 496, 497, 498, 440, 441, 504, 505, 450, 456, 442,
2914 447, 479, 511, 481, 335, 478, 457, 477, 350, 482,
2915 483, 484, 485, 350, 350, 487, 491, 493, 494, 502,
2916 536, 537, 538, 499, 226, 350, 501, 495, 518, 507,
2917 508, 524, 525, 509, 528, 529, 510, 514, 515, 512,
2918 516, 534, 500, 517, 452, 523, 544, 545, 546, 547,
2919 540, 530, 533, 549, 550, 551, 552, 535, 350, 543,
2920 560, 548, 475, 541, 542, 554, 556, 557, 350, 350,
2921 350, 427, 414, 558, 575, 576, 566, 568, 226, 241,
2922 564, 565, 242, 559, 561, 562, 563, 569, 226, 226,
2923 226, 567, 570, 571, 226, 572, 256, 257, 573, 574,
2924 241, 580, 582, 242, 581, 584, 583, 585, 586, 591,
2925 592, 593, 594, 553, 245, 246, 247, 248, 249, 250,
2926 251, 252, 253, 254, 595, 598, 587, 599, 226, 233,
2927 234, 235, 236, 237, 238, 239, 240, 350, 350, 350,
2928 176, 597, 602, 603, 177, 350, 178, 179, 601, 392,
2929 180, 65, 604, 605, 49, 521, 393, 73, 224, 350,
2930 350, 27, 334, 520, 37, 600, 490, 539, 506, 0,
2931 0, 0, 0, 0, 74, 75, 0, 199, 208, 209,
2932 210, 211, 212, 213, 214, 215, 216, 217, 218, 0,
2933 88, 20, 0, 21, 258, 259, 260, 261, 262, 263,
2934 264, 265, 266, 267, 268, 269, 270, 271, 350, 0,
2935 350, 74, 75, 0, 350, 0, 0, 89, 0, 0,
2936 0, 0, 350, 350, 350, 0, 0, -82, 20, 20,
2937 21, 21, 315, 0, 0, 0, 0, 0, 6, -82,
2938 -82, 0, 0, 0, 316, 317, 0, 0, -82, -82,
2939 -82, -82, -82, -82, -82, 0, 0, -82, 22, 0,
2940 0, 0, 0, 350, 350, 23, 350, 350, 0, 24,
2941 0, 0, 0, 350, 0, 0, 0, 0, 0, 0,
2942 0, 0, 350, 0, 0, 125, 126, 127, 128, 129,
2943 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2944 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2945 319, 0, 0, 0, 0, 0, 320, 350, 321, 0,
2946 322, 323, 324, 90, 0, 0, 91, 0, 0, 92,
2947 0, 93, 404, 0, 0, 0, 0, 0, 0, 0,
2948 0, 0, 0, 0, 0, 163, 164, 165, 166, 167,
2949 168, 169, 170, 171, 172, 173, 174, 175, 350, 0,
2950 0, 0, 0, 325, 0, 0, 326, 0, 327, 0,
2951 0, 328, 0, 350, 0, 0, 0, 0, 0, 0,
2952 350, 0, 0, 0, 350, 350, 74, 75, 0, 199,
2953 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
2954 218, 0, 88, 20, 0, 21, 0, 0, 0, 338,
2955 339, 74, 75, 340, 0, 0, 0, 0, 0, 0,
2956 0, 0, 0, 0, 0, 0, 0, 0, 20, 89,
2957 21, 0, 341, 342, 343, 0, 0, 0, 0, 0,
2958 0, 0, 0, 0, 344, 345, 0, 0, 0, 0,
2959 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2960 0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2961 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2962 0, 0, 0, 0, 0, 125, 126, 127, 128, 129,
2963 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2964 140, 141, 142, 143, 144, 145, 146, 147, 148, 318,
2965 319, 0, 0, 0, 0, 0, 320, 0, 321, 0,
2966 322, 323, 324, 0, 0, 0, 0, 0, 0, 0,
2967 0, 0, 0, 0, 0, 90, 338, 339, 91, 0,
2968 340, 92, 0, 93, 465, 163, 164, 165, 166, 167,
2969 168, 169, 170, 171, 172, 173, 174, 175, 0, 341,
2970 342, 343, 0, 0, 0, 0, 347, 0, 0, 0,
2971 0, 344, 345, 0, 0, 0, 0, 0, 0, 0,
2972 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2973 0, 0, 0, 0, 346, 0, 0, 0, 0, 0,
2974 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975 0, 0, 125, 126, 127, 128, 129, 130, 131, 132,
2976 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2977 143, 144, 145, 146, 147, 148, 318, 319, 0, 0,
2978 0, 0, 0, 320, 0, 321, 0, 322, 323, 324,
2979 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2980 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2981 0, 0, 163, 164, 165, 166, 167, 168, 169, 170,
2982 171, 172, 173, 174, 175, 0, 0, 0, 0, 0,
2983 0, 74, 75, 347, 199, 77, 78, 79, 80, 81,
2984 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
2985 21, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2986 0, 0, 0, 302, 0, 0, 0, 0, 0, 0,
2987 0, 0, 74, 75, 89, 199, 208, 209, 210, 211,
2988 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
2989 0, 21, 74, 75, 0, 199, 77, 78, 79, 80,
2990 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
2991 0, 21, 0, 0, 0, 89, 0, 0, 0, 0,
2992 0, 0, 0, 0, 413, 0, 0, 0, 0, 0,
2993 0, 0, 0, 74, 75, 89, 199, 77, 78, 79,
2994 80, 81, 82, 83, 84, 85, 86, 87, 0, 88,
2995 20, 0, 21, 0, 0, 0, 0, 0, 0, 0,
2996 0, 0, 0, 0, 0, 451, 0, 0, 0, 0,
2997 0, 0, 0, 0, 0, 0, 89, 0, 0, 0,
2998 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
2999 74, 75, 0, 199, 77, 78, 79, 80, 81, 82,
3000 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
3001 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3002 0, 90, 519, 0, 91, 0, 399, 92, 0, 93,
3003 0, 0, 0, 89, 0, 0, 0, 0, 0, 0,
3004 0, 90, 0, 0, 91, 0, 0, 92, 0, 93,
3005 74, 75, 0, 76, 77, 78, 79, 80, 81, 82,
3006 83, 84, 85, 86, 87, 0, 88, 20, 0, 21,
3007 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3008 0, 0, 90, 0, 0, 91, 0, 0, 92, 0,
3009 93, 74, 75, 89, 199, 77, 78, 79, 80, 81,
3010 82, 83, 84, 85, 86, 87, 0, 88, 20, 0,
3011 21, 74, 75, 0, 199, 208, 209, 210, 211, 212,
3012 213, 214, 215, 216, 217, 218, 0, 88, 20, 0,
3013 21, 0, 0, 0, 89, 0, 0, 0, 0, 90,
3014 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
3015 0, 0, 74, 75, 89, 229, 77, 78, 79, 80,
3016 81, 82, 83, 84, 85, 86, 87, 0, 88, 20,
3017 0, 21, 74, 75, 0, 199, 208, 209, 210, 211,
3018 212, 213, 214, 215, 216, 217, 218, 0, 88, 20,
3019 0, 21, 0, 0, 0, 89, 0, 0, 0, 90,
3020 0, 0, 91, 0, 0, 92, 0, 93, 0, 0,
3021 0, 0, 0, 0, 0, 89, 0, 0, 0, 0,
3022 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3023 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3024 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
3025 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3026 90, 0, 0, 91, 0, 0, 92, 0, 93, 0,
3027 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3028 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029 0, 0, 0, 0, 114, 0, 0, 0, 0, 0,
3030 0, 90, 0, 0, 91, 0, 0, 92, 115, 93,
3031 0, 0, 0, 0, 0, 0, 0, 0, 116, 117,
3032 0, 90, 0, 0, 91, 0, 0, 92, 0, 402,
3033 0, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3034 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3035 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
3036 147, 148, 149, 150, 151, 152, 153, 0, 0, 154,
3037 155, 156, 157, 158, 159, 160, 161, 162, 0, 0,
3038 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3039 0, 0, 0, 0, 0, 0, 0, 0, 163, 164,
3040 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3044 static const short int yycheck[] =
3046 45, 120, 115, 63, 120, 118, 107, 274, 4, 23,
3047 29, 3, 161, 0, 121, 164, 30, 558, 63, 93,
3048 5, 6, 15, 8, 9, 10, 11, 12, 13, 14,
3049 15, 16, 17, 18, 19, 15, 21, 22, 579, 24,
3050 153, 33, 23, 156, 157, 158, 159, 160, 161, 162,
3051 578, 10, 11, 12, 13, 14, 15, 16, 17, 104,
3052 105, 106, 590, 48, 57, 152, 179, 180, 306, 307,
3053 115, 153, 153, 118, 326, 327, 183, 57, 34, 161,
3054 5, 6, 163, 8, 9, 10, 11, 12, 13, 14,
3055 15, 16, 17, 18, 19, 347, 21, 22, 336, 24,
3056 159, 57, 52, 53, 54, 164, 151, 152, 153, 154,
3057 155, 156, 157, 158, 159, 160, 161, 162, 110, 153,
3058 22, 71, 24, 48, 198, 9, 153, 161, 153, 203,
3059 155, 176, 177, 178, 179, 180, 163, 21, 163, 164,
3060 153, 231, 232, 162, 61, 153, 159, 198, 61, 163,
3061 402, 159, 203, 243, 10, 11, 12, 13, 14, 15,
3062 16, 17, 0, 153, 153, 24, 162, 155, 45, 154,
3063 47, 157, 157, 163, 163, 160, 164, 162, 163, 152,
3064 293, 47, 48, 49, 244, 152, 276, 25, 32, 33,
3065 55, 56, 152, 31, 108, 109, 286, 287, 288, 244,
3066 159, 27, 28, 41, 42, 43, 44, 45, 46, 47,
3067 255, 3, 4, 3, 4, 3, 4, 455, 152, 486,
3068 152, 488, 296, 297, 62, 4, 300, 272, 24, 154,
3069 4, 291, 157, 3, 4, 160, 155, 162, 163, 64,
3070 65, 66, 67, 68, 69, 70, 291, 292, 293, 3,
3071 4, 24, 365, 20, 367, 368, 369, 77, 78, 24,
3072 4, 4, 375, 155, 59, 355, 356, 357, 158, 158,
3073 4, 4, 4, 363, 41, 42, 43, 44, 45, 46,
3074 47, 4, 7, 50, 4, 7, 7, 377, 378, 157,
3075 153, 155, 337, 394, 395, 396, 397, 398, 153, 153,
3076 153, 153, 153, 159, 153, 153, 407, 408, 409, 410,
3077 411, 153, 386, 153, 153, 24, 161, 36, 153, 156,
3078 365, 366, 367, 368, 369, 370, 371, 155, 402, 153,
3079 375, 376, 155, 155, 155, 24, 426, 155, 428, 155,
3080 155, 155, 432, 155, 155, 63, 153, 153, 153, 157,
3081 440, 441, 442, 153, 153, 456, 457, 161, 155, 153,
3082 153, 24, 463, 21, 222, 156, 155, 153, 226, 21,
3083 155, 153, 153, 231, 232, 4, 153, 153, 153, 4,
3084 493, 494, 495, 155, 429, 243, 24, 153, 36, 153,
3085 153, 481, 482, 153, 484, 485, 153, 153, 153, 161,
3086 153, 491, 447, 153, 34, 153, 507, 508, 509, 510,
3087 500, 153, 153, 514, 515, 516, 517, 153, 276, 156,
3088 533, 161, 414, 153, 153, 57, 24, 153, 286, 287,
3089 288, 57, 477, 157, 4, 21, 153, 153, 483, 558,
3090 541, 542, 558, 156, 159, 535, 156, 153, 493, 494,
3091 495, 156, 156, 156, 499, 156, 27, 28, 156, 156,
3092 579, 36, 156, 579, 159, 566, 156, 568, 569, 21,
3093 156, 156, 156, 518, 119, 120, 121, 122, 123, 124,
3094 125, 126, 127, 128, 153, 21, 576, 153, 533, 10,
3095 11, 12, 13, 14, 15, 16, 17, 355, 356, 357,
3096 65, 591, 21, 21, 65, 363, 65, 65, 598, 318,
3097 65, 33, 602, 603, 25, 478, 319, 44, 108, 377,
3098 378, 3, 222, 477, 19, 597, 429, 499, 458, -1,
3099 -1, -1, -1, -1, 5, 6, -1, 8, 9, 10,
3100 11, 12, 13, 14, 15, 16, 17, 18, 19, -1,
3101 21, 22, -1, 24, 125, 126, 127, 128, 129, 130,
3102 131, 132, 133, 134, 135, 136, 137, 138, 426, -1,
3103 428, 5, 6, -1, 432, -1, -1, 48, -1, -1,
3104 -1, -1, 440, 441, 442, -1, -1, 20, 22, 22,
3105 24, 24, 26, -1, -1, -1, -1, -1, 31, 32,
3106 33, -1, -1, -1, 38, 39, -1, -1, 41, 42,
3107 43, 44, 45, 46, 47, -1, -1, 50, 51, -1,
3108 -1, -1, -1, 481, 482, 58, 484, 485, -1, 62,
3109 -1, -1, -1, 491, -1, -1, -1, -1, -1, -1,
3110 -1, -1, 500, -1, -1, 79, 80, 81, 82, 83,
3111 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3112 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3113 104, -1, -1, -1, -1, -1, 110, 535, 112, -1,
3114 114, 115, 116, 154, -1, -1, 157, -1, -1, 160,
3115 -1, 162, 163, -1, -1, -1, -1, -1, -1, -1,
3116 -1, -1, -1, -1, -1, 139, 140, 141, 142, 143,
3117 144, 145, 146, 147, 148, 149, 150, 151, 576, -1,
3118 -1, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3119 -1, 165, -1, 591, -1, -1, -1, -1, -1, -1,
3120 598, -1, -1, -1, 602, 603, 5, 6, -1, 8,
3121 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3122 19, -1, 21, 22, -1, 24, -1, -1, -1, 3,
3123 4, 5, 6, 7, -1, -1, -1, -1, -1, -1,
3124 -1, -1, -1, -1, -1, -1, -1, -1, 22, 48,
3125 24, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3126 -1, -1, -1, -1, 38, 39, -1, -1, -1, -1,
3127 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3128 -1, -1, -1, -1, -1, -1, -1, 61, -1, -1,
3129 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3130 -1, -1, -1, -1, -1, 79, 80, 81, 82, 83,
3131 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3132 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3133 104, -1, -1, -1, -1, -1, 110, -1, 112, -1,
3134 114, 115, 116, -1, -1, -1, -1, -1, -1, -1,
3135 -1, -1, -1, -1, -1, 154, 3, 4, 157, -1,
3136 7, 160, -1, 162, 163, 139, 140, 141, 142, 143,
3137 144, 145, 146, 147, 148, 149, 150, 151, -1, 26,
3138 27, 28, -1, -1, -1, -1, 160, -1, -1, -1,
3139 -1, 38, 39, -1, -1, -1, -1, -1, -1, -1,
3140 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3141 -1, -1, -1, -1, 61, -1, -1, -1, -1, -1,
3142 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3143 -1, -1, 79, 80, 81, 82, 83, 84, 85, 86,
3144 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
3145 97, 98, 99, 100, 101, 102, 103, 104, -1, -1,
3146 -1, -1, -1, 110, -1, 112, -1, 114, 115, 116,
3147 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3148 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3149 -1, -1, 139, 140, 141, 142, 143, 144, 145, 146,
3150 147, 148, 149, 150, 151, -1, -1, -1, -1, -1,
3151 -1, 5, 6, 160, 8, 9, 10, 11, 12, 13,
3152 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3153 24, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3154 -1, -1, -1, 37, -1, -1, -1, -1, -1, -1,
3155 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3156 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3157 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3158 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3159 -1, 24, -1, -1, -1, 48, -1, -1, -1, -1,
3160 -1, -1, -1, -1, 37, -1, -1, -1, -1, -1,
3161 -1, -1, -1, 5, 6, 48, 8, 9, 10, 11,
3162 12, 13, 14, 15, 16, 17, 18, 19, -1, 21,
3163 22, -1, 24, -1, -1, -1, -1, -1, -1, -1,
3164 -1, -1, -1, -1, -1, 37, -1, -1, -1, -1,
3165 -1, -1, -1, -1, -1, -1, 48, -1, -1, -1,
3166 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3167 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3168 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3169 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3170 -1, 154, 37, -1, 157, -1, 159, 160, -1, 162,
3171 -1, -1, -1, 48, -1, -1, -1, -1, -1, -1,
3172 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3173 5, 6, -1, 8, 9, 10, 11, 12, 13, 14,
3174 15, 16, 17, 18, 19, -1, 21, 22, -1, 24,
3175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3176 -1, -1, 154, -1, -1, 157, -1, -1, 160, -1,
3177 162, 5, 6, 48, 8, 9, 10, 11, 12, 13,
3178 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3179 24, 5, 6, -1, 8, 9, 10, 11, 12, 13,
3180 14, 15, 16, 17, 18, 19, -1, 21, 22, -1,
3181 24, -1, -1, -1, 48, -1, -1, -1, -1, 154,
3182 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3183 -1, -1, 5, 6, 48, 8, 9, 10, 11, 12,
3184 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3185 -1, 24, 5, 6, -1, 8, 9, 10, 11, 12,
3186 13, 14, 15, 16, 17, 18, 19, -1, 21, 22,
3187 -1, 24, -1, -1, -1, 48, -1, -1, -1, 154,
3188 -1, -1, 157, -1, -1, 160, -1, 162, -1, -1,
3189 -1, -1, -1, -1, -1, 48, -1, -1, -1, -1,
3190 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3192 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3194 154, -1, -1, 157, -1, -1, 160, -1, 162, -1,
3195 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3196 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3197 -1, -1, -1, -1, 35, -1, -1, -1, -1, -1,
3198 -1, 154, -1, -1, 157, -1, -1, 160, 49, 162,
3199 -1, -1, -1, -1, -1, -1, -1, -1, 59, 60,
3200 -1, 154, -1, -1, 157, -1, -1, 160, -1, 162,
3201 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3202 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
3203 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
3204 101, 102, 103, 104, 105, 106, 107, -1, -1, 110,
3205 111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
3206 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3207 -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
3208 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
3212 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3213 symbol of state STATE-NUM. */
3214 static const unsigned char yystos[] =
3216 0, 200, 201, 202, 0, 25, 31, 41, 42, 43,
3217 44, 45, 46, 47, 62, 181, 219, 222, 224, 232,
3218 22, 24, 51, 58, 62, 180, 212, 224, 225, 61,
3219 220, 23, 233, 234, 30, 163, 221, 233, 52, 53,
3220 54, 71, 209, 152, 61, 20, 45, 47, 50, 181,
3221 152, 45, 47, 223, 24, 207, 64, 65, 66, 67,
3222 68, 69, 70, 182, 217, 180, 238, 152, 152, 152,
3223 152, 157, 210, 207, 5, 6, 8, 9, 10, 11,
3224 12, 13, 14, 15, 16, 17, 18, 19, 21, 48,
3225 154, 157, 160, 162, 167, 189, 190, 191, 192, 193,
3226 212, 229, 32, 33, 199, 199, 199, 199, 226, 4,
3227 189, 29, 162, 218, 35, 49, 59, 60, 72, 73,
3228 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
3229 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
3230 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3231 104, 105, 106, 107, 110, 111, 112, 113, 114, 115,
3232 116, 117, 118, 139, 140, 141, 142, 143, 144, 145,
3233 146, 147, 148, 149, 150, 151, 169, 170, 171, 174,
3234 175, 235, 236, 242, 243, 245, 246, 24, 55, 56,
3235 208, 4, 24, 24, 211, 4, 4, 4, 162, 8,
3236 163, 193, 194, 155, 164, 191, 191, 191, 9, 10,
3237 11, 12, 13, 14, 15, 16, 17, 18, 19, 176,
3238 177, 179, 191, 196, 217, 212, 191, 231, 59, 8,
3239 231, 9, 21, 10, 11, 12, 13, 14, 15, 16,
3240 17, 176, 177, 178, 182, 119, 120, 121, 122, 123,
3241 124, 125, 126, 127, 128, 172, 27, 28, 125, 126,
3242 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3243 137, 138, 173, 191, 191, 231, 191, 191, 239, 231,
3244 231, 231, 231, 231, 231, 231, 191, 191, 191, 231,
3245 231, 182, 108, 109, 153, 159, 158, 158, 163, 194,
3246 153, 163, 37, 194, 195, 205, 206, 204, 27, 28,
3247 3, 4, 168, 4, 7, 26, 38, 39, 103, 104,
3248 110, 112, 114, 115, 116, 157, 160, 162, 165, 169,
3249 170, 171, 174, 175, 197, 229, 203, 155, 3, 4,
3250 7, 26, 27, 28, 38, 39, 61, 160, 197, 228,
3251 229, 230, 230, 230, 230, 189, 191, 191, 153, 184,
3252 153, 184, 230, 157, 153, 153, 153, 153, 153, 153,
3253 153, 153, 230, 230, 230, 153, 36, 189, 191, 231,
3254 24, 193, 193, 161, 163, 193, 153, 156, 153, 187,
3255 187, 187, 172, 173, 155, 155, 155, 155, 155, 159,
3256 196, 198, 162, 198, 163, 198, 24, 155, 155, 155,
3257 155, 155, 187, 37, 191, 214, 215, 216, 63, 227,
3258 198, 153, 153, 230, 230, 230, 15, 57, 15, 153,
3259 244, 230, 157, 231, 191, 231, 231, 231, 191, 191,
3260 153, 153, 153, 231, 191, 230, 230, 153, 159, 161,
3261 161, 37, 34, 57, 185, 188, 155, 155, 196, 196,
3262 196, 196, 196, 153, 159, 163, 193, 198, 161, 163,
3263 196, 196, 196, 196, 196, 212, 213, 153, 156, 24,
3264 161, 21, 21, 155, 153, 153, 230, 4, 230, 231,
3265 240, 153, 230, 153, 153, 153, 230, 230, 230, 155,
3266 191, 24, 4, 187, 196, 196, 244, 153, 153, 153,
3267 153, 196, 161, 163, 153, 153, 153, 153, 36, 37,
3268 214, 185, 186, 153, 230, 230, 240, 241, 230, 230,
3269 153, 184, 184, 153, 230, 153, 231, 231, 231, 241,
3270 230, 153, 153, 156, 196, 196, 196, 196, 161, 196,
3271 196, 196, 196, 191, 57, 183, 24, 153, 157, 156,
3272 231, 159, 230, 156, 196, 196, 153, 156, 153, 153,
3273 156, 156, 156, 156, 156, 4, 21, 159, 178, 237,
3274 36, 159, 156, 156, 196, 196, 196, 230, 228, 159,
3275 178, 21, 156, 156, 156, 153, 228, 230, 21, 153,
3276 235, 230, 21, 21, 230, 230
3279 #define yyerrok (yyerrstatus = 0)
3280 #define yyclearin (yychar = YYEMPTY)
3281 #define YYEMPTY (-2)
3284 #define YYACCEPT goto yyacceptlab
3285 #define YYABORT goto yyabortlab
3286 #define YYERROR goto yyerrorlab
3289 /* Like YYERROR except do call yyerror. This remains here temporarily
3290 to ease the transition to the new meaning of YYERROR, for GCC.
3291 Once GCC version 2 has supplanted version 1, this can go. */
3293 #define YYFAIL goto yyerrlab
3295 #define YYRECOVERING() (!!yyerrstatus)
3297 #define YYBACKUP(Token, Value) \
3299 if (yychar == YYEMPTY && yylen == 1) \
3303 yytoken = YYTRANSLATE (yychar); \
3309 yyerror (YY_("syntax error: cannot back up")); \
3316 #define YYERRCODE 256
3319 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3320 If N is 0, then set CURRENT to the empty location which ends
3321 the previous symbol: RHS[0] (always defined). */
3323 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3324 #ifndef YYLLOC_DEFAULT
3325 # define YYLLOC_DEFAULT(Current, Rhs, N) \
3329 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
3330 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
3331 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
3332 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
3336 (Current).first_line = (Current).last_line = \
3337 YYRHSLOC (Rhs, 0).last_line; \
3338 (Current).first_column = (Current).last_column = \
3339 YYRHSLOC (Rhs, 0).last_column; \
3345 /* YY_LOCATION_PRINT -- Print the location on the stream.
3346 This macro was not mandated originally: define only if we know
3347 we won't break user code: when these are the locations we know. */
3349 #ifndef YY_LOCATION_PRINT
3350 # if YYLTYPE_IS_TRIVIAL
3351 # define YY_LOCATION_PRINT(File, Loc) \
3352 fprintf (File, "%d.%d-%d.%d", \
3353 (Loc).first_line, (Loc).first_column, \
3354 (Loc).last_line, (Loc).last_column)
3356 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3361 /* YYLEX -- calling `yylex' with the right arguments. */
3364 # define YYLEX yylex (YYLEX_PARAM)
3366 # define YYLEX yylex ()
3369 /* Enable debugging if requested. */
3373 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3374 # define YYFPRINTF fprintf
3377 # define YYDPRINTF(Args) \
3383 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3387 YYFPRINTF (stderr, "%s ", Title); \
3388 yysymprint (stderr, \
3390 YYFPRINTF (stderr, "\n"); \
3394 /*------------------------------------------------------------------.
3395 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3397 `------------------------------------------------------------------*/
3399 #if defined (__STDC__) || defined (__cplusplus)
3401 yy_stack_print (short int *bottom, short int *top)
3404 yy_stack_print (bottom, top)
3409 YYFPRINTF (stderr, "Stack now");
3410 for (/* Nothing. */; bottom <= top; ++bottom)
3411 YYFPRINTF (stderr, " %d", *bottom);
3412 YYFPRINTF (stderr, "\n");
3415 # define YY_STACK_PRINT(Bottom, Top) \
3418 yy_stack_print ((Bottom), (Top)); \
3422 /*------------------------------------------------.
3423 | Report that the YYRULE is going to be reduced. |
3424 `------------------------------------------------*/
3426 #if defined (__STDC__) || defined (__cplusplus)
3428 yy_reduce_print (int yyrule)
3431 yy_reduce_print (yyrule)
3436 unsigned long int yylno = yyrline[yyrule];
3437 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
3439 /* Print the symbols being reduced, and their result. */
3440 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
3441 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3442 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
3445 # define YY_REDUCE_PRINT(Rule) \
3448 yy_reduce_print (Rule); \
3451 /* Nonzero means print parse trace. It is left uninitialized so that
3452 multiple parsers can coexist. */
3454 #else /* !YYDEBUG */
3455 # define YYDPRINTF(Args)
3456 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3457 # define YY_STACK_PRINT(Bottom, Top)
3458 # define YY_REDUCE_PRINT(Rule)
3459 #endif /* !YYDEBUG */
3462 /* YYINITDEPTH -- initial size of the parser's stacks. */
3464 # define YYINITDEPTH 200
3467 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3468 if the built-in stack extension method is used).
3470 Do not make this value too large; the results are undefined if
3471 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3472 evaluated with infinite-precision integer arithmetic. */
3475 # define YYMAXDEPTH 10000
3483 # if defined (__GLIBC__) && defined (_STRING_H)
3484 # define yystrlen strlen
3486 /* Return the length of YYSTR. */
3488 # if defined (__STDC__) || defined (__cplusplus)
3489 yystrlen (const char *yystr)
3495 const char *yys = yystr;
3497 while (*yys++ != '\0')
3500 return yys - yystr - 1;
3506 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3507 # define yystpcpy stpcpy
3509 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3512 # if defined (__STDC__) || defined (__cplusplus)
3513 yystpcpy (char *yydest, const char *yysrc)
3515 yystpcpy (yydest, yysrc)
3521 const char *yys = yysrc;
3523 while ((*yyd++ = *yys++) != '\0')
3532 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3533 quotes and backslashes, so that it's suitable for yyerror. The
3534 heuristic is that double-quoting is unnecessary unless the string
3535 contains an apostrophe, a comma, or backslash (other than
3536 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3537 null, do not copy; instead, return the length of what the result
3540 yytnamerr (char *yyres, const char *yystr)
3545 char const *yyp = yystr;
3552 goto do_not_strip_quotes;
3556 goto do_not_strip_quotes;
3569 do_not_strip_quotes: ;
3573 return yystrlen (yystr);
3575 return yystpcpy (yyres, yystr) - yyres;
3579 #endif /* YYERROR_VERBOSE */
3584 /*--------------------------------.
3585 | Print this symbol on YYOUTPUT. |
3586 `--------------------------------*/
3588 #if defined (__STDC__) || defined (__cplusplus)
3590 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3593 yysymprint (yyoutput, yytype, yyvaluep)
3599 /* Pacify ``unused variable'' warnings. */
3602 if (yytype < YYNTOKENS)
3603 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3605 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3609 if (yytype < YYNTOKENS)
3610 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3617 YYFPRINTF (yyoutput, ")");
3620 #endif /* ! YYDEBUG */
3621 /*-----------------------------------------------.
3622 | Release the memory associated to this symbol. |
3623 `-----------------------------------------------*/
3625 #if defined (__STDC__) || defined (__cplusplus)
3627 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3630 yydestruct (yymsg, yytype, yyvaluep)
3636 /* Pacify ``unused variable'' warnings. */
3641 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3652 /* Prevent warnings from -Wmissing-prototypes. */
3654 #ifdef YYPARSE_PARAM
3655 # if defined (__STDC__) || defined (__cplusplus)
3656 int yyparse (void *YYPARSE_PARAM);
3660 #else /* ! YYPARSE_PARAM */
3661 #if defined (__STDC__) || defined (__cplusplus)
3666 #endif /* ! YYPARSE_PARAM */
3670 /* The look-ahead symbol. */
3673 /* The semantic value of the look-ahead symbol. */
3676 /* Number of syntax errors so far. */
3685 #ifdef YYPARSE_PARAM
3686 # if defined (__STDC__) || defined (__cplusplus)
3687 int yyparse (void *YYPARSE_PARAM)
3689 int yyparse (YYPARSE_PARAM)
3690 void *YYPARSE_PARAM;
3692 #else /* ! YYPARSE_PARAM */
3693 #if defined (__STDC__) || defined (__cplusplus)
3707 /* Number of tokens to shift before error messages enabled. */
3709 /* Look-ahead token as an internal (translated) token number. */
3712 /* Three stacks and their tools:
3713 `yyss': related to states,
3714 `yyvs': related to semantic values,
3715 `yyls': related to locations.
3717 Refer to the stacks thru separate pointers, to allow yyoverflow
3718 to reallocate them elsewhere. */
3720 /* The state stack. */
3721 short int yyssa[YYINITDEPTH];
3722 short int *yyss = yyssa;
3725 /* The semantic value stack. */
3726 YYSTYPE yyvsa[YYINITDEPTH];
3727 YYSTYPE *yyvs = yyvsa;
3732 #define YYPOPSTACK (yyvsp--, yyssp--)
3734 YYSIZE_T yystacksize = YYINITDEPTH;
3736 /* The variables used to return semantic value and location from the
3741 /* When reducing, the number of symbols on the RHS of the reduced
3745 YYDPRINTF ((stderr, "Starting parse\n"));
3750 yychar = YYEMPTY; /* Cause a token to be read. */
3752 /* Initialize stack pointers.
3753 Waste one element of value and location stack
3754 so that they stay on the same level as the state stack.
3755 The wasted elements are never initialized. */
3762 /*------------------------------------------------------------.
3763 | yynewstate -- Push a new state, which is found in yystate. |
3764 `------------------------------------------------------------*/
3766 /* In all cases, when you get here, the value and location stacks
3767 have just been pushed. so pushing a state here evens the stacks.
3774 if (yyss + yystacksize - 1 <= yyssp)
3776 /* Get the current used size of the three stacks, in elements. */
3777 YYSIZE_T yysize = yyssp - yyss + 1;
3781 /* Give user a chance to reallocate the stack. Use copies of
3782 these so that the &'s don't force the real ones into
3784 YYSTYPE *yyvs1 = yyvs;
3785 short int *yyss1 = yyss;
3788 /* Each stack pointer address is followed by the size of the
3789 data in use in that stack, in bytes. This used to be a
3790 conditional around just the two extra args, but that might
3791 be undefined if yyoverflow is a macro. */
3792 yyoverflow (YY_("memory exhausted"),
3793 &yyss1, yysize * sizeof (*yyssp),
3794 &yyvs1, yysize * sizeof (*yyvsp),
3801 #else /* no yyoverflow */
3802 # ifndef YYSTACK_RELOCATE
3803 goto yyexhaustedlab;
3805 /* Extend the stack our own way. */
3806 if (YYMAXDEPTH <= yystacksize)
3807 goto yyexhaustedlab;
3809 if (YYMAXDEPTH < yystacksize)
3810 yystacksize = YYMAXDEPTH;
3813 short int *yyss1 = yyss;
3814 union yyalloc *yyptr =
3815 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3817 goto yyexhaustedlab;
3818 YYSTACK_RELOCATE (yyss);
3819 YYSTACK_RELOCATE (yyvs);
3821 # undef YYSTACK_RELOCATE
3823 YYSTACK_FREE (yyss1);
3826 #endif /* no yyoverflow */
3828 yyssp = yyss + yysize - 1;
3829 yyvsp = yyvs + yysize - 1;
3832 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3833 (unsigned long int) yystacksize));
3835 if (yyss + yystacksize - 1 <= yyssp)
3839 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3848 /* Do appropriate processing given the current state. */
3849 /* Read a look-ahead token if we need one and don't already have one. */
3852 /* First try to decide what to do without reference to look-ahead token. */
3854 yyn = yypact[yystate];
3855 if (yyn == YYPACT_NINF)
3858 /* Not known => get a look-ahead token if don't already have one. */
3860 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3861 if (yychar == YYEMPTY)
3863 YYDPRINTF ((stderr, "Reading a token: "));
3867 if (yychar <= YYEOF)
3869 yychar = yytoken = YYEOF;
3870 YYDPRINTF ((stderr, "Now at end of input.\n"));
3874 yytoken = YYTRANSLATE (yychar);
3875 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3878 /* If the proper action on seeing token YYTOKEN is to reduce or to
3879 detect an error, take that action. */
3881 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3886 if (yyn == 0 || yyn == YYTABLE_NINF)
3895 /* Shift the look-ahead token. */
3896 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3898 /* Discard the token being shifted unless it is eof. */
3899 if (yychar != YYEOF)
3905 /* Count tokens shifted since error; after three, turn off error
3914 /*-----------------------------------------------------------.
3915 | yydefault -- do the default action for the current state. |
3916 `-----------------------------------------------------------*/
3918 yyn = yydefact[yystate];
3924 /*-----------------------------.
3925 | yyreduce -- Do a reduction. |
3926 `-----------------------------*/
3928 /* yyn is the number of a rule to reduce with. */
3931 /* If YYLEN is nonzero, implement the default value of the action:
3934 Otherwise, the following line sets YYVAL to garbage.
3935 This behavior is undocumented and Bison
3936 users should not rely upon it. Assigning to YYVAL
3937 unconditionally makes the parser a bit smaller, and it avoids a
3938 GCC warning that YYVAL may be used uninitialized. */
3939 yyval = yyvsp[1-yylen];
3942 YY_REDUCE_PRINT (yyn);
3946 #line 1872 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3948 if ((yyvsp[0].UIntVal) > (uint32_t)INT32_MAX) // Outside of my range!
3949 error("Value too large for type");
3950 (yyval.SIntVal) = (int32_t)(yyvsp[0].UIntVal);
3955 #line 1881 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3957 if ((yyvsp[0].UInt64Val) > (uint64_t)INT64_MAX) // Outside of my range!
3958 error("Value too large for type");
3959 (yyval.SInt64Val) = (int64_t)(yyvsp[0].UInt64Val);
3964 #line 1903 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3965 { (yyval.IPred) = ICmpInst::ICMP_EQ; ;}
3969 #line 1903 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3970 { (yyval.IPred) = ICmpInst::ICMP_NE; ;}
3974 #line 1904 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3975 { (yyval.IPred) = ICmpInst::ICMP_SLT; ;}
3979 #line 1904 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3980 { (yyval.IPred) = ICmpInst::ICMP_SGT; ;}
3984 #line 1905 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3985 { (yyval.IPred) = ICmpInst::ICMP_SLE; ;}
3989 #line 1905 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3990 { (yyval.IPred) = ICmpInst::ICMP_SGE; ;}
3994 #line 1906 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
3995 { (yyval.IPred) = ICmpInst::ICMP_ULT; ;}
3999 #line 1906 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4000 { (yyval.IPred) = ICmpInst::ICMP_UGT; ;}
4004 #line 1907 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4005 { (yyval.IPred) = ICmpInst::ICMP_ULE; ;}
4009 #line 1907 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4010 { (yyval.IPred) = ICmpInst::ICMP_UGE; ;}
4014 #line 1911 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4015 { (yyval.FPred) = FCmpInst::FCMP_OEQ; ;}
4019 #line 1911 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4020 { (yyval.FPred) = FCmpInst::FCMP_ONE; ;}
4024 #line 1912 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4025 { (yyval.FPred) = FCmpInst::FCMP_OLT; ;}
4029 #line 1912 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4030 { (yyval.FPred) = FCmpInst::FCMP_OGT; ;}
4034 #line 1913 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4035 { (yyval.FPred) = FCmpInst::FCMP_OLE; ;}
4039 #line 1913 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4040 { (yyval.FPred) = FCmpInst::FCMP_OGE; ;}
4044 #line 1914 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4045 { (yyval.FPred) = FCmpInst::FCMP_ORD; ;}
4049 #line 1914 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4050 { (yyval.FPred) = FCmpInst::FCMP_UNO; ;}
4054 #line 1915 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4055 { (yyval.FPred) = FCmpInst::FCMP_UEQ; ;}
4059 #line 1915 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4060 { (yyval.FPred) = FCmpInst::FCMP_UNE; ;}
4064 #line 1916 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4065 { (yyval.FPred) = FCmpInst::FCMP_ULT; ;}
4069 #line 1916 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4070 { (yyval.FPred) = FCmpInst::FCMP_UGT; ;}
4074 #line 1917 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4075 { (yyval.FPred) = FCmpInst::FCMP_ULE; ;}
4079 #line 1917 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4080 { (yyval.FPred) = FCmpInst::FCMP_UGE; ;}
4084 #line 1918 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4085 { (yyval.FPred) = FCmpInst::FCMP_TRUE; ;}
4089 #line 1919 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4090 { (yyval.FPred) = FCmpInst::FCMP_FALSE; ;}
4094 #line 1950 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4096 (yyval.StrVal) = (yyvsp[-1].StrVal);
4101 #line 1953 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4108 #line 1958 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4109 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
4113 #line 1959 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4114 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
4118 #line 1960 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4119 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
4123 #line 1961 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4124 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
4128 #line 1962 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4129 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
4133 #line 1963 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4134 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
4138 #line 1964 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4139 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
4143 #line 1965 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4144 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
4148 #line 1969 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4149 { (yyval.UIntVal) = OldCallingConv::C; ;}
4153 #line 1970 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4154 { (yyval.UIntVal) = OldCallingConv::C; ;}
4158 #line 1971 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4159 { (yyval.UIntVal) = OldCallingConv::CSRet; ;}
4163 #line 1972 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4164 { (yyval.UIntVal) = OldCallingConv::Fast; ;}
4168 #line 1973 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4169 { (yyval.UIntVal) = OldCallingConv::Cold; ;}
4173 #line 1974 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4174 { (yyval.UIntVal) = OldCallingConv::X86_StdCall; ;}
4178 #line 1975 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4179 { (yyval.UIntVal) = OldCallingConv::X86_FastCall; ;}
4183 #line 1976 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4185 if ((unsigned)(yyvsp[0].UInt64Val) != (yyvsp[0].UInt64Val))
4186 error("Calling conv too large");
4187 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4192 #line 1986 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4193 { (yyval.UIntVal) = 0; ;}
4197 #line 1987 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4199 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4200 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4201 error("Alignment must be a power of two");
4206 #line 1995 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4207 { (yyval.UIntVal) = 0; ;}
4211 #line 1996 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4213 (yyval.UIntVal) = (yyvsp[0].UInt64Val);
4214 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4215 error("Alignment must be a power of two");
4220 #line 2004 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4222 for (unsigned i = 0, e = strlen((yyvsp[0].StrVal)); i != e; ++i)
4223 if ((yyvsp[0].StrVal)[i] == '"' || (yyvsp[0].StrVal)[i] == '\\')
4224 error("Invalid character in section name");
4225 (yyval.StrVal) = (yyvsp[0].StrVal);
4230 #line 2013 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4231 { (yyval.StrVal) = 0; ;}
4235 #line 2014 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4236 { (yyval.StrVal) = (yyvsp[0].StrVal); ;}
4240 #line 2021 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4245 #line 2022 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4250 #line 2026 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4252 CurGV->setSection((yyvsp[0].StrVal));
4253 free((yyvsp[0].StrVal));
4258 #line 2030 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4260 if ((yyvsp[0].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[0].UInt64Val)))
4261 error("Alignment must be a power of two");
4262 CurGV->setAlignment((yyvsp[0].UInt64Val));
4268 #line 2047 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4270 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4271 (yyval.TypeVal).S.makeSignless();
4276 #line 2055 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4278 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4279 (yyval.TypeVal).S.makeSignless();
4284 #line 2062 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4286 if (!UpRefs.empty())
4287 error("Invalid upreference in type: " + (*(yyvsp[0].TypeVal).PAT)->getDescription());
4288 (yyval.TypeVal) = (yyvsp[0].TypeVal);
4293 #line 2076 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4295 (yyval.TypeVal).PAT = new PATypeHolder((yyvsp[0].PrimType).T);
4296 (yyval.TypeVal).S.copy((yyvsp[0].PrimType).S);
4301 #line 2080 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4303 (yyval.TypeVal).PAT = new PATypeHolder(OpaqueType::get());
4304 (yyval.TypeVal).S.makeSignless();
4309 #line 2084 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4310 { // Named types are also simple types...
4311 (yyval.TypeVal).S.copy(getTypeSign((yyvsp[0].ValIDVal)));
4312 const Type* tmp = getType((yyvsp[0].ValIDVal));
4313 (yyval.TypeVal).PAT = new PATypeHolder(tmp);
4318 #line 2089 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4319 { // Type UpReference
4320 if ((yyvsp[0].UInt64Val) > (uint64_t)~0U)
4321 error("Value out of range");
4322 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4323 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[0].UInt64Val), OT)); // Add to vector...
4324 (yyval.TypeVal).PAT = new PATypeHolder(OT);
4325 (yyval.TypeVal).S.makeSignless();
4326 UR_OUT("New Upreference!\n");
4331 #line 2098 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4332 { // Function derived type?
4333 (yyval.TypeVal).S.makeComposite((yyvsp[-3].TypeVal).S);
4334 std::vector<const Type*> Params;
4335 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4336 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4337 Params.push_back(I->PAT->get());
4338 (yyval.TypeVal).S.add(I->S);
4340 FunctionType::ParamAttrsList ParamAttrs;
4341 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4342 if (isVarArg) Params.pop_back();
4344 (yyval.TypeVal).PAT = new PATypeHolder(
4345 HandleUpRefs(FunctionType::get((yyvsp[-3].TypeVal).PAT->get(), Params, isVarArg,
4346 ParamAttrs), (yyval.TypeVal).S));
4347 delete (yyvsp[-3].TypeVal).PAT; // Delete the return type handle
4348 delete (yyvsp[-1].TypeList); // Delete the argument list
4353 #line 2116 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4354 { // Sized array type?
4355 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4356 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(ArrayType::get((yyvsp[-1].TypeVal).PAT->get(),
4357 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4358 delete (yyvsp[-1].TypeVal).PAT;
4363 #line 2122 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4365 const llvm::Type* ElemTy = (yyvsp[-1].TypeVal).PAT->get();
4366 if ((unsigned)(yyvsp[-3].UInt64Val) != (yyvsp[-3].UInt64Val))
4367 error("Unsigned result not equal to signed result");
4368 if (!(ElemTy->isInteger() || ElemTy->isFloatingPoint()))
4369 error("Elements of a VectorType must be integer or floating point");
4370 if (!isPowerOf2_32((yyvsp[-3].UInt64Val)))
4371 error("VectorType length should be a power of 2");
4372 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4373 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(VectorType::get(ElemTy,
4374 (unsigned)(yyvsp[-3].UInt64Val)), (yyval.TypeVal).S));
4375 delete (yyvsp[-1].TypeVal).PAT;
4380 #line 2135 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4381 { // Structure type?
4382 std::vector<const Type*> Elements;
4383 (yyval.TypeVal).S.makeComposite();
4384 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-1].TypeList)->begin(),
4385 E = (yyvsp[-1].TypeList)->end(); I != E; ++I) {
4386 Elements.push_back(I->PAT->get());
4387 (yyval.TypeVal).S.add(I->S);
4389 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements), (yyval.TypeVal).S));
4390 delete (yyvsp[-1].TypeList);
4395 #line 2146 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4396 { // Empty structure type?
4397 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4398 (yyval.TypeVal).S.makeComposite();
4403 #line 2150 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4404 { // Packed Structure type?
4405 (yyval.TypeVal).S.makeComposite();
4406 std::vector<const Type*> Elements;
4407 for (std::list<llvm::PATypeInfo>::iterator I = (yyvsp[-2].TypeList)->begin(),
4408 E = (yyvsp[-2].TypeList)->end(); I != E; ++I) {
4409 Elements.push_back(I->PAT->get());
4410 (yyval.TypeVal).S.add(I->S);
4413 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true),
4414 (yyval.TypeVal).S));
4415 delete (yyvsp[-2].TypeList);
4420 #line 2163 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4421 { // Empty packed structure type?
4422 (yyval.TypeVal).PAT = new PATypeHolder(StructType::get(std::vector<const Type*>(),true));
4423 (yyval.TypeVal).S.makeComposite();
4428 #line 2167 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4430 if ((yyvsp[-1].TypeVal).PAT->get() == Type::LabelTy)
4431 error("Cannot form a pointer to a basic block");
4432 (yyval.TypeVal).S.makeComposite((yyvsp[-1].TypeVal).S);
4433 (yyval.TypeVal).PAT = new PATypeHolder(HandleUpRefs(PointerType::get((yyvsp[-1].TypeVal).PAT->get()),
4434 (yyval.TypeVal).S));
4435 delete (yyvsp[-1].TypeVal).PAT;
4440 #line 2181 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4442 (yyval.TypeList) = new std::list<PATypeInfo>();
4443 (yyval.TypeList)->push_back((yyvsp[0].TypeVal));
4448 #line 2185 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4450 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back((yyvsp[0].TypeVal));
4455 #line 2193 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4458 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4459 VoidTI.S.makeSignless();
4460 ((yyval.TypeList)=(yyvsp[-2].TypeList))->push_back(VoidTI);
4465 #line 2199 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4467 (yyval.TypeList) = new std::list<PATypeInfo>();
4469 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
4470 VoidTI.S.makeSignless();
4471 (yyval.TypeList)->push_back(VoidTI);
4476 #line 2206 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4478 (yyval.TypeList) = new std::list<PATypeInfo>();
4483 #line 2218 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4484 { // Nonempty unsized arr
4485 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-3].TypeVal).PAT->get());
4487 error("Cannot make array constant with type: '" +
4488 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4489 const Type *ETy = ATy->getElementType();
4490 int NumElements = ATy->getNumElements();
4492 // Verify that we have the correct size...
4493 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4494 error("Type mismatch: constant sized array initialized with " +
4495 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4496 itostr(NumElements) + "");
4498 // Verify all elements are correct type!
4499 std::vector<Constant*> Elems;
4500 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4501 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4502 const Type* ValTy = C->getType();
4504 error("Element #" + utostr(i) + " is not of type '" +
4505 ETy->getDescription() +"' as required!\nIt is of type '"+
4506 ValTy->getDescription() + "'");
4509 (yyval.ConstVal).C = ConstantArray::get(ATy, Elems);
4510 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4511 delete (yyvsp[-3].TypeVal).PAT;
4512 delete (yyvsp[-1].ConstVector);
4517 #line 2248 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4519 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
4521 error("Cannot make array constant with type: '" +
4522 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4523 int NumElements = ATy->getNumElements();
4524 if (NumElements != -1 && NumElements != 0)
4525 error("Type mismatch: constant sized array initialized with 0"
4526 " arguments, but has size of " + itostr(NumElements) +"");
4527 (yyval.ConstVal).C = ConstantArray::get(ATy, std::vector<Constant*>());
4528 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4529 delete (yyvsp[-2].TypeVal).PAT;
4534 #line 2261 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4536 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[-2].TypeVal).PAT->get());
4538 error("Cannot make array constant with type: '" +
4539 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4540 int NumElements = ATy->getNumElements();
4541 const Type *ETy = dyn_cast<IntegerType>(ATy->getElementType());
4542 if (!ETy || cast<IntegerType>(ETy)->getBitWidth() != 8)
4543 error("String arrays require type i8, not '" + ETy->getDescription() +
4545 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
4546 if (NumElements != -1 && NumElements != (EndStr-(yyvsp[0].StrVal)))
4547 error("Can't build string constant of size " +
4548 itostr((int)(EndStr-(yyvsp[0].StrVal))) + " when array has size " +
4549 itostr(NumElements) + "");
4550 std::vector<Constant*> Vals;
4551 for (char *C = (char *)(yyvsp[0].StrVal); C != (char *)EndStr; ++C)
4552 Vals.push_back(ConstantInt::get(ETy, *C));
4553 free((yyvsp[0].StrVal));
4554 (yyval.ConstVal).C = ConstantArray::get(ATy, Vals);
4555 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4556 delete (yyvsp[-2].TypeVal).PAT;
4561 #line 2284 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4562 { // Nonempty unsized arr
4563 const VectorType *PTy = dyn_cast<VectorType>((yyvsp[-3].TypeVal).PAT->get());
4565 error("Cannot make packed constant with type: '" +
4566 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4567 const Type *ETy = PTy->getElementType();
4568 int NumElements = PTy->getNumElements();
4569 // Verify that we have the correct size...
4570 if (NumElements != -1 && NumElements != (int)(yyvsp[-1].ConstVector)->size())
4571 error("Type mismatch: constant sized packed initialized with " +
4572 utostr((yyvsp[-1].ConstVector)->size()) + " arguments, but has size of " +
4573 itostr(NumElements) + "");
4574 // Verify all elements are correct type!
4575 std::vector<Constant*> Elems;
4576 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
4577 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4578 const Type* ValTy = C->getType();
4580 error("Element #" + utostr(i) + " is not of type '" +
4581 ETy->getDescription() +"' as required!\nIt is of type '"+
4582 ValTy->getDescription() + "'");
4585 (yyval.ConstVal).C = ConstantVector::get(PTy, Elems);
4586 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4587 delete (yyvsp[-3].TypeVal).PAT;
4588 delete (yyvsp[-1].ConstVector);
4593 #line 2312 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4595 const StructType *STy = dyn_cast<StructType>((yyvsp[-3].TypeVal).PAT->get());
4597 error("Cannot make struct constant with type: '" +
4598 (yyvsp[-3].TypeVal).PAT->get()->getDescription() + "'");
4599 if ((yyvsp[-1].ConstVector)->size() != STy->getNumContainedTypes())
4600 error("Illegal number of initializers for structure type");
4602 // Check to ensure that constants are compatible with the type initializer!
4603 std::vector<Constant*> Fields;
4604 for (unsigned i = 0, e = (yyvsp[-1].ConstVector)->size(); i != e; ++i) {
4605 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
4606 if (C->getType() != STy->getElementType(i))
4607 error("Expected type '" + STy->getElementType(i)->getDescription() +
4608 "' for element #" + utostr(i) + " of structure initializer");
4609 Fields.push_back(C);
4611 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4612 (yyval.ConstVal).S.copy((yyvsp[-3].TypeVal).S);
4613 delete (yyvsp[-3].TypeVal).PAT;
4614 delete (yyvsp[-1].ConstVector);
4619 #line 2334 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4621 const StructType *STy = dyn_cast<StructType>((yyvsp[-2].TypeVal).PAT->get());
4623 error("Cannot make struct constant with type: '" +
4624 (yyvsp[-2].TypeVal).PAT->get()->getDescription() + "'");
4625 if (STy->getNumContainedTypes() != 0)
4626 error("Illegal number of initializers for structure type");
4627 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4628 (yyval.ConstVal).S.copy((yyvsp[-2].TypeVal).S);
4629 delete (yyvsp[-2].TypeVal).PAT;
4634 #line 2345 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4636 const StructType *STy = dyn_cast<StructType>((yyvsp[-5].TypeVal).PAT->get());
4638 error("Cannot make packed struct constant with type: '" +
4639 (yyvsp[-5].TypeVal).PAT->get()->getDescription() + "'");
4640 if ((yyvsp[-2].ConstVector)->size() != STy->getNumContainedTypes())
4641 error("Illegal number of initializers for packed structure type");
4643 // Check to ensure that constants are compatible with the type initializer!
4644 std::vector<Constant*> Fields;
4645 for (unsigned i = 0, e = (yyvsp[-2].ConstVector)->size(); i != e; ++i) {
4646 Constant *C = (*(yyvsp[-2].ConstVector))[i].C;
4647 if (C->getType() != STy->getElementType(i))
4648 error("Expected type '" + STy->getElementType(i)->getDescription() +
4649 "' for element #" + utostr(i) + " of packed struct initializer");
4650 Fields.push_back(C);
4652 (yyval.ConstVal).C = ConstantStruct::get(STy, Fields);
4653 (yyval.ConstVal).S.copy((yyvsp[-5].TypeVal).S);
4654 delete (yyvsp[-5].TypeVal).PAT;
4655 delete (yyvsp[-2].ConstVector);
4660 #line 2367 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4662 const StructType *STy = dyn_cast<StructType>((yyvsp[-4].TypeVal).PAT->get());
4664 error("Cannot make packed struct constant with type: '" +
4665 (yyvsp[-4].TypeVal).PAT->get()->getDescription() + "'");
4666 if (STy->getNumContainedTypes() != 0)
4667 error("Illegal number of initializers for packed structure type");
4668 (yyval.ConstVal).C = ConstantStruct::get(STy, std::vector<Constant*>());
4669 (yyval.ConstVal).S.copy((yyvsp[-4].TypeVal).S);
4670 delete (yyvsp[-4].TypeVal).PAT;
4675 #line 2378 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4677 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4679 error("Cannot make null pointer constant with type: '" +
4680 (yyvsp[-1].TypeVal).PAT->get()->getDescription() + "'");
4681 (yyval.ConstVal).C = ConstantPointerNull::get(PTy);
4682 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4683 delete (yyvsp[-1].TypeVal).PAT;
4688 #line 2387 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4690 (yyval.ConstVal).C = UndefValue::get((yyvsp[-1].TypeVal).PAT->get());
4691 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4692 delete (yyvsp[-1].TypeVal).PAT;
4697 #line 2392 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4699 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
4701 error("Global const reference must be a pointer type, not" +
4702 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
4704 // ConstExprs can exist in the body of a function, thus creating
4705 // GlobalValues whenever they refer to a variable. Because we are in
4706 // the context of a function, getExistingValue will search the functions
4707 // symbol table instead of the module symbol table for the global symbol,
4708 // which throws things all off. To get around this, we just tell
4709 // getExistingValue that we are at global scope here.
4711 Function *SavedCurFn = CurFun.CurrentFunction;
4712 CurFun.CurrentFunction = 0;
4713 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
4714 Value *V = getExistingValue(Ty, (yyvsp[0].ValIDVal));
4715 CurFun.CurrentFunction = SavedCurFn;
4717 // If this is an initializer for a constant pointer, which is referencing a
4718 // (currently) undefined variable, create a stub now that shall be replaced
4719 // in the future with the right type of variable.
4722 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers");
4723 const PointerType *PT = cast<PointerType>(Ty);
4725 // First check to see if the forward references value is already created!
4726 PerModuleInfo::GlobalRefsType::iterator I =
4727 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[0].ValIDVal)));
4729 if (I != CurModule.GlobalRefs.end()) {
4730 V = I->second; // Placeholder already exists, use it...
4731 (yyvsp[0].ValIDVal).destroy();
4734 if ((yyvsp[0].ValIDVal).Type == ValID::NameVal) Name = (yyvsp[0].ValIDVal).Name;
4736 // Create the forward referenced global.
4738 if (const FunctionType *FTy =
4739 dyn_cast<FunctionType>(PT->getElementType())) {
4740 GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
4741 CurModule.CurrentModule);
4743 GV = new GlobalVariable(PT->getElementType(), false,
4744 GlobalValue::ExternalLinkage, 0,
4745 Name, CurModule.CurrentModule);
4748 // Keep track of the fact that we have a forward ref to recycle it
4749 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[0].ValIDVal)), GV));
4753 (yyval.ConstVal).C = cast<GlobalValue>(V);
4754 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4755 delete (yyvsp[-1].TypeVal).PAT; // Free the type handle
4760 #line 2451 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4762 if ((yyvsp[-1].TypeVal).PAT->get() != (yyvsp[0].ConstVal).C->getType())
4763 error("Mismatched types for constant expression");
4764 (yyval.ConstVal) = (yyvsp[0].ConstVal);
4765 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4766 delete (yyvsp[-1].TypeVal).PAT;
4771 #line 2458 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4773 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
4774 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4775 error("Cannot create a null initialized value of this type");
4776 (yyval.ConstVal).C = Constant::getNullValue(Ty);
4777 (yyval.ConstVal).S.copy((yyvsp[-1].TypeVal).S);
4778 delete (yyvsp[-1].TypeVal).PAT;
4783 #line 2466 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4784 { // integral constants
4785 const Type *Ty = (yyvsp[-1].PrimType).T;
4786 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].SInt64Val)))
4787 error("Constant value doesn't fit in type");
4788 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].SInt64Val));
4789 (yyval.ConstVal).S.makeSigned();
4794 #line 2473 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4795 { // integral constants
4796 const Type *Ty = (yyvsp[-1].PrimType).T;
4797 if (!ConstantInt::isValueValidForType(Ty, (yyvsp[0].UInt64Val)))
4798 error("Constant value doesn't fit in type");
4799 (yyval.ConstVal).C = ConstantInt::get(Ty, (yyvsp[0].UInt64Val));
4800 (yyval.ConstVal).S.makeUnsigned();
4805 #line 2480 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4806 { // Boolean constants
4807 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, true);
4808 (yyval.ConstVal).S.makeUnsigned();
4813 #line 2484 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4814 { // Boolean constants
4815 (yyval.ConstVal).C = ConstantInt::get(Type::Int1Ty, false);
4816 (yyval.ConstVal).S.makeUnsigned();
4821 #line 2488 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4822 { // Float & Double constants
4823 if (!ConstantFP::isValueValidForType((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal)))
4824 error("Floating point constant invalid for type");
4825 (yyval.ConstVal).C = ConstantFP::get((yyvsp[-1].PrimType).T, (yyvsp[0].FPVal));
4826 (yyval.ConstVal).S.makeSignless();
4831 #line 2497 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4833 const Type* SrcTy = (yyvsp[-3].ConstVal).C->getType();
4834 const Type* DstTy = (yyvsp[-1].TypeVal).PAT->get();
4835 Signedness SrcSign((yyvsp[-3].ConstVal).S);
4836 Signedness DstSign((yyvsp[-1].TypeVal).S);
4837 if (!SrcTy->isFirstClassType())
4838 error("cast constant expression from a non-primitive type: '" +
4839 SrcTy->getDescription() + "'");
4840 if (!DstTy->isFirstClassType())
4841 error("cast constant expression to a non-primitive type: '" +
4842 DstTy->getDescription() + "'");
4843 (yyval.ConstVal).C = cast<Constant>(getCast((yyvsp[-5].CastOpVal), (yyvsp[-3].ConstVal).C, SrcSign, DstTy, DstSign));
4844 (yyval.ConstVal).S.copy(DstSign);
4845 delete (yyvsp[-1].TypeVal).PAT;
4850 #line 2512 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4852 const Type *Ty = (yyvsp[-2].ConstVal).C->getType();
4853 if (!isa<PointerType>(Ty))
4854 error("GetElementPtr requires a pointer operand");
4856 std::vector<Value*> VIndices;
4857 std::vector<Constant*> CIndices;
4858 upgradeGEPIndices((yyvsp[-2].ConstVal).C->getType(), (yyvsp[-1].ValueList), VIndices, &CIndices);
4860 delete (yyvsp[-1].ValueList);
4861 (yyval.ConstVal).C = ConstantExpr::getGetElementPtr((yyvsp[-2].ConstVal).C, &CIndices[0], CIndices.size());
4862 (yyval.ConstVal).S.copy(getElementSign((yyvsp[-2].ConstVal), CIndices));
4867 #line 2525 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4869 if (!(yyvsp[-5].ConstVal).C->getType()->isInteger() ||
4870 cast<IntegerType>((yyvsp[-5].ConstVal).C->getType())->getBitWidth() != 1)
4871 error("Select condition must be bool type");
4872 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4873 error("Select operand types must match");
4874 (yyval.ConstVal).C = ConstantExpr::getSelect((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4875 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4880 #line 2534 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4882 const Type *Ty = (yyvsp[-3].ConstVal).C->getType();
4883 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4884 error("Binary operator types must match");
4885 // First, make sure we're dealing with the right opcode by upgrading from
4886 // obsolete versions.
4887 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4889 // HACK: llvm 1.3 and earlier used to emit invalid pointer constant exprs.
4890 // To retain backward compatibility with these early compilers, we emit a
4891 // cast to the appropriate integer type automatically if we are in the
4892 // broken case. See PR424 for more information.
4893 if (!isa<PointerType>(Ty)) {
4894 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4896 const Type *IntPtrTy = 0;
4897 switch (CurModule.CurrentModule->getPointerSize()) {
4898 case Module::Pointer32: IntPtrTy = Type::Int32Ty; break;
4899 case Module::Pointer64: IntPtrTy = Type::Int64Ty; break;
4900 default: error("invalid pointer binary constant expr");
4902 (yyval.ConstVal).C = ConstantExpr::get(Opcode,
4903 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-3].ConstVal).C, IntPtrTy),
4904 ConstantExpr::getCast(Instruction::PtrToInt, (yyvsp[-1].ConstVal).C, IntPtrTy));
4905 (yyval.ConstVal).C = ConstantExpr::getCast(Instruction::IntToPtr, (yyval.ConstVal).C, Ty);
4907 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4912 #line 2562 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4914 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4915 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4916 error("Logical operator types must match");
4917 if (!Ty->isInteger()) {
4918 if (!isa<VectorType>(Ty) ||
4919 !cast<VectorType>(Ty)->getElementType()->isInteger())
4920 error("Logical operator requires integer operands");
4922 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S);
4923 (yyval.ConstVal).C = ConstantExpr::get(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4924 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4929 #line 2575 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4931 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4932 if (Ty != (yyvsp[-1].ConstVal).C->getType())
4933 error("setcc operand types must match");
4934 unsigned short pred;
4935 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-5].BinaryOpVal), pred, Ty, (yyvsp[-3].ConstVal).S);
4936 (yyval.ConstVal).C = ConstantExpr::getCompare(Opcode, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4937 (yyval.ConstVal).S.makeUnsigned();
4942 #line 2584 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4944 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4945 error("icmp operand types must match");
4946 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].IPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4947 (yyval.ConstVal).S.makeUnsigned();
4952 #line 2590 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4954 if ((yyvsp[-3].ConstVal).C->getType() != (yyvsp[-1].ConstVal).C->getType())
4955 error("fcmp operand types must match");
4956 (yyval.ConstVal).C = ConstantExpr::getCompare((yyvsp[-5].FPred), (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4957 (yyval.ConstVal).S.makeUnsigned();
4962 #line 2596 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4964 if (!(yyvsp[-1].ConstVal).C->getType()->isInteger() ||
4965 cast<IntegerType>((yyvsp[-1].ConstVal).C->getType())->getBitWidth() != 8)
4966 error("Shift count for shift constant must be unsigned byte");
4967 const Type* Ty = (yyvsp[-3].ConstVal).C->getType();
4968 if (!(yyvsp[-3].ConstVal).C->getType()->isInteger())
4969 error("Shift constant expression requires integer operand");
4970 Constant *ShiftAmt = ConstantExpr::getZExt((yyvsp[-1].ConstVal).C, Ty);
4971 (yyval.ConstVal).C = ConstantExpr::get(getBinaryOp((yyvsp[-5].BinaryOpVal), Ty, (yyvsp[-3].ConstVal).S), (yyvsp[-3].ConstVal).C, ShiftAmt);
4972 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S);
4977 #line 2607 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4979 if (!ExtractElementInst::isValidOperands((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4980 error("Invalid extractelement operands");
4981 (yyval.ConstVal).C = ConstantExpr::getExtractElement((yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4982 (yyval.ConstVal).S.copy((yyvsp[-3].ConstVal).S.get(0));
4987 #line 2613 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4989 if (!InsertElementInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
4990 error("Invalid insertelement operands");
4991 (yyval.ConstVal).C = ConstantExpr::getInsertElement((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
4992 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
4997 #line 2619 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
4999 if (!ShuffleVectorInst::isValidOperands((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C))
5000 error("Invalid shufflevector operands");
5001 (yyval.ConstVal).C = ConstantExpr::getShuffleVector((yyvsp[-5].ConstVal).C, (yyvsp[-3].ConstVal).C, (yyvsp[-1].ConstVal).C);
5002 (yyval.ConstVal).S.copy((yyvsp[-5].ConstVal).S);
5007 #line 2630 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5008 { ((yyval.ConstVector) = (yyvsp[-2].ConstVector))->push_back((yyvsp[0].ConstVal)); ;}
5012 #line 2631 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5014 (yyval.ConstVector) = new std::vector<ConstInfo>();
5015 (yyval.ConstVector)->push_back((yyvsp[0].ConstVal));
5020 #line 2640 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5021 { (yyval.BoolVal) = false; ;}
5025 #line 2641 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5026 { (yyval.BoolVal) = true; ;}
5030 #line 2653 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5032 (yyval.ModuleVal) = ParserResult = (yyvsp[0].ModuleVal);
5033 CurModule.ModuleDone();
5038 #line 2662 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5039 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); CurFun.FunctionDone(); ;}
5043 #line 2663 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5044 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5048 #line 2664 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5049 { (yyval.ModuleVal) = (yyvsp[-3].ModuleVal); ;}
5053 #line 2665 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5054 { (yyval.ModuleVal) = (yyvsp[-1].ModuleVal); ;}
5058 #line 2666 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5060 (yyval.ModuleVal) = CurModule.CurrentModule;
5061 // Emit an error if there are any unresolved types left.
5062 if (!CurModule.LateResolveTypes.empty()) {
5063 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
5064 if (DID.Type == ValID::NameVal) {
5065 error("Reference to an undefined type: '"+DID.getName() + "'");
5067 error("Reference to an undefined type: #" + itostr(DID.Num));
5074 #line 2682 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5076 // Eagerly resolve types. This is not an optimization, this is a
5077 // requirement that is due to the fact that we could have this:
5079 // %list = type { %list * }
5080 // %list = type { %list * } ; repeated type decl
5082 // If types are not resolved eagerly, then the two types will not be
5083 // determined to be the same type!
5085 ResolveTypeTo((yyvsp[-2].StrVal), (yyvsp[0].TypeVal).PAT->get(), (yyvsp[0].TypeVal).S);
5087 if (!setTypeName((yyvsp[0].TypeVal), (yyvsp[-2].StrVal)) && !(yyvsp[-2].StrVal)) {
5088 // If this is a numbered type that is not a redefinition, add it to the
5090 CurModule.Types.push_back((yyvsp[0].TypeVal).PAT->get());
5091 CurModule.TypeSigns.push_back((yyvsp[0].TypeVal).S);
5093 delete (yyvsp[0].TypeVal).PAT;
5098 #line 2702 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5099 { // Function prototypes can be in const pool
5104 #line 2704 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5105 { // Asm blocks can be in the const pool
5110 #line 2706 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5112 if ((yyvsp[0].ConstVal).C == 0)
5113 error("Global value initializer is not a constant");
5114 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), (yyvsp[-2].Linkage), (yyvsp[-1].BoolVal), (yyvsp[0].ConstVal).C->getType(), (yyvsp[0].ConstVal).C, (yyvsp[0].ConstVal).S);
5119 #line 2710 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5126 #line 2713 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5128 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5129 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5130 (yyvsp[0].TypeVal).S);
5131 delete (yyvsp[0].TypeVal).PAT;
5136 #line 2718 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5143 #line 2721 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5145 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5146 CurGV = ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::DLLImportLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5147 (yyvsp[0].TypeVal).S);
5148 delete (yyvsp[0].TypeVal).PAT;
5153 #line 2726 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5160 #line 2729 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5162 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
5164 ParseGlobalVariable((yyvsp[-3].StrVal), GlobalValue::ExternalWeakLinkage, (yyvsp[-1].BoolVal), Ty, 0,
5165 (yyvsp[0].TypeVal).S);
5166 delete (yyvsp[0].TypeVal).PAT;
5171 #line 2735 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5178 #line 2738 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5184 #line 2740 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5190 #line 2742 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5196 #line 2747 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5198 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
5199 char *EndStr = UnEscapeLexed((yyvsp[0].StrVal), true);
5200 std::string NewAsm((yyvsp[0].StrVal), EndStr);
5201 free((yyvsp[0].StrVal));
5203 if (AsmSoFar.empty())
5204 CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
5206 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
5211 #line 2761 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5212 { (yyval.Endianness) = Module::BigEndian; ;}
5216 #line 2762 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5217 { (yyval.Endianness) = Module::LittleEndian; ;}
5221 #line 2766 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5223 CurModule.setEndianness((yyvsp[0].Endianness));
5228 #line 2769 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5230 if ((yyvsp[0].UInt64Val) == 32)
5231 CurModule.setPointerSize(Module::Pointer32);
5232 else if ((yyvsp[0].UInt64Val) == 64)
5233 CurModule.setPointerSize(Module::Pointer64);
5235 error("Invalid pointer size: '" + utostr((yyvsp[0].UInt64Val)) + "'");
5240 #line 2777 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5242 CurModule.CurrentModule->setTargetTriple((yyvsp[0].StrVal));
5243 free((yyvsp[0].StrVal));
5248 #line 2781 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5250 CurModule.CurrentModule->setDataLayout((yyvsp[0].StrVal));
5251 free((yyvsp[0].StrVal));
5256 #line 2792 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5258 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5259 free((yyvsp[0].StrVal));
5264 #line 2796 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5266 CurModule.CurrentModule->addLibrary((yyvsp[0].StrVal));
5267 free((yyvsp[0].StrVal));
5272 #line 2800 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5277 #line 2813 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5278 { (yyval.StrVal) = 0; ;}
5282 #line 2817 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5284 if ((yyvsp[-1].TypeVal).PAT->get() == Type::VoidTy)
5285 error("void typed arguments are invalid");
5286 (yyval.ArgVal) = new std::pair<PATypeInfo, char*>((yyvsp[-1].TypeVal), (yyvsp[0].StrVal));
5291 #line 2825 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5293 (yyval.ArgList) = (yyvsp[-2].ArgList);
5294 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5295 delete (yyvsp[0].ArgVal);
5300 #line 2830 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5302 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5303 (yyval.ArgList)->push_back(*(yyvsp[0].ArgVal));
5304 delete (yyvsp[0].ArgVal);
5309 #line 2838 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5310 { (yyval.ArgList) = (yyvsp[0].ArgList); ;}
5314 #line 2839 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5316 (yyval.ArgList) = (yyvsp[-2].ArgList);
5318 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5319 VoidTI.S.makeSignless();
5320 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5325 #line 2846 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5327 (yyval.ArgList) = new std::vector<std::pair<PATypeInfo,char*> >();
5329 VoidTI.PAT = new PATypeHolder(Type::VoidTy);
5330 VoidTI.S.makeSignless();
5331 (yyval.ArgList)->push_back(std::pair<PATypeInfo, char*>(VoidTI, 0));
5336 #line 2853 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5337 { (yyval.ArgList) = 0; ;}
5341 #line 2857 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5343 UnEscapeLexed((yyvsp[-5].StrVal));
5344 std::string FunctionName((yyvsp[-5].StrVal));
5345 free((yyvsp[-5].StrVal)); // Free strdup'd memory!
5347 const Type* RetTy = (yyvsp[-6].TypeVal).PAT->get();
5349 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
5350 error("LLVM functions cannot return aggregate types");
5353 FTySign.makeComposite((yyvsp[-6].TypeVal).S);
5354 std::vector<const Type*> ParamTyList;
5356 // In LLVM 2.0 the signatures of three varargs intrinsics changed to take
5357 // i8*. We check here for those names and override the parameter list
5358 // types to ensure the prototype is correct.
5359 if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
5360 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5361 } else if (FunctionName == "llvm.va_copy") {
5362 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5363 ParamTyList.push_back(PointerType::get(Type::Int8Ty));
5364 } else if ((yyvsp[-3].ArgList)) { // If there are arguments...
5365 for (std::vector<std::pair<PATypeInfo,char*> >::iterator
5366 I = (yyvsp[-3].ArgList)->begin(), E = (yyvsp[-3].ArgList)->end(); I != E; ++I) {
5367 const Type *Ty = I->first.PAT->get();
5368 ParamTyList.push_back(Ty);
5369 FTySign.add(I->first.S);
5373 bool isVarArg = ParamTyList.size() && ParamTyList.back() == Type::VoidTy;
5375 ParamTyList.pop_back();
5377 // Convert the CSRet calling convention into the corresponding parameter
5379 FunctionType::ParamAttrsList ParamAttrs;
5380 if ((yyvsp[-7].UIntVal) == OldCallingConv::CSRet) {
5381 ParamAttrs.push_back(FunctionType::NoAttributeSet); // result
5382 ParamAttrs.push_back(FunctionType::StructRetAttribute); // first arg
5385 const FunctionType *FT = FunctionType::get(RetTy, ParamTyList, isVarArg,
5387 const PointerType *PFT = PointerType::get(FT);
5388 delete (yyvsp[-6].TypeVal).PAT;
5391 if (!FunctionName.empty()) {
5392 ID = ValID::create((char*)FunctionName.c_str());
5394 ID = ValID::create((int)CurModule.Values[PFT].size());
5396 ID.S.makeComposite(FTySign);
5399 Module* M = CurModule.CurrentModule;
5401 // See if this function was forward referenced. If so, recycle the object.
5402 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5403 // Move the function to the end of the list, from whereever it was
5404 // previously inserted.
5405 Fn = cast<Function>(FWRef);
5406 M->getFunctionList().remove(Fn);
5407 M->getFunctionList().push_back(Fn);
5408 } else if (!FunctionName.empty()) {
5409 GlobalValue *Conflict = M->getFunction(FunctionName);
5411 Conflict = M->getNamedGlobal(FunctionName);
5412 if (Conflict && PFT == Conflict->getType()) {
5413 if (!CurFun.isDeclare && !Conflict->isDeclaration()) {
5414 // We have two function definitions that conflict, same type, same
5415 // name. We should really check to make sure that this is the result
5416 // of integer type planes collapsing and generate an error if it is
5417 // not, but we'll just rename on the assumption that it is. However,
5418 // let's do it intelligently and rename the internal linkage one
5420 std::string NewName(makeNameUnique(FunctionName));
5421 if (Conflict->hasInternalLinkage()) {
5422 Conflict->setName(NewName);
5424 makeRenameMapKey(FunctionName, Conflict->getType(), ID.S);
5425 CurModule.RenameMap[Key] = NewName;
5426 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5427 InsertValue(Fn, CurModule.Values);
5429 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5430 InsertValue(Fn, CurModule.Values);
5432 makeRenameMapKey(FunctionName, PFT, ID.S);
5433 CurModule.RenameMap[Key] = NewName;
5436 // If they are not both definitions, then just use the function we
5437 // found since the types are the same.
5438 Fn = cast<Function>(Conflict);
5440 // Make sure to strip off any argument names so we can't get
5442 if (Fn->isDeclaration())
5443 for (Function::arg_iterator AI = Fn->arg_begin(),
5444 AE = Fn->arg_end(); AI != AE; ++AI)
5447 } else if (Conflict) {
5448 // We have two globals with the same name and different types.
5449 // Previously, this was permitted because the symbol table had
5450 // "type planes" and names only needed to be distinct within a
5451 // type plane. After PR411 was fixed, this is no loner the case.
5452 // To resolve this we must rename one of the two.
5453 if (Conflict->hasInternalLinkage()) {
5454 // We can safely rename the Conflict.
5456 makeRenameMapKey(Conflict->getName(), Conflict->getType(),
5457 CurModule.NamedValueSigns[Conflict->getName()]);
5458 Conflict->setName(makeNameUnique(Conflict->getName()));
5459 CurModule.RenameMap[Key] = Conflict->getName();
5460 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5461 InsertValue(Fn, CurModule.Values);
5463 // We can't quietly rename either of these things, but we must
5464 // rename one of them. Only if the function's linkage is internal can
5465 // we forgo a warning message about the renamed function.
5466 std::string NewName = makeNameUnique(FunctionName);
5467 if (CurFun.Linkage != GlobalValue::InternalLinkage) {
5468 warning("Renaming function '" + FunctionName + "' as '" + NewName +
5469 "' may cause linkage errors");
5471 // Elect to rename the thing we're now defining.
5472 Fn = new Function(FT, CurFun.Linkage, NewName, M);
5473 InsertValue(Fn, CurModule.Values);
5474 RenameMapKey Key = makeRenameMapKey(FunctionName, PFT, ID.S);
5475 CurModule.RenameMap[Key] = NewName;
5478 // There's no conflict, just define the function
5479 Fn = new Function(FT, CurFun.Linkage, FunctionName, M);
5480 InsertValue(Fn, CurModule.Values);
5484 CurFun.FunctionStart(Fn);
5486 if (CurFun.isDeclare) {
5487 // If we have declaration, always overwrite linkage. This will allow us
5488 // to correctly handle cases, when pointer to function is passed as
5489 // argument to another function.
5490 Fn->setLinkage(CurFun.Linkage);
5492 Fn->setCallingConv(upgradeCallingConv((yyvsp[-7].UIntVal)));
5493 Fn->setAlignment((yyvsp[0].UIntVal));
5494 if ((yyvsp[-1].StrVal)) {
5495 Fn->setSection((yyvsp[-1].StrVal));
5496 free((yyvsp[-1].StrVal));
5499 // Add all of the arguments we parsed to the function...
5500 if ((yyvsp[-3].ArgList)) { // Is null if empty...
5501 if (isVarArg) { // Nuke the last entry
5502 assert((yyvsp[-3].ArgList)->back().first.PAT->get() == Type::VoidTy &&
5503 (yyvsp[-3].ArgList)->back().second == 0 && "Not a varargs marker");
5504 delete (yyvsp[-3].ArgList)->back().first.PAT;
5505 (yyvsp[-3].ArgList)->pop_back(); // Delete the last entry
5507 Function::arg_iterator ArgIt = Fn->arg_begin();
5508 Function::arg_iterator ArgEnd = Fn->arg_end();
5509 std::vector<std::pair<PATypeInfo,char*> >::iterator I = (yyvsp[-3].ArgList)->begin();
5510 std::vector<std::pair<PATypeInfo,char*> >::iterator E = (yyvsp[-3].ArgList)->end();
5511 for ( ; I != E && ArgIt != ArgEnd; ++I, ++ArgIt) {
5512 delete I->first.PAT; // Delete the typeholder...
5513 ValueInfo VI; VI.V = ArgIt; VI.S.copy(I->first.S);
5514 setValueName(VI, I->second); // Insert arg into symtab...
5517 delete (yyvsp[-3].ArgList); // We're now done with the argument list
5523 #line 3042 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5524 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5528 #line 3042 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5530 (yyval.FunctionVal) = CurFun.CurrentFunction;
5532 // Make sure that we keep track of the linkage type even if there was a
5533 // previous "declare".
5534 (yyval.FunctionVal)->setLinkage((yyvsp[-3].Linkage));
5539 #line 3056 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5541 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5546 #line 3061 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5547 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
5551 #line 3062 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5552 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
5556 #line 3063 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5557 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
5561 #line 3067 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5562 { CurFun.isDeclare = true; ;}
5566 #line 3068 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5567 { CurFun.Linkage = (yyvsp[0].Linkage); ;}
5571 #line 3068 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5573 (yyval.FunctionVal) = CurFun.CurrentFunction;
5574 CurFun.FunctionDone();
5580 #line 3080 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5581 { (yyval.BoolVal) = false; ;}
5585 #line 3081 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5586 { (yyval.BoolVal) = true; ;}
5590 #line 3086 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5591 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SInt64Val)); ;}
5595 #line 3087 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5596 { (yyval.ValIDVal) = ValID::create((yyvsp[0].UInt64Val)); ;}
5600 #line 3088 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5601 { (yyval.ValIDVal) = ValID::create((yyvsp[0].FPVal)); ;}
5605 #line 3089 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5607 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, true));
5608 (yyval.ValIDVal).S.makeUnsigned();
5613 #line 3093 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5615 (yyval.ValIDVal) = ValID::create(ConstantInt::get(Type::Int1Ty, false));
5616 (yyval.ValIDVal).S.makeUnsigned();
5621 #line 3097 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5622 { (yyval.ValIDVal) = ValID::createNull(); ;}
5626 #line 3098 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5627 { (yyval.ValIDVal) = ValID::createUndef(); ;}
5631 #line 3099 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5632 { (yyval.ValIDVal) = ValID::createZeroInit(); ;}
5636 #line 3100 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5637 { // Nonempty unsized packed vector
5638 const Type *ETy = (*(yyvsp[-1].ConstVector))[0].C->getType();
5639 int NumElements = (yyvsp[-1].ConstVector)->size();
5640 VectorType* pt = VectorType::get(ETy, NumElements);
5641 (yyval.ValIDVal).S.makeComposite((*(yyvsp[-1].ConstVector))[0].S);
5642 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt, (yyval.ValIDVal).S));
5644 // Verify all elements are correct type!
5645 std::vector<Constant*> Elems;
5646 for (unsigned i = 0; i < (yyvsp[-1].ConstVector)->size(); i++) {
5647 Constant *C = (*(yyvsp[-1].ConstVector))[i].C;
5648 const Type *CTy = C->getType();
5650 error("Element #" + utostr(i) + " is not of type '" +
5651 ETy->getDescription() +"' as required!\nIt is of type '" +
5652 CTy->getDescription() + "'");
5655 (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, Elems));
5656 delete PTy; delete (yyvsp[-1].ConstVector);
5661 #line 3121 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5663 (yyval.ValIDVal) = ValID::create((yyvsp[0].ConstVal).C);
5664 (yyval.ValIDVal).S.copy((yyvsp[0].ConstVal).S);
5669 #line 3125 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5671 char *End = UnEscapeLexed((yyvsp[-2].StrVal), true);
5672 std::string AsmStr = std::string((yyvsp[-2].StrVal), End);
5673 End = UnEscapeLexed((yyvsp[0].StrVal), true);
5674 std::string Constraints = std::string((yyvsp[0].StrVal), End);
5675 (yyval.ValIDVal) = ValID::createInlineAsm(AsmStr, Constraints, (yyvsp[-3].BoolVal));
5676 free((yyvsp[-2].StrVal));
5677 free((yyvsp[0].StrVal));
5682 #line 3139 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5683 { (yyval.ValIDVal) = ValID::create((yyvsp[0].SIntVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5687 #line 3140 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5688 { (yyval.ValIDVal) = ValID::create((yyvsp[0].StrVal)); (yyval.ValIDVal).S.makeSignless(); ;}
5692 #line 3153 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5694 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
5695 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
5696 (yyval.ValueVal).V = getVal(Ty, (yyvsp[0].ValIDVal));
5697 (yyval.ValueVal).S.copy((yyvsp[-1].TypeVal).S);
5698 delete (yyvsp[-1].TypeVal).PAT;
5703 #line 3163 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5705 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5710 #line 3166 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5711 { // Do not allow functions with 0 basic blocks
5712 (yyval.FunctionVal) = (yyvsp[-1].FunctionVal);
5717 #line 3175 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5719 ValueInfo VI; VI.V = (yyvsp[0].TermInstVal).TI; VI.S.copy((yyvsp[0].TermInstVal).S);
5720 setValueName(VI, (yyvsp[-1].StrVal));
5721 InsertValue((yyvsp[0].TermInstVal).TI);
5722 (yyvsp[-2].BasicBlockVal)->getInstList().push_back((yyvsp[0].TermInstVal).TI);
5723 InsertValue((yyvsp[-2].BasicBlockVal));
5724 (yyval.BasicBlockVal) = (yyvsp[-2].BasicBlockVal);
5729 #line 3186 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5731 if ((yyvsp[0].InstVal).I)
5732 (yyvsp[-1].BasicBlockVal)->getInstList().push_back((yyvsp[0].InstVal).I);
5733 (yyval.BasicBlockVal) = (yyvsp[-1].BasicBlockVal);
5738 #line 3191 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5740 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((int)CurFun.NextBBNum++),true);
5741 // Make sure to move the basic block to the correct location in the
5742 // function, instead of leaving it inserted wherever it was first
5744 Function::BasicBlockListType &BBL =
5745 CurFun.CurrentFunction->getBasicBlockList();
5746 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5751 #line 3200 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5753 (yyval.BasicBlockVal) = CurBB = getBBVal(ValID::create((yyvsp[0].StrVal)), true);
5754 // Make sure to move the basic block to the correct location in the
5755 // function, instead of leaving it inserted wherever it was first
5757 Function::BasicBlockListType &BBL =
5758 CurFun.CurrentFunction->getBasicBlockList();
5759 BBL.splice(BBL.end(), BBL, (yyval.BasicBlockVal));
5764 #line 3214 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5765 { // Return with a result...
5766 (yyval.TermInstVal).TI = new ReturnInst((yyvsp[0].ValueVal).V);
5767 (yyval.TermInstVal).S.makeSignless();
5772 #line 3218 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5773 { // Return with no result...
5774 (yyval.TermInstVal).TI = new ReturnInst();
5775 (yyval.TermInstVal).S.makeSignless();
5780 #line 3222 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5781 { // Unconditional Branch...
5782 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5783 (yyval.TermInstVal).TI = new BranchInst(tmpBB);
5784 (yyval.TermInstVal).S.makeSignless();
5789 #line 3227 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5791 (yyvsp[-3].ValIDVal).S.makeSignless();
5792 (yyvsp[0].ValIDVal).S.makeSignless();
5793 BasicBlock* tmpBBA = getBBVal((yyvsp[-3].ValIDVal));
5794 BasicBlock* tmpBBB = getBBVal((yyvsp[0].ValIDVal));
5795 (yyvsp[-6].ValIDVal).S.makeUnsigned();
5796 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[-6].ValIDVal));
5797 (yyval.TermInstVal).TI = new BranchInst(tmpBBA, tmpBBB, tmpVal);
5798 (yyval.TermInstVal).S.makeSignless();
5803 #line 3237 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5805 (yyvsp[-6].ValIDVal).S.copy((yyvsp[-7].PrimType).S);
5806 Value* tmpVal = getVal((yyvsp[-7].PrimType).T, (yyvsp[-6].ValIDVal));
5807 (yyvsp[-3].ValIDVal).S.makeSignless();
5808 BasicBlock* tmpBB = getBBVal((yyvsp[-3].ValIDVal));
5809 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, (yyvsp[-1].JumpTable)->size());
5810 (yyval.TermInstVal).TI = S;
5811 (yyval.TermInstVal).S.makeSignless();
5812 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[-1].JumpTable)->begin(),
5813 E = (yyvsp[-1].JumpTable)->end();
5814 for (; I != E; ++I) {
5815 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
5816 S->addCase(CI, I->second);
5818 error("Switch case is constant, but not a simple integer");
5820 delete (yyvsp[-1].JumpTable);
5825 #line 3255 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5827 (yyvsp[-5].ValIDVal).S.copy((yyvsp[-6].PrimType).S);
5828 Value* tmpVal = getVal((yyvsp[-6].PrimType).T, (yyvsp[-5].ValIDVal));
5829 (yyvsp[-2].ValIDVal).S.makeSignless();
5830 BasicBlock* tmpBB = getBBVal((yyvsp[-2].ValIDVal));
5831 SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
5832 (yyval.TermInstVal).TI = S;
5833 (yyval.TermInstVal).S.makeSignless();
5838 #line 3265 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5840 const PointerType *PFTy;
5841 const FunctionType *Ty;
5844 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-10].TypeVal).PAT->get())) ||
5845 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
5846 // Pull out the types of all of the arguments...
5847 std::vector<const Type*> ParamTypes;
5848 FTySign.makeComposite((yyvsp[-10].TypeVal).S);
5849 if ((yyvsp[-7].ValueList)) {
5850 for (std::vector<ValueInfo>::iterator I = (yyvsp[-7].ValueList)->begin(), E = (yyvsp[-7].ValueList)->end();
5852 ParamTypes.push_back((*I).V->getType());
5856 FunctionType::ParamAttrsList ParamAttrs;
5857 if ((yyvsp[-11].UIntVal) == OldCallingConv::CSRet) {
5858 ParamAttrs.push_back(FunctionType::NoAttributeSet);
5859 ParamAttrs.push_back(FunctionType::StructRetAttribute);
5861 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
5862 if (isVarArg) ParamTypes.pop_back();
5863 Ty = FunctionType::get((yyvsp[-10].TypeVal).PAT->get(), ParamTypes, isVarArg, ParamAttrs);
5864 PFTy = PointerType::get(Ty);
5865 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S);
5867 FTySign = (yyvsp[-10].TypeVal).S;
5868 (yyval.TermInstVal).S.copy((yyvsp[-10].TypeVal).S.get(0)); // 0th element of FuncTy sign is result ty
5870 (yyvsp[-9].ValIDVal).S.makeComposite(FTySign);
5871 Value *V = getVal(PFTy, (yyvsp[-9].ValIDVal)); // Get the function we're calling...
5872 BasicBlock *Normal = getBBVal((yyvsp[-3].ValIDVal));
5873 BasicBlock *Except = getBBVal((yyvsp[0].ValIDVal));
5875 // Create the call node...
5876 if (!(yyvsp[-7].ValueList)) { // Has no arguments?
5877 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, 0, 0);
5878 } else { // Has arguments?
5879 // Loop through FunctionType's arguments and ensure they are specified
5882 FunctionType::param_iterator I = Ty->param_begin();
5883 FunctionType::param_iterator E = Ty->param_end();
5884 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-7].ValueList)->begin(), ArgE = (yyvsp[-7].ValueList)->end();
5886 std::vector<Value*> Args;
5887 for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
5888 if ((*ArgI).V->getType() != *I)
5889 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
5890 (*I)->getDescription() + "'");
5891 Args.push_back((*ArgI).V);
5894 if (I != E || (ArgI != ArgE && !Ty->isVarArg()))
5895 error("Invalid number of parameters detected");
5897 (yyval.TermInstVal).TI = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
5899 cast<InvokeInst>((yyval.TermInstVal).TI)->setCallingConv(upgradeCallingConv((yyvsp[-11].UIntVal)));
5900 delete (yyvsp[-10].TypeVal).PAT;
5901 delete (yyvsp[-7].ValueList);
5906 #line 3329 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5908 (yyval.TermInstVal).TI = new UnwindInst();
5909 (yyval.TermInstVal).S.makeSignless();
5914 #line 3333 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5916 (yyval.TermInstVal).TI = new UnreachableInst();
5917 (yyval.TermInstVal).S.makeSignless();
5922 #line 3340 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5924 (yyval.JumpTable) = (yyvsp[-5].JumpTable);
5925 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5926 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5929 error("May only switch on a constant pool value");
5931 (yyvsp[0].ValIDVal).S.makeSignless();
5932 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5933 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5938 #line 3352 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5940 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
5941 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-4].PrimType).S);
5942 Constant *V = cast<Constant>(getExistingValue((yyvsp[-4].PrimType).T, (yyvsp[-3].ValIDVal)));
5945 error("May only switch on a constant pool value");
5947 (yyvsp[0].ValIDVal).S.makeSignless();
5948 BasicBlock* tmpBB = getBBVal((yyvsp[0].ValIDVal));
5949 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
5954 #line 3367 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5957 if ((yyvsp[-1].StrVal))
5958 if (BitCastInst *BCI = dyn_cast<BitCastInst>((yyvsp[0].InstVal).I))
5959 if (BCI->getSrcTy() == BCI->getDestTy() &&
5960 BCI->getOperand(0)->getName() == (yyvsp[-1].StrVal))
5961 // This is a useless bit cast causing a name redefinition. It is
5962 // a bit cast from a type to the same type of an operand with the
5963 // same name as the name we would give this instruction. Since this
5964 // instruction results in no code generation, it is safe to omit
5965 // the instruction. This situation can occur because of collapsed
5966 // type planes. For example:
5967 // %X = add int %Y, %Z
5968 // %X = cast int %Y to uint
5969 // After upgrade, this looks like:
5970 // %X = add i32 %Y, %Z
5971 // %X = bitcast i32 to i32
5972 // The bitcast is clearly useless so we omit it.
5975 (yyval.InstVal).I = 0;
5976 (yyval.InstVal).S.makeSignless();
5978 ValueInfo VI; VI.V = (yyvsp[0].InstVal).I; VI.S.copy((yyvsp[0].InstVal).S);
5979 setValueName(VI, (yyvsp[-1].StrVal));
5980 InsertValue((yyvsp[0].InstVal).I);
5981 (yyval.InstVal) = (yyvsp[0].InstVal);
5987 #line 3397 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
5988 { // Used for PHI nodes
5989 (yyval.PHIList).P = new std::list<std::pair<Value*, BasicBlock*> >();
5990 (yyval.PHIList).S.copy((yyvsp[-5].TypeVal).S);
5991 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-5].TypeVal).S);
5992 Value* tmpVal = getVal((yyvsp[-5].TypeVal).PAT->get(), (yyvsp[-3].ValIDVal));
5993 (yyvsp[-1].ValIDVal).S.makeSignless();
5994 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
5995 (yyval.PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
5996 delete (yyvsp[-5].TypeVal).PAT;
6001 #line 3407 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6003 (yyval.PHIList) = (yyvsp[-6].PHIList);
6004 (yyvsp[-3].ValIDVal).S.copy((yyvsp[-6].PHIList).S);
6005 Value* tmpVal = getVal((yyvsp[-6].PHIList).P->front().first->getType(), (yyvsp[-3].ValIDVal));
6006 (yyvsp[-1].ValIDVal).S.makeSignless();
6007 BasicBlock* tmpBB = getBBVal((yyvsp[-1].ValIDVal));
6008 (yyvsp[-6].PHIList).P->push_back(std::make_pair(tmpVal, tmpBB));
6013 #line 3417 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6014 { // Used for call statements, and memory insts...
6015 (yyval.ValueList) = new std::vector<ValueInfo>();
6016 (yyval.ValueList)->push_back((yyvsp[0].ValueVal));
6021 #line 3421 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6023 (yyval.ValueList) = (yyvsp[-2].ValueList);
6024 (yyvsp[-2].ValueList)->push_back((yyvsp[0].ValueVal));
6029 #line 3429 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6030 { (yyval.ValueList) = 0; ;}
6034 #line 3433 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6036 (yyval.BoolVal) = true;
6041 #line 3436 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6043 (yyval.BoolVal) = false;
6048 #line 3442 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6050 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6051 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6052 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6053 if (!Ty->isInteger() && !Ty->isFloatingPoint() && !isa<VectorType>(Ty))
6054 error("Arithmetic operator requires integer, FP, or packed operands");
6055 if (isa<VectorType>(Ty) &&
6056 ((yyvsp[-4].BinaryOpVal) == URemOp || (yyvsp[-4].BinaryOpVal) == SRemOp || (yyvsp[-4].BinaryOpVal) == FRemOp || (yyvsp[-4].BinaryOpVal) == RemOp))
6057 error("Remainder not supported on vector types");
6058 // Upgrade the opcode from obsolete versions before we do anything with it.
6059 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6060 Value* val1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6061 Value* val2 = getVal(Ty, (yyvsp[0].ValIDVal));
6062 (yyval.InstVal).I = BinaryOperator::create(Opcode, val1, val2);
6063 if ((yyval.InstVal).I == 0)
6064 error("binary operator returned null");
6065 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6066 delete (yyvsp[-3].TypeVal).PAT;
6071 #line 3461 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6073 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6074 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6075 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6076 if (!Ty->isInteger()) {
6077 if (!isa<VectorType>(Ty) ||
6078 !cast<VectorType>(Ty)->getElementType()->isInteger())
6079 error("Logical operator requires integral operands");
6081 Instruction::BinaryOps Opcode = getBinaryOp((yyvsp[-4].BinaryOpVal), Ty, (yyvsp[-3].TypeVal).S);
6082 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6083 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6084 (yyval.InstVal).I = BinaryOperator::create(Opcode, tmpVal1, tmpVal2);
6085 if ((yyval.InstVal).I == 0)
6086 error("binary operator returned null");
6087 (yyval.InstVal).S.copy((yyvsp[-3].TypeVal).S);
6088 delete (yyvsp[-3].TypeVal).PAT;
6093 #line 3479 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6095 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6096 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6097 const Type* Ty = (yyvsp[-3].TypeVal).PAT->get();
6098 if(isa<VectorType>(Ty))
6099 error("VectorTypes currently not supported in setcc instructions");
6100 unsigned short pred;
6101 Instruction::OtherOps Opcode = getCompareOp((yyvsp[-4].BinaryOpVal), pred, Ty, (yyvsp[-3].TypeVal).S);
6102 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6103 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6104 (yyval.InstVal).I = CmpInst::create(Opcode, pred, tmpVal1, tmpVal2);
6105 if ((yyval.InstVal).I == 0)
6106 error("binary operator returned null");
6107 (yyval.InstVal).S.makeUnsigned();
6108 delete (yyvsp[-3].TypeVal).PAT;
6113 #line 3495 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6115 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6116 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6117 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6118 if (isa<VectorType>(Ty))
6119 error("VectorTypes currently not supported in icmp instructions");
6120 else if (!Ty->isInteger() && !isa<PointerType>(Ty))
6121 error("icmp requires integer or pointer typed operands");
6122 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6123 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6124 (yyval.InstVal).I = new ICmpInst((yyvsp[-4].IPred), tmpVal1, tmpVal2);
6125 (yyval.InstVal).S.makeUnsigned();
6126 delete (yyvsp[-3].TypeVal).PAT;
6131 #line 3509 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6133 (yyvsp[-2].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6134 (yyvsp[0].ValIDVal).S.copy((yyvsp[-3].TypeVal).S);
6135 const Type *Ty = (yyvsp[-3].TypeVal).PAT->get();
6136 if (isa<VectorType>(Ty))
6137 error("VectorTypes currently not supported in fcmp instructions");
6138 else if (!Ty->isFloatingPoint())
6139 error("fcmp instruction requires floating point operands");
6140 Value* tmpVal1 = getVal(Ty, (yyvsp[-2].ValIDVal));
6141 Value* tmpVal2 = getVal(Ty, (yyvsp[0].ValIDVal));
6142 (yyval.InstVal).I = new FCmpInst((yyvsp[-4].FPred), tmpVal1, tmpVal2);
6143 (yyval.InstVal).S.makeUnsigned();
6144 delete (yyvsp[-3].TypeVal).PAT;
6149 #line 3523 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6151 warning("Use of obsolete 'not' instruction: Replacing with 'xor");
6152 const Type *Ty = (yyvsp[0].ValueVal).V->getType();
6153 Value *Ones = ConstantInt::getAllOnesValue(Ty);
6155 error("Expected integral type for not instruction");
6156 (yyval.InstVal).I = BinaryOperator::create(Instruction::Xor, (yyvsp[0].ValueVal).V, Ones);
6157 if ((yyval.InstVal).I == 0)
6158 error("Could not create a xor instruction");
6159 (yyval.InstVal).S.copy((yyvsp[0].ValueVal).S);
6164 #line 3534 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6166 if (!(yyvsp[0].ValueVal).V->getType()->isInteger() ||
6167 cast<IntegerType>((yyvsp[0].ValueVal).V->getType())->getBitWidth() != 8)
6168 error("Shift amount must be int8");
6169 const Type* Ty = (yyvsp[-2].ValueVal).V->getType();
6170 if (!Ty->isInteger())
6171 error("Shift constant expression requires integer operand");
6172 Value* ShiftAmt = 0;
6173 if (cast<IntegerType>(Ty)->getBitWidth() > Type::Int8Ty->getBitWidth())
6174 if (Constant *C = dyn_cast<Constant>((yyvsp[0].ValueVal).V))
6175 ShiftAmt = ConstantExpr::getZExt(C, Ty);
6177 ShiftAmt = new ZExtInst((yyvsp[0].ValueVal).V, Ty, makeNameUnique("shift"), CurBB);
6179 ShiftAmt = (yyvsp[0].ValueVal).V;
6180 (yyval.InstVal).I = BinaryOperator::create(getBinaryOp((yyvsp[-3].BinaryOpVal), Ty, (yyvsp[-2].ValueVal).S), (yyvsp[-2].ValueVal).V, ShiftAmt);
6181 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6186 #line 3552 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6188 const Type *DstTy = (yyvsp[0].TypeVal).PAT->get();
6189 if (!DstTy->isFirstClassType())
6190 error("cast instruction to a non-primitive type: '" +
6191 DstTy->getDescription() + "'");
6192 (yyval.InstVal).I = cast<Instruction>(getCast((yyvsp[-3].CastOpVal), (yyvsp[-2].ValueVal).V, (yyvsp[-2].ValueVal).S, DstTy, (yyvsp[0].TypeVal).S, true));
6193 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6194 delete (yyvsp[0].TypeVal).PAT;
6199 #line 3561 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6201 if (!(yyvsp[-4].ValueVal).V->getType()->isInteger() ||
6202 cast<IntegerType>((yyvsp[-4].ValueVal).V->getType())->getBitWidth() != 1)
6203 error("select condition must be bool");
6204 if ((yyvsp[-2].ValueVal).V->getType() != (yyvsp[0].ValueVal).V->getType())
6205 error("select value types should match");
6206 (yyval.InstVal).I = new SelectInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6207 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S);
6212 #line 3570 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6214 const Type *Ty = (yyvsp[0].TypeVal).PAT->get();
6216 (yyval.InstVal).I = new VAArgInst((yyvsp[-2].ValueVal).V, Ty);
6217 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6218 delete (yyvsp[0].TypeVal).PAT;
6223 #line 3577 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6225 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6226 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6227 ObsoleteVarArgs = true;
6228 Function* NF = cast<Function>(CurModule.CurrentModule->
6229 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6232 //foo = alloca 1 of t
6236 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
6237 CurBB->getInstList().push_back(foo);
6238 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6239 CurBB->getInstList().push_back(bar);
6240 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6241 (yyval.InstVal).I = new VAArgInst(foo, DstTy);
6242 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6243 delete (yyvsp[0].TypeVal).PAT;
6248 #line 3598 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6250 const Type* ArgTy = (yyvsp[-2].ValueVal).V->getType();
6251 const Type* DstTy = (yyvsp[0].TypeVal).PAT->get();
6252 ObsoleteVarArgs = true;
6253 Function* NF = cast<Function>(CurModule.CurrentModule->
6254 getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy, (Type *)0));
6256 //b = vanext a, t ->
6257 //foo = alloca 1 of t
6260 //tmp = vaarg foo, t
6262 AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
6263 CurBB->getInstList().push_back(foo);
6264 CallInst* bar = new CallInst(NF, (yyvsp[-2].ValueVal).V);
6265 CurBB->getInstList().push_back(bar);
6266 CurBB->getInstList().push_back(new StoreInst(bar, foo));
6267 Instruction* tmp = new VAArgInst(foo, DstTy);
6268 CurBB->getInstList().push_back(tmp);
6269 (yyval.InstVal).I = new LoadInst(foo);
6270 (yyval.InstVal).S.copy((yyvsp[0].TypeVal).S);
6271 delete (yyvsp[0].TypeVal).PAT;
6276 #line 3622 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6278 if (!ExtractElementInst::isValidOperands((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6279 error("Invalid extractelement operands");
6280 (yyval.InstVal).I = new ExtractElementInst((yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6281 (yyval.InstVal).S.copy((yyvsp[-2].ValueVal).S.get(0));
6286 #line 3628 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6288 if (!InsertElementInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6289 error("Invalid insertelement operands");
6290 (yyval.InstVal).I = new InsertElementInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6291 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6296 #line 3634 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6298 if (!ShuffleVectorInst::isValidOperands((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V))
6299 error("Invalid shufflevector operands");
6300 (yyval.InstVal).I = new ShuffleVectorInst((yyvsp[-4].ValueVal).V, (yyvsp[-2].ValueVal).V, (yyvsp[0].ValueVal).V);
6301 (yyval.InstVal).S.copy((yyvsp[-4].ValueVal).S);
6306 #line 3640 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6308 const Type *Ty = (yyvsp[0].PHIList).P->front().first->getType();
6309 if (!Ty->isFirstClassType())
6310 error("PHI node operands must be of first class type");
6311 PHINode *PHI = new PHINode(Ty);
6312 PHI->reserveOperandSpace((yyvsp[0].PHIList).P->size());
6313 while ((yyvsp[0].PHIList).P->begin() != (yyvsp[0].PHIList).P->end()) {
6314 if ((yyvsp[0].PHIList).P->front().first->getType() != Ty)
6315 error("All elements of a PHI node must be of the same type");
6316 PHI->addIncoming((yyvsp[0].PHIList).P->front().first, (yyvsp[0].PHIList).P->front().second);
6317 (yyvsp[0].PHIList).P->pop_front();
6319 (yyval.InstVal).I = PHI;
6320 (yyval.InstVal).S.copy((yyvsp[0].PHIList).S);
6321 delete (yyvsp[0].PHIList).P; // Free the list...
6326 #line 3656 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6328 // Handle the short call syntax
6329 const PointerType *PFTy;
6330 const FunctionType *FTy;
6332 if (!(PFTy = dyn_cast<PointerType>((yyvsp[-4].TypeVal).PAT->get())) ||
6333 !(FTy = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6334 // Pull out the types of all of the arguments...
6335 std::vector<const Type*> ParamTypes;
6336 FTySign.makeComposite((yyvsp[-4].TypeVal).S);
6337 if ((yyvsp[-1].ValueList)) {
6338 for (std::vector<ValueInfo>::iterator I = (yyvsp[-1].ValueList)->begin(), E = (yyvsp[-1].ValueList)->end();
6340 ParamTypes.push_back((*I).V->getType());
6345 FunctionType::ParamAttrsList ParamAttrs;
6346 if ((yyvsp[-5].UIntVal) == OldCallingConv::CSRet) {
6347 ParamAttrs.push_back(FunctionType::NoAttributeSet);
6348 ParamAttrs.push_back(FunctionType::StructRetAttribute);
6350 bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
6351 if (isVarArg) ParamTypes.pop_back();
6353 const Type *RetTy = (yyvsp[-4].TypeVal).PAT->get();
6354 if (!RetTy->isFirstClassType() && RetTy != Type::VoidTy)
6355 error("Functions cannot return aggregate types");
6357 FTy = FunctionType::get(RetTy, ParamTypes, isVarArg, ParamAttrs);
6358 PFTy = PointerType::get(FTy);
6359 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S);
6361 FTySign = (yyvsp[-4].TypeVal).S;
6362 (yyval.InstVal).S.copy((yyvsp[-4].TypeVal).S.get(0)); // 0th element of FuncTy signedness is result sign
6364 (yyvsp[-3].ValIDVal).S.makeComposite(FTySign);
6366 // First upgrade any intrinsic calls.
6367 std::vector<Value*> Args;
6368 if ((yyvsp[-1].ValueList))
6369 for (unsigned i = 0, e = (yyvsp[-1].ValueList)->size(); i < e; ++i)
6370 Args.push_back((*(yyvsp[-1].ValueList))[i].V);
6371 Instruction *Inst = upgradeIntrinsicCall(FTy->getReturnType(), (yyvsp[-3].ValIDVal), Args);
6373 // If we got an upgraded intrinsic
6375 (yyval.InstVal).I = Inst;
6377 // Get the function we're calling
6378 Value *V = getVal(PFTy, (yyvsp[-3].ValIDVal));
6380 // Check the argument values match
6381 if (!(yyvsp[-1].ValueList)) { // Has no arguments?
6382 // Make sure no arguments is a good thing!
6383 if (FTy->getNumParams() != 0)
6384 error("No arguments passed to a function that expects arguments");
6385 } else { // Has arguments?
6386 // Loop through FunctionType's arguments and ensure they are specified
6389 FunctionType::param_iterator I = FTy->param_begin();
6390 FunctionType::param_iterator E = FTy->param_end();
6391 std::vector<ValueInfo>::iterator ArgI = (yyvsp[-1].ValueList)->begin(), ArgE = (yyvsp[-1].ValueList)->end();
6393 for (; ArgI != ArgE && I != E; ++ArgI, ++I)
6394 if ((*ArgI).V->getType() != *I)
6395 error("Parameter " +(*ArgI).V->getName()+ " is not of type '" +
6396 (*I)->getDescription() + "'");
6398 if (I != E || (ArgI != ArgE && !FTy->isVarArg()))
6399 error("Invalid number of parameters detected");
6402 // Create the call instruction
6403 CallInst *CI = new CallInst(V, &Args[0], Args.size());
6404 CI->setTailCall((yyvsp[-6].BoolVal));
6405 CI->setCallingConv(upgradeCallingConv((yyvsp[-5].UIntVal)));
6406 (yyval.InstVal).I = CI;
6408 delete (yyvsp[-4].TypeVal).PAT;
6409 delete (yyvsp[-1].ValueList);
6414 #line 3740 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6416 (yyval.InstVal) = (yyvsp[0].InstVal);
6421 #line 3748 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6422 { (yyval.ValueList) = (yyvsp[0].ValueList); ;}
6426 #line 3749 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6427 { (yyval.ValueList) = new std::vector<ValueInfo>(); ;}
6431 #line 3753 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6432 { (yyval.BoolVal) = true; ;}
6436 #line 3754 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6437 { (yyval.BoolVal) = false; ;}
6441 #line 3758 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6443 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6444 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6445 (yyval.InstVal).I = new MallocInst(Ty, 0, (yyvsp[0].UIntVal));
6446 delete (yyvsp[-1].TypeVal).PAT;
6451 #line 3764 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6453 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6454 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6455 (yyval.InstVal).S.makeComposite((yyvsp[-4].TypeVal).S);
6456 (yyval.InstVal).I = new MallocInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6457 delete (yyvsp[-4].TypeVal).PAT;
6462 #line 3771 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6464 const Type *Ty = (yyvsp[-1].TypeVal).PAT->get();
6465 (yyval.InstVal).S.makeComposite((yyvsp[-1].TypeVal).S);
6466 (yyval.InstVal).I = new AllocaInst(Ty, 0, (yyvsp[0].UIntVal));
6467 delete (yyvsp[-1].TypeVal).PAT;
6472 #line 3777 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6474 const Type *Ty = (yyvsp[-4].TypeVal).PAT->get();
6475 (yyvsp[-1].ValIDVal).S.makeUnsigned();
6476 (yyval.InstVal).S.makeComposite((yyvsp[-2].PrimType).S);
6477 (yyval.InstVal).I = new AllocaInst(Ty, getVal((yyvsp[-2].PrimType).T, (yyvsp[-1].ValIDVal)), (yyvsp[0].UIntVal));
6478 delete (yyvsp[-4].TypeVal).PAT;
6483 #line 3784 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6485 const Type *PTy = (yyvsp[0].ValueVal).V->getType();
6486 if (!isa<PointerType>(PTy))
6487 error("Trying to free nonpointer type '" + PTy->getDescription() + "'");
6488 (yyval.InstVal).I = new FreeInst((yyvsp[0].ValueVal).V);
6489 (yyval.InstVal).S.makeSignless();
6494 #line 3791 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6496 const Type* Ty = (yyvsp[-1].TypeVal).PAT->get();
6497 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6498 if (!isa<PointerType>(Ty))
6499 error("Can't load from nonpointer type: " + Ty->getDescription());
6500 if (!cast<PointerType>(Ty)->getElementType()->isFirstClassType())
6501 error("Can't load from pointer of non-first-class type: " +
6502 Ty->getDescription());
6503 Value* tmpVal = getVal(Ty, (yyvsp[0].ValIDVal));
6504 (yyval.InstVal).I = new LoadInst(tmpVal, "", (yyvsp[-3].BoolVal));
6505 (yyval.InstVal).S.copy((yyvsp[-1].TypeVal).S.get(0));
6506 delete (yyvsp[-1].TypeVal).PAT;
6511 #line 3804 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6513 (yyvsp[0].ValIDVal).S.copy((yyvsp[-1].TypeVal).S);
6514 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[-1].TypeVal).PAT->get());
6516 error("Can't store to a nonpointer type: " +
6517 (yyvsp[-1].TypeVal).PAT->get()->getDescription());
6518 const Type *ElTy = PTy->getElementType();
6519 Value *StoreVal = (yyvsp[-3].ValueVal).V;
6520 Value* tmpVal = getVal(PTy, (yyvsp[0].ValIDVal));
6521 if (ElTy != (yyvsp[-3].ValueVal).V->getType()) {
6522 StoreVal = handleSRetFuncTypeMerge((yyvsp[-3].ValueVal).V, ElTy);
6524 error("Can't store '" + (yyvsp[-3].ValueVal).V->getType()->getDescription() +
6525 "' into space of type '" + ElTy->getDescription() + "'");
6527 PTy = PointerType::get(StoreVal->getType());
6528 if (Constant *C = dyn_cast<Constant>(tmpVal))
6529 tmpVal = ConstantExpr::getBitCast(C, PTy);
6531 tmpVal = new BitCastInst(tmpVal, PTy, "upgrd.cast", CurBB);
6534 (yyval.InstVal).I = new StoreInst(StoreVal, tmpVal, (yyvsp[-5].BoolVal));
6535 (yyval.InstVal).S.makeSignless();
6536 delete (yyvsp[-1].TypeVal).PAT;
6541 #line 3830 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6543 (yyvsp[-1].ValIDVal).S.copy((yyvsp[-2].TypeVal).S);
6544 const Type* Ty = (yyvsp[-2].TypeVal).PAT->get();
6545 if (!isa<PointerType>(Ty))
6546 error("getelementptr insn requires pointer operand");
6548 std::vector<Value*> VIndices;
6549 upgradeGEPIndices(Ty, (yyvsp[0].ValueList), VIndices);
6551 Value* tmpVal = getVal(Ty, (yyvsp[-1].ValIDVal));
6552 (yyval.InstVal).I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size());
6553 ValueInfo VI; VI.V = tmpVal; VI.S.copy((yyvsp[-2].TypeVal).S);
6554 (yyval.InstVal).S.copy(getElementSign(VI, VIndices));
6555 delete (yyvsp[-2].TypeVal).PAT;
6556 delete (yyvsp[0].ValueList);
6564 /* Line 1126 of yacc.c. */
6565 #line 6566 "UpgradeParser.tab.c"
6571 YY_STACK_PRINT (yyss, yyssp);
6576 /* Now `shift' the result of the reduction. Determine what state
6577 that goes to, based on the state we popped back to and the rule
6578 number reduced by. */
6582 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6583 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6584 yystate = yytable[yystate];
6586 yystate = yydefgoto[yyn - YYNTOKENS];
6591 /*------------------------------------.
6592 | yyerrlab -- here on detecting error |
6593 `------------------------------------*/
6595 /* If not already recovering from an error, report this error. */
6600 yyn = yypact[yystate];
6602 if (YYPACT_NINF < yyn && yyn < YYLAST)
6604 int yytype = YYTRANSLATE (yychar);
6605 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
6606 YYSIZE_T yysize = yysize0;
6608 int yysize_overflow = 0;
6610 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
6611 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
6615 /* This is so xgettext sees the translatable formats that are
6616 constructed on the fly. */
6617 YY_("syntax error, unexpected %s");
6618 YY_("syntax error, unexpected %s, expecting %s");
6619 YY_("syntax error, unexpected %s, expecting %s or %s");
6620 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
6621 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
6625 static char const yyunexpected[] = "syntax error, unexpected %s";
6626 static char const yyexpecting[] = ", expecting %s";
6627 static char const yyor[] = " or %s";
6628 char yyformat[sizeof yyunexpected
6629 + sizeof yyexpecting - 1
6630 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
6631 * (sizeof yyor - 1))];
6632 char const *yyprefix = yyexpecting;
6634 /* Start YYX at -YYN if negative to avoid negative indexes in
6636 int yyxbegin = yyn < 0 ? -yyn : 0;
6638 /* Stay within bounds of both yycheck and yytname. */
6639 int yychecklim = YYLAST - yyn;
6640 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
6643 yyarg[0] = yytname[yytype];
6644 yyfmt = yystpcpy (yyformat, yyunexpected);
6646 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
6647 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6649 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
6653 yyformat[sizeof yyunexpected - 1] = '\0';
6656 yyarg[yycount++] = yytname[yyx];
6657 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
6658 yysize_overflow |= yysize1 < yysize;
6660 yyfmt = yystpcpy (yyfmt, yyprefix);
6664 yyf = YY_(yyformat);
6665 yysize1 = yysize + yystrlen (yyf);
6666 yysize_overflow |= yysize1 < yysize;
6669 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
6670 yymsg = (char *) YYSTACK_ALLOC (yysize);
6673 /* Avoid sprintf, as that infringes on the user's name space.
6674 Don't have undefined behavior even if the translation
6675 produced a string with the wrong number of "%s"s. */
6678 while ((*yyp = *yyf))
6680 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
6682 yyp += yytnamerr (yyp, yyarg[yyi++]);
6692 YYSTACK_FREE (yymsg);
6696 yyerror (YY_("syntax error"));
6697 goto yyexhaustedlab;
6701 #endif /* YYERROR_VERBOSE */
6702 yyerror (YY_("syntax error"));
6707 if (yyerrstatus == 3)
6709 /* If just tried and failed to reuse look-ahead token after an
6710 error, discard it. */
6712 if (yychar <= YYEOF)
6714 /* Return failure if at end of input. */
6715 if (yychar == YYEOF)
6720 yydestruct ("Error: discarding", yytoken, &yylval);
6725 /* Else will try to reuse look-ahead token after shifting the error
6730 /*---------------------------------------------------.
6731 | yyerrorlab -- error raised explicitly by YYERROR. |
6732 `---------------------------------------------------*/
6735 /* Pacify compilers like GCC when the user code never invokes
6736 YYERROR and the label yyerrorlab therefore never appears in user
6747 /*-------------------------------------------------------------.
6748 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6749 `-------------------------------------------------------------*/
6751 yyerrstatus = 3; /* Each real token shifted decrements this. */
6755 yyn = yypact[yystate];
6756 if (yyn != YYPACT_NINF)
6759 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6767 /* Pop the current state because it cannot handle the error token. */
6772 yydestruct ("Error: popping", yystos[yystate], yyvsp);
6775 YY_STACK_PRINT (yyss, yyssp);
6784 /* Shift the error token. */
6785 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6791 /*-------------------------------------.
6792 | yyacceptlab -- YYACCEPT comes here. |
6793 `-------------------------------------*/
6798 /*-----------------------------------.
6799 | yyabortlab -- YYABORT comes here. |
6800 `-----------------------------------*/
6806 /*-------------------------------------------------.
6807 | yyexhaustedlab -- memory exhaustion comes here. |
6808 `-------------------------------------------------*/
6810 yyerror (YY_("memory exhausted"));
6816 if (yychar != YYEOF && yychar != YYEMPTY)
6817 yydestruct ("Cleanup: discarding lookahead",
6819 while (yyssp != yyss)
6821 yydestruct ("Cleanup: popping",
6822 yystos[*yyssp], yyvsp);
6827 YYSTACK_FREE (yyss);
6833 #line 3848 "/proj/llvm/llvm-1/tools/llvm-upgrade/UpgradeParser.y"
6836 int yyerror(const char *ErrorMsg) {
6838 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6839 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6840 std::string errMsg = where + "error: " + std::string(ErrorMsg);
6841 if (yychar != YYEMPTY && yychar != 0)
6842 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6844 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6845 std::cout << "llvm-upgrade: parse failed.\n";
6849 void warning(const std::string& ErrorMsg) {
6851 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
6852 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
6853 std::string errMsg = where + "warning: " + std::string(ErrorMsg);
6854 if (yychar != YYEMPTY && yychar != 0)
6855 errMsg += " while reading token '" + std::string(Upgradetext, Upgradeleng) +
6857 std::cerr << "llvm-upgrade: " << errMsg << '\n';
6860 void error(const std::string& ErrorMsg, int LineNo) {
6861 if (LineNo == -1) LineNo = Upgradelineno;
6862 Upgradelineno = LineNo;
6863 yyerror(ErrorMsg.c_str());